void
test_eigen_nonsymm(void)
{
size_t N_max = 20;
size_t n, i;
gsl_rng *r = gsl_rng_alloc(gsl_rng_default);
for (n = 1; n <= N_max; ++n)
{
gsl_matrix * m = gsl_matrix_alloc(n, n);
gsl_eigen_nonsymmv_workspace * w = gsl_eigen_nonsymmv_alloc(n);
for (i = 0; i < 5; ++i)
{
create_random_nonsymm_matrix(m, r, -10, 10);
gsl_eigen_nonsymmv_params(0, w);
test_eigen_nonsymm_matrix(m, i, "random, unbalanced", w);
gsl_eigen_nonsymmv_params(1, w);
test_eigen_nonsymm_matrix(m, i, "random, balanced", w);
}
gsl_matrix_free(m);
gsl_eigen_nonsymmv_free(w);
}
gsl_rng_free(r);
{
double dat1[] = { 0, 1, 1, 1,
1, 1, 1, 1,
0, 0, 0, 0,
0, 0, 0, 0 };
double dat2[] = { 1, 1, 0, 1,
1, 1, 1, 1,
1, 1, 1, 1,
0, 1, 0, 0 };
gsl_matrix_view v;
gsl_eigen_nonsymmv_workspace * w = gsl_eigen_nonsymmv_alloc(4);
v = gsl_matrix_view_array (dat1, 4, 4);
test_eigen_nonsymm_matrix(&v.matrix, 0, "integer", w);
v = gsl_matrix_view_array (dat2, 4, 4);
test_eigen_nonsymm_matrix(&v.matrix, 1, "integer", w);
gsl_eigen_nonsymmv_free(w);
}
} /* test_eigen_nonsymm() */
void expm(gsl_matrix_complex * L, gsl_complex t, gsl_matrix * m)
{
int i,j,s;
gsl_vector_complex *eval = gsl_vector_complex_alloc(4);
gsl_matrix_complex *evec = gsl_matrix_complex_alloc(4, 4);
gsl_eigen_nonsymmv_workspace * w = gsl_eigen_nonsymmv_alloc(4);
gsl_matrix_complex *evalmat = gsl_matrix_complex_alloc(4, 4);
gsl_matrix_complex *vd = gsl_matrix_complex_alloc(4, 4);
gsl_complex one = gsl_complex_rect(1, 0);
gsl_complex zero = gsl_complex_rect(0, 0);
gsl_matrix_complex *K = gsl_matrix_complex_alloc(4, 4);
gsl_permutation *p = gsl_permutation_alloc(4);
gsl_vector_complex *x = gsl_vector_complex_alloc(4);
gsl_vector_complex_view bp;
gsl_complex z;
gsl_eigen_nonsymmv(m, eval, evec, w);
gsl_eigen_nonsymmv_sort(eval, evec, GSL_EIGEN_SORT_ABS_DESC);
gsl_eigen_nonsymmv_free(w); // clear workspace
for (i = 0; i < 4; i++)
{
gsl_complex eval_i = gsl_vector_complex_get(eval, i);
gsl_complex expeval = gsl_complex_mul(eval_i,t);
expeval = gsl_complex_exp(expeval);
gsl_matrix_complex_set(evalmat, i, i, expeval);
}
gsl_vector_complex_free(eval); // clear vector for eigenvalues
// v'L'=De'v'
gsl_blas_zgemm(CblasTrans, CblasTrans, one, evalmat, evec, zero, vd);
gsl_matrix_complex_transpose(evec);//transpose v
gsl_matrix_complex_memcpy(K,evec);
for (i = 0; i < 4; i++)
{
bp = gsl_matrix_complex_column(vd, i);
gsl_linalg_complex_LU_decomp(evec, p, &s);
gsl_linalg_complex_LU_solve(evec, p, &bp.vector, x);
for (j = 0; j < 4; j++)
{
z = gsl_vector_complex_get(x, j);
gsl_matrix_complex_set(L,i,j,z); //'through the looking glass' transpose
}
gsl_matrix_complex_memcpy(evec,K);
}
gsl_permutation_free(p);
gsl_vector_complex_free(x);
gsl_matrix_complex_free(vd);
gsl_matrix_complex_free(evec);
gsl_matrix_complex_free(evalmat);
gsl_matrix_complex_free(K);
}
//-----------------------------------------------------------------------------
// Returns the eigendecomposition A = X*D*X^-1.
// d is the diagonal entries of D.
// X and d must be preallocated: X should be n x n and d should be length n.
//-----------------------------------------------------------------------------
void eigendecomp (double **A, double complex **X, double complex *d, int n)
{
double *a;
double complex **Xtmp;
double complex *dtmp;
gsl_matrix_view m;
gsl_vector_complex *eval;
gsl_matrix_complex *evec;
gsl_eigen_nonsymmv_workspace *w;
// Use GSL routine to compute eigenvalues and eigenvectors
a = matrixToVector (A, n, n);
m = gsl_matrix_view_array (a, n, n);
eval = gsl_vector_complex_alloc (n);
evec = gsl_matrix_complex_alloc (n, n);
w = gsl_eigen_nonsymmv_alloc (n);
gsl_eigen_nonsymmv (&m.matrix, eval, evec, w);
gsl_eigen_nonsymmv_free (w);
// Convert from GSL to intrinsic types
Xtmp = gslmToCx (evec, n, n);
dtmp = gslvToCx (eval, n);
copycm_inplace (X, Xtmp, n, n);
copycv_inplace (d, dtmp, n);
freecmatrix(Xtmp, n);
free(a);
free(dtmp);
gsl_vector_complex_free(eval);
gsl_matrix_complex_free(evec);
}
void matrix<double>::eigensystem(matrix<complex> &U, vector<complex> &S) {
matrix<double> m(*this);
gsl_eigen_nonsymmv_workspace *ws;
ws = gsl_eigen_nonsymmv_alloc(size_i());
gsl_eigen_nonsymmv(m.as_gsl_type_ptr(), S.as_gsl_type_ptr(),
U.as_gsl_type_ptr(), ws);
gsl_eigen_nonsymmv_free(ws);
}
int
main (void)
{
double data[] = { -1.0, 1.0, -1.0, 1.0,
-8.0, 4.0, -2.0, 1.0,
27.0, 9.0, 3.0, 1.0,
64.0, 16.0, 4.0, 1.0 };
gsl_matrix_view m
= gsl_matrix_view_array (data, 4, 4);
gsl_vector_complex *eval = gsl_vector_complex_alloc (4);
gsl_matrix_complex *evec = gsl_matrix_complex_alloc (4, 4);
gsl_eigen_nonsymmv_workspace * w =
gsl_eigen_nonsymmv_alloc (4);
gsl_eigen_nonsymmv (&m.matrix, eval, evec, w);
gsl_eigen_nonsymmv_free (w);
gsl_eigen_nonsymmv_sort (eval, evec,
GSL_EIGEN_SORT_ABS_DESC);
{
int i, j;
for (i = 0; i < 4; i++)
{
gsl_complex eval_i
= gsl_vector_complex_get (eval, i);
gsl_vector_complex_view evec_i
= gsl_matrix_complex_column (evec, i);
printf ("eigenvalue = %g + %gi\n",
GSL_REAL(eval_i), GSL_IMAG(eval_i));
printf ("eigenvector = \n");
for (j = 0; j < 4; ++j)
{
gsl_complex z = gsl_vector_complex_get(&evec_i.vector, j);
printf("%g + %gi\n", GSL_REAL(z), GSL_IMAG(z));
}
}
}
gsl_vector_complex_free(eval);
gsl_matrix_complex_free(evec);
return 0;
}
void alloc_gslws(gslws_t *ws) {
ws->evals = gsl_vector_complex_alloc(6);
ws->evecs = gsl_matrix_complex_alloc(6,6);
ws->evecs_inv = gsl_matrix_complex_alloc(6,6);
ws->P = gsl_matrix_alloc(6,6);
ws->c_P = gsl_matrix_complex_alloc(6,6);
ws->temp1 = gsl_matrix_complex_alloc(6,6);
ws->temp2 = gsl_matrix_complex_alloc(6,6);
ws->Q_copy = gsl_matrix_alloc(6,6);
ws->evecs_copy = gsl_matrix_complex_alloc(6,6);
ws->perm = gsl_permutation_alloc(6);
ws->eigenws = gsl_eigen_nonsymmv_alloc(6);
ws->tempvec1 = gsl_vector_alloc(6);
ws->tempvec2 = gsl_vector_alloc(6);
}
double R0(const double theta[numParam], const double r0time, double * eigenvec)
{
gsl_matrix * Fmat = gsl_matrix_calloc(NG*(DS-1)*RG, NG*(DS-1)*RG);
gsl_matrix * Vmat = gsl_matrix_calloc(NG*(DS-1)*RG, NG*(DS-1)*RG);
gsl_matrix * VmatInv = gsl_matrix_calloc(NG*(DS-1)*RG, NG*(DS-1)*RG);
gsl_matrix * ngm = gsl_matrix_calloc(NG*(DS-1)*RG, NG*(DS-1)*RG);
createNGM(theta, r0time, Fmat, Vmat);
gsl_permutation * p = gsl_permutation_alloc(NG*(DS-1)*RG);
int s;
gsl_linalg_LU_decomp(Vmat, p, &s);
gsl_linalg_LU_invert(Vmat, p, VmatInv);
gsl_blas_dgemm(CblasNoTrans, CblasNoTrans, 1.0, Fmat, VmatInv, 0.0, ngm);
gsl_eigen_nonsymmv_workspace * w = gsl_eigen_nonsymmv_alloc(NG*(DS-1)*RG);
gsl_vector_complex * eval = gsl_vector_complex_alloc(NG*(DS-1)*RG);
gsl_matrix_complex * evec = gsl_matrix_complex_alloc(NG*(DS-1)*RG, NG*(DS-1)*RG);
gsl_set_error_handler_off();
gsl_eigen_nonsymmv(ngm, eval, evec, w);
size_t r0_idx = 0;
double r0 = 0.0;
for(size_t i = 0; i < NG*(DS-1)*RG; i++){
if(GSL_REAL(gsl_vector_complex_get(eval, i)) > r0){
r0_idx = i;
r0 = GSL_REAL(gsl_vector_complex_get(eval, i));
}
}
if(eigenvec != NULL){
for(size_t i = 0; i < NG*(DS-1)*RG; i++)
eigenvec[i] = GSL_REAL(gsl_matrix_complex_get(evec, i, r0_idx));
}
gsl_matrix_free(Fmat);
gsl_matrix_free(Vmat);
gsl_matrix_free(VmatInv);
gsl_matrix_free(ngm);
gsl_permutation_free(p);
gsl_eigen_nonsymmv_free(w);
gsl_vector_complex_free(eval);
gsl_matrix_complex_free(evec);
return r0;
}
gsl_vector_complex *
CRebuildGraph::calculateEgeinval (gsl_matrix *target)
{
int order = (int)target->size1;
gsl_vector_complex *eval = gsl_vector_complex_alloc (order);
gsl_matrix_complex *evec = gsl_matrix_complex_alloc (order, order);
gsl_eigen_nonsymmv_workspace * w =
gsl_eigen_nonsymmv_alloc (order);
gsl_eigen_nonsymmv (target, eval, evec, w);
gsl_eigen_nonsymmv_free (w);
gsl_eigen_nonsymmv_sort (eval, evec,
GSL_EIGEN_SORT_ABS_DESC);
{
int i, j;
for (i = 0; i < order; i++)
{
gsl_complex eval_i
= gsl_vector_complex_get (eval, i);
gsl_vector_complex_view evec_i
= gsl_matrix_complex_column (evec, i);
printf ("eigenvalue = %g + %gi\n",
GSL_REAL(eval_i), GSL_IMAG(eval_i));
printf ("eigenvector = \n");
for (j = 0; j < order; ++j)
{
/* gsl_complex z = */
gsl_vector_complex_get(&evec_i.vector, j);
// printf("%g + %gi\n", GSL_REAL(z), GSL_IMAG(z));
}
}
}
// gsl_vector_complex_free(eval);
gsl_matrix_complex_free(evec);
return eval;
}
bool eigenValuesVectors(const Matrix &m, Matrix& vals_real, Matrix& vals_imag,
Matrix& vecs_real, Matrix& vecs_imag){
// check if m is square
assert(m.getM() == m.getN());
gsl_matrix* m_gsl = toGSL(m);
gsl_eigen_nonsymmv_workspace* w = gsl_eigen_nonsymmv_alloc (m.getM());
gsl_vector_complex *eval = gsl_vector_complex_alloc (m.getM());
gsl_matrix_complex *evec = gsl_matrix_complex_alloc (m.getM(), m.getM());
gsl_eigen_nonsymmv (m_gsl, eval, evec, w);
gsl_eigen_nonsymmv_free (w);
gsl_eigen_nonsymmv_sort (eval, evec, GSL_EIGEN_SORT_ABS_DESC);
gsl_vector_view eval_real = gsl_vector_complex_real(eval);
gsl_vector_view eval_imag = gsl_vector_complex_imag(eval);
vals_real = fromGSL(&eval_real.vector);
vals_imag = fromGSL(&eval_imag.vector);
vecs_real = fromGSL_real(evec);
vecs_imag = fromGSL_imag(evec);
return true;
}
double epidemicGrowthRate(const double theta[numParam], const double r0time, double * eigenvec)
{
gsl_matrix * Fmat = gsl_matrix_calloc(NG*(DS-1)*RG, NG*(DS-1)*RG);
gsl_matrix * Vmat = gsl_matrix_calloc(NG*(DS-1)*RG, NG*(DS-1)*RG);
createNGM(theta, r0time, Fmat, Vmat);
gsl_matrix_sub(Fmat, Vmat);
gsl_eigen_nonsymmv_workspace * w = gsl_eigen_nonsymmv_alloc(NG*(DS-1)*RG);
gsl_vector_complex * eval = gsl_vector_complex_alloc(NG*(DS-1)*RG);
gsl_matrix_complex * evec = gsl_matrix_complex_alloc(NG*(DS-1)*RG, NG*(DS-1)*RG);
gsl_set_error_handler_off();
gsl_eigen_nonsymmv(Fmat, eval, evec, w);
size_t growth_rate_idx = 0;
double growth_rate = -INFINITY;
for(size_t i = 0; i < NG*(DS-1)*RG; i++){
if(GSL_REAL(gsl_vector_complex_get(eval, i)) > growth_rate){
growth_rate_idx = i;
growth_rate = GSL_REAL(gsl_vector_complex_get(eval, i));
}
}
if(eigenvec != NULL){
for(size_t i = 0; i < NG*(DS-1)*RG; i++)
eigenvec[i] = GSL_REAL(gsl_matrix_complex_get(evec, i, growth_rate_idx));
}
gsl_matrix_free(Fmat);
gsl_matrix_free(Vmat);
gsl_vector_complex_free(eval);
gsl_matrix_complex_free(evec);
gsl_eigen_nonsymmv_free(w);
return growth_rate;
}
void MarkovChain::setupCDFS(const gsl_matrix * Q)
{
double cdf, norm;
gsl_vector_complex *eval;
gsl_matrix_complex *evec;
gsl_eigen_nonsymmv_workspace * w;
gsl_vector_complex_view S;
gsl_matrix_memcpy (m_cdfQ, Q);
eval = gsl_vector_complex_alloc (Q->size1);
evec = gsl_matrix_complex_alloc (Q->size1, Q->size2);
w = gsl_eigen_nonsymmv_alloc(Q->size1);
gsl_eigen_nonsymmv (m_cdfQ, eval, evec, w);
gsl_eigen_nonsymmv_sort (eval, evec,
GSL_EIGEN_SORT_ABS_DESC);
/*vector of stationary probabilities corresponding to the eigenvalue 1 */
S = gsl_matrix_complex_column(evec, 0);
/*sum of vector elements*/
norm = 0.0;
for(size_t i = 0; i < Q->size1; ++i)
{
norm += GSL_REAL(gsl_vector_complex_get(&S.vector, i));
}
/*cdfs*/
cdf = 0.0;
for(size_t i = 0; i < Q->size1; ++i)
{
cdf += GSL_REAL(gsl_vector_complex_get(&S.vector, i)) / norm;
gsl_vector_set(m_cdfS, i, cdf);
}
gsl_eigen_nonsymmv_free (w);
gsl_vector_complex_free(eval);
gsl_matrix_complex_free(evec);
}
void K_wandering_test()
{
int neuronsOfLayer[] = {10, 10, 10}; // first = input layer, last = output layer
int numLayers = sizeof (neuronsOfLayer) / sizeof (int);
NNET *Net = create_NN(numLayers, neuronsOfLayer);
LAYER lastLayer = Net->layers[numLayers - 1];
// **** Calculate spectral radius of weight matrices
printf("Eigen values = \n");
for (int l = 1; l < numLayers; ++l) // except first layer which has no weights
{
int N = 10;
// assume weight matrix is square, if not, fill with zero rows perhaps (TO-DO)
gsl_matrix *A = gsl_matrix_alloc(N, N);
for (int n = 0; n < N; ++n)
for (int i = 0; i < N; ++i)
gsl_matrix_set(A, n, i, Net->layers[l].neurons[n].weights[i]);
gsl_eigen_nonsymmv_workspace *wrk = gsl_eigen_nonsymmv_alloc(N);
gsl_vector_complex *Aval = gsl_vector_complex_alloc(N);
gsl_matrix_complex *Avec = gsl_matrix_complex_alloc(N, N);
gsl_eigen_nonsymmv(A, Aval, Avec, wrk);
gsl_eigen_nonsymmv_free(wrk);
gsl_eigen_nonsymmv_sort(Aval, Avec, GSL_EIGEN_SORT_ABS_DESC);
printf("[ ");
for (int i = 0; i < N; i++)
{
gsl_complex v = gsl_vector_complex_get(Aval, i);
// printf("%.02f %.02f, ", GSL_REAL(v), GSL_IMAG(v));
printf("%.02f ", gsl_complex_abs(v));
}
printf(" ]\n");
gsl_matrix_free(A);
gsl_matrix_complex_free(Avec);
gsl_vector_complex_free(Aval);
}
start_K_plot();
printf("\nPress 'Q' to quit\n\n");
// **** Initialize K vector
for (int k = 0; k < dim_K; ++k)
K[k] = (rand() / (float) RAND_MAX) - 0.5f;
double K2[dim_K];
int quit = 0;
for (int j = 0; j < 10000; j++) // max number of iterations
{
ForwardPropMethod(Net, dim_K, K);
// printf("%02d", j);
double d = 0.0;
// copy output to input
for (int k = 0; k < dim_K; ++k)
{
K2[k] = K[k];
K[k] = lastLayer.neurons[k].output;
// printf(", %0.4lf", K[k]);
double diff = (K2[k] - K[k]);
d += (diff * diff);
}
plot_trainer(0); // required to clear window
plot_K();
if (quit = delay_vis(60)) // delay in milliseconds
break;
// printf("\n");
if (d < 0.000001)
{
fprintf(stderr, "terminated after %d cycles,\t delta = %lf\n", j, d);
break;
}
}
beep();
if (!quit)
pause_graphics();
else
quit_graphics();
free_NN(Net, neuronsOfLayer);
}
