1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
|
#include "rb_lapack.h"
extern VOID dlaqp2_(integer* m, integer* n, integer* offset, doublereal* a, integer* lda, integer* jpvt, doublereal* tau, doublereal* vn1, doublereal* vn2, doublereal* work);
static VALUE
rblapack_dlaqp2(int argc, VALUE *argv, VALUE self){
VALUE rblapack_m;
integer m;
VALUE rblapack_offset;
integer offset;
VALUE rblapack_a;
doublereal *a;
VALUE rblapack_jpvt;
integer *jpvt;
VALUE rblapack_vn1;
doublereal *vn1;
VALUE rblapack_vn2;
doublereal *vn2;
VALUE rblapack_tau;
doublereal *tau;
VALUE rblapack_a_out__;
doublereal *a_out__;
VALUE rblapack_jpvt_out__;
integer *jpvt_out__;
VALUE rblapack_vn1_out__;
doublereal *vn1_out__;
VALUE rblapack_vn2_out__;
doublereal *vn2_out__;
doublereal *work;
integer lda;
integer n;
VALUE rblapack_options;
if (argc > 0 && TYPE(argv[argc-1]) == T_HASH) {
argc--;
rblapack_options = argv[argc];
if (rb_hash_aref(rblapack_options, sHelp) == Qtrue) {
printf("%s\n", "USAGE:\n tau, a, jpvt, vn1, vn2 = NumRu::Lapack.dlaqp2( m, offset, a, jpvt, vn1, vn2, [:usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n SUBROUTINE DLAQP2( M, N, OFFSET, A, LDA, JPVT, TAU, VN1, VN2, WORK )\n\n* Purpose\n* =======\n*\n* DLAQP2 computes a QR factorization with column pivoting of\n* the block A(OFFSET+1:M,1:N).\n* The block A(1:OFFSET,1:N) is accordingly pivoted, but not factorized.\n*\n\n* Arguments\n* =========\n*\n* M (input) INTEGER\n* The number of rows of the matrix A. M >= 0.\n*\n* N (input) INTEGER\n* The number of columns of the matrix A. N >= 0.\n*\n* OFFSET (input) INTEGER\n* The number of rows of the matrix A that must be pivoted\n* but no factorized. OFFSET >= 0.\n*\n* A (input/output) DOUBLE PRECISION array, dimension (LDA,N)\n* On entry, the M-by-N matrix A.\n* On exit, the upper triangle of block A(OFFSET+1:M,1:N) is \n* the triangular factor obtained; the elements in block\n* A(OFFSET+1:M,1:N) below the diagonal, together with the\n* array TAU, represent the orthogonal matrix Q as a product of\n* elementary reflectors. Block A(1:OFFSET,1:N) has been\n* accordingly pivoted, but no factorized.\n*\n* LDA (input) INTEGER\n* The leading dimension of the array A. LDA >= max(1,M).\n*\n* JPVT (input/output) INTEGER array, dimension (N)\n* On entry, if JPVT(i) .ne. 0, the i-th column of A is permuted\n* to the front of A*P (a leading column); if JPVT(i) = 0,\n* the i-th column of A is a free column.\n* On exit, if JPVT(i) = k, then the i-th column of A*P\n* was the k-th column of A.\n*\n* TAU (output) DOUBLE PRECISION array, dimension (min(M,N))\n* The scalar factors of the elementary reflectors.\n*\n* VN1 (input/output) DOUBLE PRECISION array, dimension (N)\n* The vector with the partial column norms.\n*\n* VN2 (input/output) DOUBLE PRECISION array, dimension (N)\n* The vector with the exact column norms.\n*\n* WORK (workspace) DOUBLE PRECISION array, dimension (N)\n*\n\n* Further Details\n* ===============\n*\n* Based on contributions by\n* G. Quintana-Orti, Depto. de Informatica, Universidad Jaime I, Spain\n* X. Sun, Computer Science Dept., Duke University, USA\n*\n* Partial column norm updating strategy modified by\n* Z. Drmac and Z. Bujanovic, Dept. of Mathematics,\n* University of Zagreb, Croatia.\n* June 2010\n* For more details see LAPACK Working Note 176.\n* =====================================================================\n*\n\n");
return Qnil;
}
if (rb_hash_aref(rblapack_options, sUsage) == Qtrue) {
printf("%s\n", "USAGE:\n tau, a, jpvt, vn1, vn2 = NumRu::Lapack.dlaqp2( m, offset, a, jpvt, vn1, vn2, [:usage => usage, :help => help])\n");
return Qnil;
}
} else
rblapack_options = Qnil;
if (argc != 6 && argc != 6)
rb_raise(rb_eArgError,"wrong number of arguments (%d for 6)", argc);
rblapack_m = argv[0];
rblapack_offset = argv[1];
rblapack_a = argv[2];
rblapack_jpvt = argv[3];
rblapack_vn1 = argv[4];
rblapack_vn2 = argv[5];
if (argc == 6) {
} else if (rblapack_options != Qnil) {
} else {
}
m = NUM2INT(rblapack_m);
if (!NA_IsNArray(rblapack_a))
rb_raise(rb_eArgError, "a (3th argument) must be NArray");
if (NA_RANK(rblapack_a) != 2)
rb_raise(rb_eArgError, "rank of a (3th argument) must be %d", 2);
lda = NA_SHAPE0(rblapack_a);
n = NA_SHAPE1(rblapack_a);
if (NA_TYPE(rblapack_a) != NA_DFLOAT)
rblapack_a = na_change_type(rblapack_a, NA_DFLOAT);
a = NA_PTR_TYPE(rblapack_a, doublereal*);
if (!NA_IsNArray(rblapack_vn1))
rb_raise(rb_eArgError, "vn1 (5th argument) must be NArray");
if (NA_RANK(rblapack_vn1) != 1)
rb_raise(rb_eArgError, "rank of vn1 (5th argument) must be %d", 1);
if (NA_SHAPE0(rblapack_vn1) != n)
rb_raise(rb_eRuntimeError, "shape 0 of vn1 must be the same as shape 1 of a");
if (NA_TYPE(rblapack_vn1) != NA_DFLOAT)
rblapack_vn1 = na_change_type(rblapack_vn1, NA_DFLOAT);
vn1 = NA_PTR_TYPE(rblapack_vn1, doublereal*);
offset = NUM2INT(rblapack_offset);
if (!NA_IsNArray(rblapack_vn2))
rb_raise(rb_eArgError, "vn2 (6th argument) must be NArray");
if (NA_RANK(rblapack_vn2) != 1)
rb_raise(rb_eArgError, "rank of vn2 (6th argument) must be %d", 1);
if (NA_SHAPE0(rblapack_vn2) != n)
rb_raise(rb_eRuntimeError, "shape 0 of vn2 must be the same as shape 1 of a");
if (NA_TYPE(rblapack_vn2) != NA_DFLOAT)
rblapack_vn2 = na_change_type(rblapack_vn2, NA_DFLOAT);
vn2 = NA_PTR_TYPE(rblapack_vn2, doublereal*);
if (!NA_IsNArray(rblapack_jpvt))
rb_raise(rb_eArgError, "jpvt (4th argument) must be NArray");
if (NA_RANK(rblapack_jpvt) != 1)
rb_raise(rb_eArgError, "rank of jpvt (4th argument) must be %d", 1);
if (NA_SHAPE0(rblapack_jpvt) != n)
rb_raise(rb_eRuntimeError, "shape 0 of jpvt must be the same as shape 1 of a");
if (NA_TYPE(rblapack_jpvt) != NA_LINT)
rblapack_jpvt = na_change_type(rblapack_jpvt, NA_LINT);
jpvt = NA_PTR_TYPE(rblapack_jpvt, integer*);
{
na_shape_t shape[1];
shape[0] = MIN(m,n);
rblapack_tau = na_make_object(NA_DFLOAT, 1, shape, cNArray);
}
tau = NA_PTR_TYPE(rblapack_tau, doublereal*);
{
na_shape_t shape[2];
shape[0] = lda;
shape[1] = n;
rblapack_a_out__ = na_make_object(NA_DFLOAT, 2, shape, cNArray);
}
a_out__ = NA_PTR_TYPE(rblapack_a_out__, doublereal*);
MEMCPY(a_out__, a, doublereal, NA_TOTAL(rblapack_a));
rblapack_a = rblapack_a_out__;
a = a_out__;
{
na_shape_t shape[1];
shape[0] = n;
rblapack_jpvt_out__ = na_make_object(NA_LINT, 1, shape, cNArray);
}
jpvt_out__ = NA_PTR_TYPE(rblapack_jpvt_out__, integer*);
MEMCPY(jpvt_out__, jpvt, integer, NA_TOTAL(rblapack_jpvt));
rblapack_jpvt = rblapack_jpvt_out__;
jpvt = jpvt_out__;
{
na_shape_t shape[1];
shape[0] = n;
rblapack_vn1_out__ = na_make_object(NA_DFLOAT, 1, shape, cNArray);
}
vn1_out__ = NA_PTR_TYPE(rblapack_vn1_out__, doublereal*);
MEMCPY(vn1_out__, vn1, doublereal, NA_TOTAL(rblapack_vn1));
rblapack_vn1 = rblapack_vn1_out__;
vn1 = vn1_out__;
{
na_shape_t shape[1];
shape[0] = n;
rblapack_vn2_out__ = na_make_object(NA_DFLOAT, 1, shape, cNArray);
}
vn2_out__ = NA_PTR_TYPE(rblapack_vn2_out__, doublereal*);
MEMCPY(vn2_out__, vn2, doublereal, NA_TOTAL(rblapack_vn2));
rblapack_vn2 = rblapack_vn2_out__;
vn2 = vn2_out__;
work = ALLOC_N(doublereal, (n));
dlaqp2_(&m, &n, &offset, a, &lda, jpvt, tau, vn1, vn2, work);
free(work);
return rb_ary_new3(5, rblapack_tau, rblapack_a, rblapack_jpvt, rblapack_vn1, rblapack_vn2);
}
void
init_lapack_dlaqp2(VALUE mLapack, VALUE sH, VALUE sU, VALUE zero){
sHelp = sH;
sUsage = sU;
rblapack_ZERO = zero;
rb_define_module_function(mLapack, "dlaqp2", rblapack_dlaqp2, -1);
}
|
