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
|
#include "rb_lapack.h"
extern VOID clartv_(integer* n, complex* x, integer* incx, complex* y, integer* incy, real* c, complex* s, integer* incc);
static VALUE
rblapack_clartv(int argc, VALUE *argv, VALUE self){
VALUE rblapack_n;
integer n;
VALUE rblapack_x;
complex *x;
VALUE rblapack_incx;
integer incx;
VALUE rblapack_y;
complex *y;
VALUE rblapack_incy;
integer incy;
VALUE rblapack_c;
real *c;
VALUE rblapack_s;
complex *s;
VALUE rblapack_incc;
integer incc;
VALUE rblapack_x_out__;
complex *x_out__;
VALUE rblapack_y_out__;
complex *y_out__;
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 x, y = NumRu::Lapack.clartv( n, x, incx, y, incy, c, s, incc, [:usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n SUBROUTINE CLARTV( N, X, INCX, Y, INCY, C, S, INCC )\n\n* Purpose\n* =======\n*\n* CLARTV applies a vector of complex plane rotations with real cosines\n* to elements of the complex vectors x and y. For i = 1,2,...,n\n*\n* ( x(i) ) := ( c(i) s(i) ) ( x(i) )\n* ( y(i) ) ( -conjg(s(i)) c(i) ) ( y(i) )\n*\n\n* Arguments\n* =========\n*\n* N (input) INTEGER\n* The number of plane rotations to be applied.\n*\n* X (input/output) COMPLEX array, dimension (1+(N-1)*INCX)\n* The vector x.\n*\n* INCX (input) INTEGER\n* The increment between elements of X. INCX > 0.\n*\n* Y (input/output) COMPLEX array, dimension (1+(N-1)*INCY)\n* The vector y.\n*\n* INCY (input) INTEGER\n* The increment between elements of Y. INCY > 0.\n*\n* C (input) REAL array, dimension (1+(N-1)*INCC)\n* The cosines of the plane rotations.\n*\n* S (input) COMPLEX array, dimension (1+(N-1)*INCC)\n* The sines of the plane rotations.\n*\n* INCC (input) INTEGER\n* The increment between elements of C and S. INCC > 0.\n*\n\n* =====================================================================\n*\n* .. Local Scalars ..\n INTEGER I, IC, IX, IY\n COMPLEX XI, YI\n* ..\n* .. Intrinsic Functions ..\n INTRINSIC CONJG\n* ..\n\n");
return Qnil;
}
if (rb_hash_aref(rblapack_options, sUsage) == Qtrue) {
printf("%s\n", "USAGE:\n x, y = NumRu::Lapack.clartv( n, x, incx, y, incy, c, s, incc, [:usage => usage, :help => help])\n");
return Qnil;
}
} else
rblapack_options = Qnil;
if (argc != 8 && argc != 8)
rb_raise(rb_eArgError,"wrong number of arguments (%d for 8)", argc);
rblapack_n = argv[0];
rblapack_x = argv[1];
rblapack_incx = argv[2];
rblapack_y = argv[3];
rblapack_incy = argv[4];
rblapack_c = argv[5];
rblapack_s = argv[6];
rblapack_incc = argv[7];
if (argc == 8) {
} else if (rblapack_options != Qnil) {
} else {
}
n = NUM2INT(rblapack_n);
incx = NUM2INT(rblapack_incx);
incy = NUM2INT(rblapack_incy);
incc = NUM2INT(rblapack_incc);
if (!NA_IsNArray(rblapack_x))
rb_raise(rb_eArgError, "x (2th argument) must be NArray");
if (NA_RANK(rblapack_x) != 1)
rb_raise(rb_eArgError, "rank of x (2th argument) must be %d", 1);
if (NA_SHAPE0(rblapack_x) != (1+(n-1)*incx))
rb_raise(rb_eRuntimeError, "shape 0 of x must be %d", 1+(n-1)*incx);
if (NA_TYPE(rblapack_x) != NA_SCOMPLEX)
rblapack_x = na_change_type(rblapack_x, NA_SCOMPLEX);
x = NA_PTR_TYPE(rblapack_x, complex*);
if (!NA_IsNArray(rblapack_c))
rb_raise(rb_eArgError, "c (6th argument) must be NArray");
if (NA_RANK(rblapack_c) != 1)
rb_raise(rb_eArgError, "rank of c (6th argument) must be %d", 1);
if (NA_SHAPE0(rblapack_c) != (1+(n-1)*incc))
rb_raise(rb_eRuntimeError, "shape 0 of c must be %d", 1+(n-1)*incc);
if (NA_TYPE(rblapack_c) != NA_SFLOAT)
rblapack_c = na_change_type(rblapack_c, NA_SFLOAT);
c = NA_PTR_TYPE(rblapack_c, real*);
if (!NA_IsNArray(rblapack_y))
rb_raise(rb_eArgError, "y (4th argument) must be NArray");
if (NA_RANK(rblapack_y) != 1)
rb_raise(rb_eArgError, "rank of y (4th argument) must be %d", 1);
if (NA_SHAPE0(rblapack_y) != (1+(n-1)*incy))
rb_raise(rb_eRuntimeError, "shape 0 of y must be %d", 1+(n-1)*incy);
if (NA_TYPE(rblapack_y) != NA_SCOMPLEX)
rblapack_y = na_change_type(rblapack_y, NA_SCOMPLEX);
y = NA_PTR_TYPE(rblapack_y, complex*);
if (!NA_IsNArray(rblapack_s))
rb_raise(rb_eArgError, "s (7th argument) must be NArray");
if (NA_RANK(rblapack_s) != 1)
rb_raise(rb_eArgError, "rank of s (7th argument) must be %d", 1);
if (NA_SHAPE0(rblapack_s) != (1+(n-1)*incc))
rb_raise(rb_eRuntimeError, "shape 0 of s must be %d", 1+(n-1)*incc);
if (NA_TYPE(rblapack_s) != NA_SCOMPLEX)
rblapack_s = na_change_type(rblapack_s, NA_SCOMPLEX);
s = NA_PTR_TYPE(rblapack_s, complex*);
{
na_shape_t shape[1];
shape[0] = 1+(n-1)*incx;
rblapack_x_out__ = na_make_object(NA_SCOMPLEX, 1, shape, cNArray);
}
x_out__ = NA_PTR_TYPE(rblapack_x_out__, complex*);
MEMCPY(x_out__, x, complex, NA_TOTAL(rblapack_x));
rblapack_x = rblapack_x_out__;
x = x_out__;
{
na_shape_t shape[1];
shape[0] = 1+(n-1)*incy;
rblapack_y_out__ = na_make_object(NA_SCOMPLEX, 1, shape, cNArray);
}
y_out__ = NA_PTR_TYPE(rblapack_y_out__, complex*);
MEMCPY(y_out__, y, complex, NA_TOTAL(rblapack_y));
rblapack_y = rblapack_y_out__;
y = y_out__;
clartv_(&n, x, &incx, y, &incy, c, s, &incc);
return rb_ary_new3(2, rblapack_x, rblapack_y);
}
void
init_lapack_clartv(VALUE mLapack, VALUE sH, VALUE sU, VALUE zero){
sHelp = sH;
sUsage = sU;
rblapack_ZERO = zero;
rb_define_module_function(mLapack, "clartv", rblapack_clartv, -1);
}
|
