static VALUE rb_gsl_blas_zscal(int argc, VALUE *argv, VALUE obj)
{
gsl_complex *a = NULL;
gsl_vector_complex *x = NULL;
CHECK_COMPLEX(argv[0]);
switch (TYPE(obj)) {
case T_MODULE:
case T_CLASS:
case T_OBJECT:
if (argc != 2) rb_raise(rb_eArgError, "wrong number of arguments (%d for 2)",
argc);
CHECK_VECTOR_COMPLEX(argv[1]);
Data_Get_Struct(argv[0], gsl_complex, a);
Data_Get_Struct(argv[1], gsl_vector_complex, x);
gsl_blas_zscal(*a, x);
return argv[1];
break;
default:
if (argc != 1) rb_raise(rb_eArgError, "wrong number of arguments (%d for 1)",
argc);
Data_Get_Struct(obj, gsl_vector_complex, x);
Data_Get_Struct(argv[0], gsl_complex, a);
gsl_blas_zscal(*a, x);
return obj;
break;
}
}
static VALUE rb_gsl_blas_zscal2(int argc, VALUE *argv, VALUE obj)
{
gsl_complex *a = NULL;
gsl_vector_complex *x = NULL, *xnew = NULL;
CHECK_COMPLEX(argv[0]);
switch (TYPE(obj)) {
case T_MODULE:
case T_CLASS:
case T_OBJECT:
if (argc != 2) rb_raise(rb_eArgError, "wrong number of arguments (%d for 2)",
argc);
CHECK_VECTOR_COMPLEX(argv[1]);
Data_Get_Struct(argv[0], gsl_complex, a);
Data_Get_Struct(argv[1], gsl_vector_complex, x);
break;
default:
if (argc != 1) rb_raise(rb_eArgError, "wrong number of arguments (%d for 1)",
argc);
Data_Get_Struct(obj, gsl_vector_complex, x);
Data_Get_Struct(argv[0], gsl_complex, a);
break;
}
xnew = gsl_vector_complex_alloc(x->size);
gsl_vector_complex_memcpy(xnew, x);
gsl_blas_zscal(*a, xnew);
return Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, xnew);
}
/**
* C++ version of gsl_blas_zscal().
* @param alpha A constant
* @param X A vector
*/
void zscal( complex const& alpha, vector_complex& X ){ gsl_blas_zscal( alpha.get(), X.get() ); }
/** Division operator (complex) */
vector<complex> vector<complex>::operator/(const complex& z) const
{
vector<complex> v1(_vector);
gsl_blas_zscal(z.inverse().as_gsl_type(), v1.as_gsl_type_ptr());
return v1;
}
void
test_eigen_nonsymm_results (const gsl_matrix * m,
const gsl_vector_complex * eval,
const gsl_matrix_complex * evec,
size_t count,
const char * desc,
const char * desc2)
{
size_t i,j;
size_t N = m->size1;
gsl_vector_complex * x = gsl_vector_complex_alloc(N);
gsl_vector_complex * y = gsl_vector_complex_alloc(N);
gsl_matrix_complex * A = gsl_matrix_complex_alloc(N, N);
/* we need a complex matrix for the blas routines, so copy m into A */
for (i = 0; i < N; ++i)
{
for (j = 0; j < N; ++j)
{
gsl_complex z;
GSL_SET_COMPLEX(&z, gsl_matrix_get(m, i, j), 0.0);
gsl_matrix_complex_set(A, i, j, z);
}
}
for (i = 0; i < N; i++)
{
gsl_complex ei = gsl_vector_complex_get (eval, i);
gsl_vector_complex_const_view vi = gsl_matrix_complex_const_column(evec, i);
double norm = gsl_blas_dznrm2(&vi.vector);
/* check that eigenvector is normalized */
gsl_test_rel(norm, 1.0, N * GSL_DBL_EPSILON,
"nonsymm(N=%u,cnt=%u), %s, normalized(%d), %s", N, count, desc, i, desc2);
gsl_vector_complex_memcpy(x, &vi.vector);
/* compute y = m x (should = lambda v) */
gsl_blas_zgemv (CblasNoTrans, GSL_COMPLEX_ONE, A, x,
GSL_COMPLEX_ZERO, y);
/* compute x = lambda v */
gsl_blas_zscal(ei, x);
/* now test if y = x */
for (j = 0; j < N; j++)
{
gsl_complex xj = gsl_vector_complex_get (x, j);
gsl_complex yj = gsl_vector_complex_get (y, j);
/* use abs here in case the values are close to 0 */
gsl_test_abs(GSL_REAL(yj), GSL_REAL(xj), 1e8*GSL_DBL_EPSILON,
"nonsymm(N=%u,cnt=%u), %s, eigenvalue(%d,%d), real, %s", N, count, desc, i, j, desc2);
gsl_test_abs(GSL_IMAG(yj), GSL_IMAG(xj), 1e8*GSL_DBL_EPSILON,
"nonsymm(N=%u,cnt=%u), %s, eigenvalue(%d,%d), imag, %s", N, count, desc, i, j, desc2);
}
}
gsl_matrix_complex_free(A);
gsl_vector_complex_free(x);
gsl_vector_complex_free(y);
}
void
test_eigen_gen_results (const gsl_matrix * A, const gsl_matrix * B,
const gsl_vector_complex * alpha,
const gsl_vector * beta,
const gsl_matrix_complex * evec,
size_t count, const char * desc,
const char * desc2)
{
const size_t N = A->size1;
size_t i, j;
gsl_matrix_complex *ma, *mb;
gsl_vector_complex *x, *y;
gsl_complex z_one, z_zero;
ma = gsl_matrix_complex_alloc(N, N);
mb = gsl_matrix_complex_alloc(N, N);
y = gsl_vector_complex_alloc(N);
x = gsl_vector_complex_alloc(N);
/* ma <- A, mb <- B */
for (i = 0; i < N; ++i)
{
for (j = 0; j < N; ++j)
{
gsl_complex z;
GSL_SET_COMPLEX(&z, gsl_matrix_get(A, i, j), 0.0);
gsl_matrix_complex_set(ma, i, j, z);
GSL_SET_COMPLEX(&z, gsl_matrix_get(B, i, j), 0.0);
gsl_matrix_complex_set(mb, i, j, z);
}
}
GSL_SET_COMPLEX(&z_one, 1.0, 0.0);
GSL_SET_COMPLEX(&z_zero, 0.0, 0.0);
/* check eigenvalues */
for (i = 0; i < N; ++i)
{
gsl_vector_complex_const_view vi =
gsl_matrix_complex_const_column(evec, i);
gsl_complex ai = gsl_vector_complex_get(alpha, i);
double bi = gsl_vector_get(beta, i);
/* compute x = alpha * B * v */
gsl_blas_zgemv(CblasNoTrans, z_one, mb, &vi.vector, z_zero, x);
gsl_blas_zscal(ai, x);
/* compute y = beta * A v */
gsl_blas_zgemv(CblasNoTrans, z_one, ma, &vi.vector, z_zero, y);
gsl_blas_zdscal(bi, y);
/* now test if y = x */
for (j = 0; j < N; ++j)
{
gsl_complex xj = gsl_vector_complex_get(x, j);
gsl_complex yj = gsl_vector_complex_get(y, j);
gsl_test_abs(GSL_REAL(yj), GSL_REAL(xj), 1e8*GSL_DBL_EPSILON,
"gen(N=%u,cnt=%u), %s, eigenvalue(%d,%d), real, %s",
N, count, desc, i, j, desc2);
gsl_test_abs(GSL_IMAG(yj), GSL_IMAG(xj), 1e8*GSL_DBL_EPSILON,
"gen(N=%u,cnt=%u), %s, eigenvalue(%d,%d), real, %s",
N, count, desc, i, j, desc2);
}
}
gsl_matrix_complex_free(ma);
gsl_matrix_complex_free(mb);
gsl_vector_complex_free(y);
gsl_vector_complex_free(x);
} /* test_eigen_gen_results() */
/** Multiplication operator (complex) */
vector<complex> vector<complex>::operator*(const complex& z)
{
vector<complex> v1(_vector);
gsl_blas_zscal(z.as_gsl_type(), v1.as_gsl_type_ptr());
return v1;
}
