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 slartv_(integer* n, real* x, integer* incx, real* y, integer* incy, real* c, real* s, integer* incc);
static VALUE
rblapack_slartv(int argc, VALUE *argv, VALUE self){
VALUE rblapack_n;
integer n;
VALUE rblapack_x;
real *x;
VALUE rblapack_incx;
integer incx;
VALUE rblapack_y;
real *y;
VALUE rblapack_incy;
integer incy;
VALUE rblapack_c;
real *c;
VALUE rblapack_s;
real *s;
VALUE rblapack_incc;
integer incc;
VALUE rblapack_x_out__;
real *x_out__;
VALUE rblapack_y_out__;
real *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.slartv( n, x, incx, y, incy, c, s, incc, [:usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n SUBROUTINE SLARTV( N, X, INCX, Y, INCY, C, S, INCC )\n\n* Purpose\n* =======\n*\n* SLARTV applies a vector of real plane rotations to elements of the\n* real vectors x and y. For i = 1,2,...,n\n*\n* ( x(i) ) := ( c(i) s(i) ) ( x(i) )\n* ( y(i) ) ( -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) REAL array,\n* 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) REAL array,\n* 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) REAL 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 REAL XI, YI\n* ..\n\n");
return Qnil;
}
if (rb_hash_aref(rblapack_options, sUsage) == Qtrue) {
printf("%s\n", "USAGE:\n x, y = NumRu::Lapack.slartv( 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_SFLOAT)
rblapack_x = na_change_type(rblapack_x, NA_SFLOAT);
x = NA_PTR_TYPE(rblapack_x, real*);
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_SFLOAT)
rblapack_y = na_change_type(rblapack_y, NA_SFLOAT);
y = NA_PTR_TYPE(rblapack_y, real*);
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_SFLOAT)
rblapack_s = na_change_type(rblapack_s, NA_SFLOAT);
s = NA_PTR_TYPE(rblapack_s, real*);
{
na_shape_t shape[1];
shape[0] = 1+(n-1)*incx;
rblapack_x_out__ = na_make_object(NA_SFLOAT, 1, shape, cNArray);
}
x_out__ = NA_PTR_TYPE(rblapack_x_out__, real*);
MEMCPY(x_out__, x, real, 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_SFLOAT, 1, shape, cNArray);
}
y_out__ = NA_PTR_TYPE(rblapack_y_out__, real*);
MEMCPY(y_out__, y, real, NA_TOTAL(rblapack_y));
rblapack_y = rblapack_y_out__;
y = y_out__;
slartv_(&n, x, &incx, y, &incy, c, s, &incc);
return rb_ary_new3(2, rblapack_x, rblapack_y);
}
void
init_lapack_slartv(VALUE mLapack, VALUE sH, VALUE sU, VALUE zero){
sHelp = sH;
sUsage = sU;
rblapack_ZERO = zero;
rb_define_module_function(mLapack, "slartv", rblapack_slartv, -1);
}
|
