예제 #1
0
// Scale each row in a matrix to have values in a given range [a,b]
// f(x) = a + (b-a)(x-min)/(max-min)
void shapeAlign::scaleMatrix(gsl_matrix *M, double min, double max){
	for (size_t i = 0; i < M->size1; i++){
		double rmin,rmax;	// row max and min
		gsl_vector_view row = gsl_matrix_row(M,i);
		gsl_vector_minmax(&row.vector,&rmin,&rmax);
		gsl_vector_add_constant(&row.vector,-1*rmin);
		gsl_vector_scale(&row.vector,(max-min)/(rmax-rmin));
		gsl_vector_add_constant(&row.vector,min);
	}
	return;
}
예제 #2
0
gsl_matrix*
GaussianMatrix ( gsl_vector *v, float sigma ) {
	gsl_vector_add_constant ( v, -1 );
	gsl_vector_scale ( v, 0.5 );
	
	int siz1 = gsl_vector_get ( v, 0 );
	int siz2 = gsl_vector_get ( v, 1 );
	gsl_matrix *x = gsl_matrix_alloc ( siz1*2+1, siz2*2+1 );
	gsl_matrix *y = gsl_matrix_alloc ( siz1*2+1, siz2*2+1 ); 

	for ( int i=-siz2; i<=siz2; i++ ) {
		for ( int j=-siz1; j<=siz1; j++ ) {
			gsl_matrix_set ( x, i+siz2, j+siz1, j );
			gsl_matrix_set ( y, i+siz2, j+siz1, i );
		}
	}

	gsl_matrix_mul_elements ( x, x );
	gsl_matrix_mul_elements ( y, y );
	gsl_matrix_add ( x, y );
	gsl_matrix_scale ( x, -1/(2*sigma*sigma) );

	float sum = 0;
	for ( int i=0; i<x->size1; i++ ) {
		for ( int j=0; j<x->size2; j++ ) {
			gsl_matrix_set ( x, i, j, exp(gsl_matrix_get ( x, i, j )) );
			sum += gsl_matrix_get ( x, i, j );
		}
	}
	if ( sum != 0 ) gsl_matrix_scale ( x, 1/sum );

	gsl_matrix_free ( y );
	return x;
}
예제 #3
0
inline void model::zero_out_mat(gsl_matrix *mat)
{
	size_t ncol = mat->size2;

	for (size_t j = 0; j < ncol; ++j) {
		gsl_vector_view cv = gsl_matrix_column(mat, j);
		gsl_vector_add_constant(&cv.vector, -gsl_vector_get(_col_mean, j));
	}
}
예제 #4
0
파일: lls.c 프로젝트: pa345/lib
int
lls_regularize(const double lambda, gsl_matrix *ATA)
{
  int s;
  gsl_vector_view d = gsl_matrix_diagonal(ATA);

  s = gsl_vector_add_constant(&d.vector, lambda * lambda);

  return s;
} /* lls_regularize() */
예제 #5
0
 /** Subtraction operator (double) */
 vector<double> vector<double>::operator-(const double& a)
 {
   vector<double> v1(_vector);
   if (gsl_vector_add_constant(v1.as_gsl_type_ptr(), -a))
     {
       std::cout << "\n Error in vector<double> - (double)" << std::endl;
       exit(EXIT_FAILURE);
     }
   return v1;
 }
예제 #6
0
void shapeAlign::scaleMatrixZscore(gsl_matrix *M){
	for (size_t i = 0; i < M->size1; i++){
		gsl_vector_view row = gsl_matrix_row(M,i);
		double mu = gsl_stats_mean(row.vector.data, row.vector.stride, row.vector.size);
		double sigma = gsl_stats_sd_m(row.vector.data, row.vector.stride, row.vector.size, mu);

		gsl_vector_add_constant(&row.vector,-mu);
		gsl_vector_scale(&row.vector,1.0/sigma);
	}
	return;
}
void StationaryCholesky::computeGammak( const gsl_matrix *Rt, double reg ) {
  gsl_matrix_view submat;
  
  for (size_t k = 0; k < getMu(); k++) { 
    submat = gsl_matrix_submatrix(myGammaK, 0, k * getD(), getD(), getD());
    myStStruct->AtVkB(&submat.matrix, k, Rt, Rt, myTempVijtRt);
 
    if (reg > 0) {
      gsl_vector diag = gsl_matrix_diagonal(&submat.matrix).vector;
      gsl_vector_add_constant(&diag, reg);
    }    
  }
  submat = gsl_matrix_submatrix(myGammaK, 0, getMu() * getD(), getD(), getD());
  gsl_matrix_set_zero(&submat.matrix);
}
예제 #8
0
파일: util.c 프로젝트: alvarouc/ica_gsl
void matrix_demean(gsl_matrix *input){

  gsl_vector *mean = gsl_vector_alloc(input->size2);
  matrix_mean(mean, input);

  size_t NCOL = input->size2;
  size_t i;
  gsl_vector_view column;
  #pragma omp parallel for private(column)
  for (i = 0; i < NCOL; i++) {
    column = gsl_matrix_column(input, i);
    gsl_vector_add_constant( &column.vector,
                             -gsl_vector_get(mean, i));
  }
}
예제 #9
0
/**
 * Empirical Orthogonal Functions analysis (or Principal Component Analysis)
 * of a multivariate time series.
 * \param[in]  data Multivariate time series on which to perform the analysis.
 * \param[out] w    Eigenvalues of the covariance matrix giving the explained variance.
 * \param[out] E    Matrix with an Empirical Orthogonal Function for each column.
 * \param[out] A    Matrix with a principal component for each column.
 */
void
getEOF(const gsl_matrix *data, gsl_vector *w, gsl_matrix *E, gsl_matrix *A)
{
    size_t nt = data->size1;
    size_t N = data->size2;
    gsl_vector *mean;
    gsl_matrix *C = gsl_matrix_alloc(N, N);
    gsl_eigen_symmv_workspace *work = gsl_eigen_symmv_alloc(N);
    gsl_matrix *X = gsl_matrix_alloc(data->size1, data->size2);
    gsl_matrix_memcpy(X, data);
    gsl_vector_view col;

    // Get anomalies
    A = gsl_matrix_alloc(nt, N);
    gsl_matrix_memcpy(A, X);
    mean = gsl_vector_alloc(N);
    gsl_matrix_get_mean(mean, A, 0);
    for (size_t j = 0; j < X->size2; j++)
    {
        col = gsl_matrix_column(X, j);
        gsl_vector_add_constant(&col.vector, - gsl_vector_get(mean, j));
    }

    // Get correlation matrix
    gsl_blas_dgemm(CblasTrans, CblasNoTrans, 1., A, A, 0., C);
    gsl_matrix_scale(C, 1. / nt);

    // Solve eigen problem and sort by descending magnitude
    gsl_eigen_symmv(C, w, E, work);
    gsl_eigen_symmv_sort(w, E, GSL_EIGEN_SORT_VAL_DESC);

    // Get principal components
    gsl_blas_dgemm(CblasNoTrans, CblasNoTrans, 1., X, E, 0., A);

    // Free
    gsl_eigen_symmv_free(work);
    gsl_matrix_free(C);

    return;
}
예제 #10
0
파일: utils.c 프로젝트: hwp/notGHMM
double log_sum_exp(const gsl_vector* v) {
  double m = -gsl_vector_max(v);
  assert(!isnan(m));
  if (isinf(m)) {
    // m = +inf OR -inf
    // both cases the result should be equal to m
    return m;
  }

  gsl_vector* w = gsl_vector_alloc(v->size);
  gsl_vector_memcpy(w, v);
  gsl_vector_add_constant(w, m);

  double s = 0.0;
  size_t i;
  for (i = 0; i < w->size; i++) {
    s += DEBUG_EXP(gsl_vector_get(w, i));
  }

  gsl_vector_free(w);

  return -m + DEBUG_LOG(s);
}
예제 #11
0
gsl_matrix* reconstructData (gsl_matrix* t_data, gsl_matrix* rot, gsl_vector* means) {

    // rec_data = rot * t_data
    gsl_matrix* rec_data_t = gsl_matrix_alloc(rot->size1, t_data->size2);
    gsl_blas_dgemm( CblasNoTrans,
                    CblasNoTrans,
                    1.0, rot, t_data, 0.0, rec_data_t);


    gsl_matrix* rec_data = gsl_matrix_alloc(rec_data_t->size2, rec_data_t->size1);
    transposeMatrix(rec_data_t, rec_data);

    gsl_matrix_free(rec_data_t);

    // rec_data + means
    for (unsigned int j = 0; j < (rec_data->size2); j++) {
        gsl_vector_view vv = gsl_matrix_column(rec_data,j);
        gsl_vector* v = &vv.vector;
        gsl_vector_add_constant(v, gsl_vector_get(means,j));
    }

    return(rec_data);
}
예제 #12
0
파일: nlfit4.c 프로젝트: liigo/gsl-vc2015
int
penalty_df (CBLAS_TRANSPOSE_t TransJ, const gsl_vector * x,
            const gsl_vector * u, void * params, gsl_vector * v,
            gsl_matrix * JTJ)
{
  struct model_params *par = (struct model_params *) params;
  const size_t p = x->size;
  size_t j;

  /* store 2*x in last row of J */
  for (j = 0; j < p; ++j)
    {
      double xj = gsl_vector_get(x, j);
      gsl_spmatrix_set(par->J, p, j, 2.0 * xj);
    }

  /* compute v = op(J) u */
  if (v)
    gsl_spblas_dgemv(TransJ, 1.0, par->J, u, 0.0, v);

  if (JTJ)
    {
      gsl_vector_view diag = gsl_matrix_diagonal(JTJ);

      /* compute J^T J = [ alpha*I_p + 4 x x^T ] */
      gsl_matrix_set_zero(JTJ);

      /* store 4 x x^T in lower half of JTJ */
      gsl_blas_dsyr(CblasLower, 4.0, x, JTJ);

      /* add alpha to diag(JTJ) */
      gsl_vector_add_constant(&diag.vector, par->alpha);
    }

  return GSL_SUCCESS;
}
예제 #13
0
int compute_itegral_r(const mu_data_fit *mu, const fit_params fp, gsl_vector *fftR_abs){
    size_t vsize= mu->k->size; 
    gsl_vector *mu_tmp=gsl_vector_alloc(vsize);
    gsl_vector_set_zero(mu_tmp);
    size_t ikmin=search_min(mu->k, mu->kmin - 0.5*mu->dwk);
    size_t ikmax=search_min(mu->k, mu->kmax + 0.5*mu->dwk);
    gsl_vector_view kw  = gsl_vector_subvector(mu->k, ikmin-1, ikmax-ikmin-1);
    gsl_vector_view muw = gsl_vector_subvector(mu_tmp, ikmin-1, ikmax-ikmin-1);


    gsl_vector *ktmp=gsl_vector_alloc((&kw.vector)->size);
    
    gsl_vector_memcpy(ktmp, &kw.vector);
    gsl_vector_add_constant(ktmp, fp.kshift);
    compute_itegral(ktmp, &fp, &muw.vector);
    hanning(mu_tmp, mu->k, mu->kmin, mu->kmax, mu->dwk);

    //FFT transform
    double *data = (double *) malloc(vsize*sizeof(double)); 
    memcpy(data, mu_tmp->data, vsize*sizeof(double));
    gsl_fft_real_radix2_transform(data, 1, vsize);

    //Unpack complex vector
    gsl_vector_complex *fourier_data = gsl_vector_complex_alloc (vsize);
    gsl_fft_halfcomplex_radix2_unpack(data, fourier_data->data, 1, vsize);
    gsl_vector *fftR_real = gsl_vector_alloc(vsize/2);
    gsl_vector *fftR_imag = gsl_vector_alloc(vsize/2);
    //gsl_vector *fftR_abs  = gsl_vector_alloc(vsize/2);
    complex_vector_parts(fourier_data, fftR_real, fftR_imag);
    complex_vector_abs(fftR_abs, fftR_real, fftR_imag);
    hanning(fftR_abs, mu->r, mu->rmin, mu->rmax, mu->dwr); 
    gsl_vector_free(fftR_real); gsl_vector_free(fftR_imag);
    gsl_vector_complex_free(fourier_data); gsl_vector_free(mu_tmp);  
    free(data);

}
예제 #14
0
파일: KFKSDS-steady.cpp 프로젝트: cran/stsm
void KFKSDS_steady (int *dim, double *sy, double *sZ, double *sT, double *sH, 
  double *sR, double *sV, double *sQ, double *sa0, double *sP0,
  double *tol, int *maxiter, double *ksconvfactor,
  double *mll, double *epshat, double *vareps,
  double *etahat, double *vareta, 
  double *sumepsmisc, double *sumetamisc)
{
  int i, ip1, n = dim[0], m = dim[2], ir = dim[3], convref, nmconvref, nm1 = n-1;
  int irsod = ir * sizeof(double);

  //double v[n], f[n], invf[n], vof[n];
  std::vector<double> v(n), f(n), invf(n), vof(n);

  sumepsmisc[0] = 0.0;

  gsl_vector * sum_eta_misc = gsl_vector_calloc(ir);
  gsl_vector * etahat_sq = gsl_vector_alloc(ir);
  gsl_vector_view Z = gsl_vector_view_array(sZ, m);
  gsl_vector * Z_cp = gsl_vector_alloc(m);
  gsl_matrix * K = gsl_matrix_alloc(n, m);
  gsl_vector_view K_irow;
  gsl_matrix_view Q = gsl_matrix_view_array(sQ, m, m);
  gsl_matrix_view V = gsl_matrix_view_array(sV, ir, ir);  
  gsl_matrix_view R = gsl_matrix_view_array(sR, m, ir);

  gsl_matrix * r = gsl_matrix_alloc(n + 1, m);
  gsl_vector_view r_row_t;
  gsl_vector_view r_row_tp1 = gsl_matrix_row(r, n);
  gsl_vector_set_zero(&r_row_tp1.vector);

  std::vector<gsl_matrix*> L(n);
  std::vector<gsl_matrix*> N(n+1);
  N.at(n) = gsl_matrix_calloc(m, m);
  gsl_vector_view Ndiag;
  
  gsl_vector_view Qdiag = gsl_matrix_diagonal(&Q.matrix);
  gsl_vector * Qdiag_msq = gsl_vector_alloc(m);
  gsl_vector_memcpy(Qdiag_msq, &Qdiag.vector);
  gsl_vector_mul(Qdiag_msq, &Qdiag.vector);
  gsl_vector_scale(Qdiag_msq, -1.0);
  
  gsl_vector * sum_vareta = gsl_vector_calloc(m);

  KF_steady(dim, sy, sZ, sT, sH, 
    sR, sV, sQ, sa0, sP0, 
    mll, &v, &f, &invf, &vof, K, &L, tol, maxiter);

  convref = dim[5];
  if (convref == -1) {
    convref = n;    
  } else 
    convref = ceil(convref * ksconvfactor[0]);
  nmconvref = n - convref;

  gsl_vector_view vaux;

  gsl_matrix * Mmm = gsl_matrix_alloc(m, m);

  gsl_matrix * ZtZ = gsl_matrix_alloc(m, m);
  gsl_matrix_view maux1, maux2;
  maux1 = gsl_matrix_view_array(gsl_vector_ptr(&Z.vector, 0), m, 1);
  gsl_vector_memcpy(Z_cp, &Z.vector);
  maux2 = gsl_matrix_view_array(gsl_vector_ptr(Z_cp, 0), 1, m);
  gsl_blas_dgemm(CblasNoTrans, CblasNoTrans, 1.0, &maux1.matrix, 
    &maux2.matrix, 0.0, ZtZ);

  gsl_vector * var_eps = gsl_vector_alloc(n);

  double msHsq = -1.0 * pow(*sH, 2);
  vaux = gsl_vector_view_array(&f[0], n);
  gsl_vector_set_all(var_eps, msHsq);
  gsl_vector_div(var_eps, &vaux.vector);
  gsl_vector_add_constant(var_eps, *sH);

  gsl_matrix * eta_hat = gsl_matrix_alloc(n, ir);  
  gsl_matrix * Mrm = gsl_matrix_alloc(ir, m);
  gsl_blas_dgemm(CblasNoTrans, CblasTrans, 1.0, &V.matrix, &R.matrix, 0.0, Mrm);

  for (i = n-1; i > -1; i--)
  {
    ip1 = i + 1;
    
    if (i != n-1)  //the case i=n-1 was initialized above
      r_row_tp1 = gsl_matrix_row(r, ip1);
    r_row_t = gsl_matrix_row(r, i);

    gsl_blas_dgemv(CblasTrans, 1.0, L.at(i), &r_row_tp1.vector, 
      0.0, &r_row_t.vector);
    gsl_vector_memcpy(Z_cp, &Z.vector);
    gsl_vector_scale(Z_cp, vof[i]);
    gsl_vector_add(&r_row_t.vector, Z_cp);

    N.at(i) = gsl_matrix_alloc(m, m);
    if (i < convref || i > nmconvref)
    {
      gsl_matrix_memcpy(N.at(i), ZtZ);
      gsl_blas_dgemm(CblasTrans, CblasNoTrans, 1.0, L.at(i), N.at(ip1), 0.0, Mmm);
      gsl_blas_dgemm(CblasNoTrans, CblasNoTrans, 1.0, Mmm, L.at(i), invf[i], N.at(i)); 
    } else {
      gsl_matrix_memcpy(N.at(i), N.at(ip1));
    }
    
    if (dim[6] == 0 || dim[6] == 1)
    {

      if (i < convref || i == nm1) {
        K_irow = gsl_matrix_row(K, i);
      }

      gsl_blas_ddot(&K_irow.vector, &r_row_tp1.vector, &epshat[i]);

      epshat[i] -= vof[i];
      epshat[i] *= -*sH;

      if (i < convref || i > nmconvref)
      {
        maux1 = gsl_matrix_view_array(gsl_vector_ptr(&K_irow.vector, 0), 1, m);
        maux2 = gsl_matrix_view_array(gsl_vector_ptr(Z_cp, 0), 1, m);    
        gsl_blas_dgemm(CblasNoTrans, CblasNoTrans, 1.0, &maux1.matrix, N.at(ip1),
          0.0, &maux2.matrix);

        vaux = gsl_vector_view_array(gsl_vector_ptr(var_eps, i), 1);
        gsl_blas_dgemv(CblasNoTrans, msHsq, &maux2.matrix, &K_irow.vector, 
          1.0, &vaux.vector);
        vareps[i] = gsl_vector_get(&vaux.vector, 0);
    } else {
        vareps[i] = vareps[ip1];
    }

    sumepsmisc[0] += epshat[i] * epshat[i] + vareps[i];
  }

  if (dim[6] == 0 || dim[6] == 2)
  {
    vaux = gsl_matrix_row(eta_hat, i);
    gsl_blas_dgemv(CblasNoTrans, 1.0, Mrm, &r_row_tp1.vector,
      0.0, &vaux.vector);

    memcpy(&etahat[i*ir], (&vaux.vector)->data, irsod);

    if (i != n-1)
    {
      gsl_vector_memcpy(etahat_sq, &vaux.vector);
      gsl_vector_mul(etahat_sq, etahat_sq);

      gsl_vector_add(sum_eta_misc, etahat_sq);
    }

    if (i != n-1)
    {
      if (i < convref || i > nmconvref)
      {
        Ndiag = gsl_matrix_diagonal(N.at(ip1));
        gsl_vector_memcpy(Z_cp, &Ndiag.vector);
        gsl_vector_mul(Z_cp, Qdiag_msq);
        gsl_vector_add(Z_cp, &Qdiag.vector);
        gsl_vector_set_zero(sum_vareta);
        gsl_vector_add(sum_vareta, Z_cp);
      }
        gsl_blas_dgemv(CblasTrans, 1.0, &R.matrix, sum_vareta, 1.0, sum_eta_misc);    
    }
  }

    gsl_matrix_free(L.at(i));    
    gsl_matrix_free(N.at(ip1));
  }

  gsl_matrix_free(N.at(0));

  if (dim[6] == 0 || dim[6] == 2)
  {
    memcpy(&sumetamisc[0], sum_eta_misc->data, irsod);
  }

  gsl_vector_free(Z_cp);
  gsl_vector_free(var_eps);
  gsl_vector_free(Qdiag_msq);
  gsl_vector_free(sum_vareta);
  gsl_vector_free(sum_eta_misc);
  gsl_vector_free(etahat_sq);
  gsl_matrix_free(eta_hat);  
  gsl_matrix_free(Mrm);
  gsl_matrix_free(r);
  gsl_matrix_free(K);
  gsl_matrix_free(ZtZ);
  gsl_matrix_free(Mmm);
}
예제 #15
0
int model::predict(const dataset &tds, gsl_matrix **pp)
{
	int ret = -1;

	gsl_matrix *mat = NULL;
	gsl_matrix *ptv = NULL;
	gsl_matrix *km1 = NULL;
	gsl_matrix *km2 = NULL;
	gsl_matrix *res = NULL;
	gsl_matrix *stm = NULL;

        gsl_vector_view avg_col;
        gsl_vector_view dv;
        
	if (tds.ins_num() <= 0 || tds.fea_num() != (int)_col_mean->size) {
		ULIB_FATAL("invalid test dimensions, (ins_num=%d,fea_num=%d)",
                           tds.ins_num(), tds.fea_num());
		goto done;
	}

	mat = gsl_matrix_alloc(tds.ins_num(), tds.fea_num());
	if (mat == NULL) {
		ULIB_FATAL("couldn't allocate test feature matrix");
		goto done;
	}
	ptv = gsl_matrix_alloc(tds.ins_num(), 2);
	if (ptv == NULL) {
		ULIB_FATAL("couldn't allocate prediction matrix");
		goto done;
	}
        if (tds.get_matrix(mat)) {
                ULIB_FATAL("couldn't get test matrix");
                goto done;
        }
	dbg_print_mat(mat, "Test Matrix:");

	zero_out_mat(mat);
	norm_mat(mat);

	dbg_print_mat(mat, "Normalized Test Matrix:");

	km1 = comp_kern_mat(mat, _fm, _kern);
	if (km1 == NULL) {
		ULIB_FATAL("couldn't compute test1 kernel matrix");
		goto done;
	}
	dbg_print_mat(km1, "Test Kernel Matrix:");

	km2 = comp_kern_mat(mat, mat, _kern);
	if (km2 == NULL) {
		ULIB_FATAL("couldn't compute test2 kernel matrix");
		goto done;
	}
	dbg_print_mat(km1, "Test Kernel Matrix:");
	dv = gsl_matrix_diagonal(km2);

	res = gsl_matrix_alloc(km1->size1, _ikm->size2);
	if (res == NULL) {
		ULIB_FATAL("couldn't allocate temporary matrix");
		goto done;
	}
	stm = gsl_matrix_alloc(km2->size1, km2->size2);
	if (stm == NULL) {
		ULIB_FATAL("couldn't allocate std matrix");
		goto done;
	}

	gsl_blas_dgemm(CblasNoTrans, CblasNoTrans, 1.0, km1, _ikm, 0.0, res);
	gsl_blas_dgemm(CblasNoTrans, CblasTrans, 1.0, res, km1, 0.0, stm);
        gsl_matrix_sub(km2, stm);
	dbg_print_mat(res, "Predictive Matrix:");
        avg_col = gsl_matrix_column(ptv, 0);
	gsl_blas_dgemv(CblasNoTrans, 1.0, res, _tv, 0.0, &avg_col.vector);
        gsl_vector_add_constant(&avg_col.vector, _t_avg);
        gsl_matrix_scale(km2, _t_std*_t_std);
	gsl_vector_add_constant(&dv.vector, _noise_var);
        for (size_t i = 0; i < km2->size1; ++i)
                gsl_matrix_set(ptv, i, 1, sqrt(gsl_vector_get(&dv.vector, i)));
	*pp = ptv;
	ptv = NULL;
	ret = 0;
done:
	gsl_matrix_free(mat);
	gsl_matrix_free(ptv);
	gsl_matrix_free(km1);
	gsl_matrix_free(km2);
	gsl_matrix_free(res);
	gsl_matrix_free(stm);
	return ret;
}
예제 #16
0
파일: pca.c 프로젝트: jbao/mds
int main(int argc, char **argv){
    int row = atoi(argv[2]);
    int col = atoi(argv[3]);
    printf("%d %d\n", row, col);
    gsl_matrix* data = gsl_matrix_alloc(row, col);
    //gsl_matrix* data = gsl_matrix_alloc(col, row);
    FILE* f = fopen(argv[1], "r");
    gsl_matrix_fscanf(f, data);
    //gsl_matrix_fread(f, data);
    //gsl_matrix_transpose_memcpy(data, data_raw);
    fclose(f);

    //printf("%f %f", gsl_matrix_get(data,0,0), gsl_matrix_get(data,0,1));
    //f = fopen("test.dat", "w");
    //gsl_matrix_fprintf(f, data, "%f");
    //fclose(f);
    
    // data centering, subtract the mean in each dimension (col.-wise)
    int i, j;
    double mean, sum, std;
    gsl_vector_view col_vector;
    for (i = 0; i < col; ++i){
        col_vector = gsl_matrix_column(data, i);
        mean = gsl_stats_mean((&col_vector.vector)->data, 1, 
            (&col_vector.vector)->size);
        gsl_vector_add_constant(&col_vector.vector, -mean);
        gsl_matrix_set_col(data, i, &col_vector.vector);
    }
    
    char filename[50];
    //sprintf(filename, "%s.zscore", argv[1]);
    //print2file(filename, data);

    gsl_matrix* u;
    if (col > row) {
        u = gsl_matrix_alloc(data->size2, data->size1);
        gsl_matrix_transpose_memcpy(u, data);
    } 
    else {
        u = gsl_matrix_alloc(data->size1, data->size2);
        gsl_matrix_memcpy(u, data);
    }

    // svd
    gsl_matrix* X = gsl_matrix_alloc(col, col);
    gsl_matrix* V = gsl_matrix_alloc(u->size2, u->size2);
    gsl_vector* S = gsl_vector_alloc(u->size2);
    gsl_vector* work = gsl_vector_alloc(u->size2);
    gsl_linalg_SV_decomp(u, V, S, work);
    //gsl_linalg_SV_decomp_jacobi(u, V, S);

    // mode coefficient
    //print2file("u.dat", u);
    /*
    // characteristic mode
    gsl_matrix* diag = diag_alloc(S);
    gsl_matrix* mode = gsl_matrix_alloc(diag->size1, V->size1);
    gsl_blas_dgemm(CblasNoTrans, CblasTrans, 1.0, diag, V, 0.0, mode);
    gsl_matrix_transpose(mode);
    print2file("mode.dat", mode);
    gsl_matrix_transpose(mode);
    */
    // reconstruction
    gsl_matrix *recons = gsl_matrix_alloc(u->size2, data->size1);
    if (col > row) {
        gsl_matrix_view data_sub = gsl_matrix_submatrix(data, 0, 0, 
            u->size2, u->size2);
        gsl_blas_dgemm(CblasNoTrans, CblasTrans, 1.0, V, 
            &data_sub.matrix, 0.0, recons);
    }
    else
        gsl_blas_dgemm(CblasTrans, CblasTrans, 1.0, V, data, 0.0, recons);

    //gsl_blas_dgemm(CblasNoTrans, CblasNoTrans, 1.0, u, mode, 0.0, 
    //    recons);
    gsl_matrix *recons_trans = gsl_matrix_alloc(recons->size2, 
        recons->size1);
    gsl_matrix_transpose_memcpy(recons_trans, recons);
    // take the first two eigenvectors
    gsl_matrix_view final = gsl_matrix_submatrix(recons_trans, 0, 0, 
            recons_trans->size1, 2);

    print2file(argv[4], &final.matrix);

    // eigenvalue
    gsl_vector_mul(S, S);
    f = fopen("eigenvalue.dat", "w");
    //gsl_vector_fprintf(f, S, "%f");
    fclose(f);

    gsl_matrix_free(data);
    gsl_matrix_free(X);
    gsl_matrix_free(V);
    //gsl_matrix_free(diag);
    //gsl_matrix_free(mode);
    gsl_matrix_free(recons);
    gsl_matrix_free(recons_trans);
    gsl_matrix_free(u);
    gsl_vector_free(S);
    gsl_vector_free(work);
    //gsl_vector_free(zero);
    //gsl_vector_free(corrcoef);
    //gsl_vector_free(corrcoef_mean);
    return 0;
}
예제 #17
0
파일: test_reg.c 프로젝트: FMX/gsl
/* solve standard form system with given lambda and test against
 * normal equations solution, L = I */
static void
test_reg2(const double lambda, const gsl_matrix * X, const gsl_vector * y,
          const gsl_vector * wts, const double tol,
          gsl_multifit_linear_workspace * w, const char * desc)
{
  const size_t n = X->size1;
  const size_t p = X->size2;
  double rnorm0, snorm0;
  double rnorm1, snorm1;
  gsl_vector *c0 = gsl_vector_alloc(p);
  gsl_vector *c1 = gsl_vector_alloc(p);
  gsl_matrix *XTX = gsl_matrix_alloc(p, p); /* X^T W X + lambda^2 I */
  gsl_vector *XTy = gsl_vector_alloc(p);    /* X^T W y */
  gsl_matrix *Xs = gsl_matrix_alloc(n, p);
  gsl_vector *ys = gsl_vector_alloc(n);
  gsl_vector_view xtx_diag = gsl_matrix_diagonal(XTX);
  gsl_permutation *perm = gsl_permutation_alloc(p);
  gsl_vector *r = gsl_vector_alloc(n);
  int signum;
  size_t j;

  /* compute Xs = sqrt(W) X and ys = sqrt(W) y */
  gsl_multifit_linear_wstdform1(NULL, X, wts, y, Xs, ys, w);

  /* construct XTy = X^T W y */
  gsl_blas_dgemv(CblasTrans, 1.0, Xs, ys, 0.0, XTy);

  /* construct XTX = X^T W X + lambda^2 I */
  gsl_blas_dgemm(CblasTrans, CblasNoTrans, 1.0, Xs, Xs, 0.0, XTX);
  gsl_vector_add_constant(&xtx_diag.vector, lambda*lambda);

  /* solve XTX c = XTy with LU decomp */
  gsl_linalg_LU_decomp(XTX, perm, &signum);
  gsl_linalg_LU_solve(XTX, perm, XTy, c0);

  /* compute SVD of X */
  gsl_multifit_linear_svd(Xs, w);

  /* solve regularized standard form system with lambda */
  gsl_multifit_linear_solve(lambda, Xs, ys, c1, &rnorm0, &snorm0, w);

  /* test snorm = ||c1|| */
  snorm1 = gsl_blas_dnrm2(c1);
  gsl_test_rel(snorm0, snorm1, tol, "test_reg2: %s, snorm lambda=%g n=%zu p=%zu",
               desc, lambda, n, p);

  /* test rnorm = ||y - X c1|| */
  gsl_vector_memcpy(r, ys);
  gsl_blas_dgemv(CblasNoTrans, -1.0, Xs, c1, 1.0, r);
  rnorm1 = gsl_blas_dnrm2(r);
  gsl_test_rel(rnorm0, rnorm1, tol, "test_reg2: %s, rnorm lambda=%g n=%zu p=%zu",
               desc, lambda, n, p);

  /* test c0 = c1 */
  for (j = 0; j < p; ++j)
    {
      double c0j = gsl_vector_get(c0, j);
      double c1j = gsl_vector_get(c1, j);

      gsl_test_rel(c1j, c0j, tol, "test_reg2: %s, c0/c1 lambda=%g n=%zu p=%zu",
                   desc, lambda, n, p);
    }

  gsl_matrix_free(XTX);
  gsl_vector_free(XTy);
  gsl_matrix_free(Xs);
  gsl_vector_free(ys);
  gsl_vector_free(c0);
  gsl_vector_free(c1);
  gsl_vector_free(r);
  gsl_permutation_free(perm);
}
예제 #18
0
void KFKSDS_deriv_C (int *dim, double *sy, double *sZ, double *sT, double *sH, 
  double *sR, double *sV, double *sQ, double *sa0, double *sP0, double *dvof, 
  double *epshat, double *vareps, double *etahat, double *vareta, 
  double *r, double *N, double *dr, double *dN, 
  double *dahat, double *dvareps)
{
  //int s, p = dim[1], mp1 = m + 1;
  int i, ip1, j, k, n = dim[0], m = dim[2], 
    ir = dim[3], rp1 = ir + 1, nrp1 = n * rp1,
    rp1m = rp1 * m, iaux, irp1m,
    irsod = ir * sizeof(double), msod = m * sizeof(double), 
    nsod = n * sizeof(double), rp1msod = rp1 * msod;

  //double invf[n], vof[n], msHsq, dfinvfsq[nrp1];
  double msHsq;
  std::vector<double> invf(n);
  std::vector<double> vof(n);
  std::vector<double> dfinvfsq(nrp1);

  gsl_matrix_view Q = gsl_matrix_view_array(sQ, m, m);
  
  gsl_vector_view Z = gsl_vector_view_array(sZ, m);  
  gsl_vector * Z_cp = gsl_vector_alloc(m);

  gsl_matrix * ZtZ = gsl_matrix_alloc(m, m);
  gsl_matrix_view maux1, maux2;
  maux1 = gsl_matrix_view_array(gsl_vector_ptr(&Z.vector, 0), m, 1);
  gsl_vector_memcpy(Z_cp, &Z.vector);
  maux2 = gsl_matrix_view_array(gsl_vector_ptr(Z_cp, 0), 1, m);
  gsl_blas_dgemm(CblasNoTrans, CblasNoTrans, 1.0, &maux1.matrix, 
    &maux2.matrix, 0.0, ZtZ);
  
  gsl_matrix * a_pred = gsl_matrix_alloc(n, m);
  std::vector<gsl_matrix*> P_pred(n);
    
  gsl_matrix * K = gsl_matrix_alloc(n, m);
  gsl_vector_view K_irow;
  
  std::vector<gsl_matrix*> L(n);
  
  gsl_vector_view Qdiag = gsl_matrix_diagonal(&Q.matrix);
  gsl_vector * Qdiag_msq = gsl_vector_alloc(m);
  gsl_vector_memcpy(Qdiag_msq, &Qdiag.vector);
  gsl_vector_mul(Qdiag_msq, &Qdiag.vector);
  gsl_vector_scale(Qdiag_msq, -1.0);
  
  std::vector<gsl_matrix*> da_pred(rp1);

  std::vector< std::vector<gsl_matrix*> > dP_pred(n, std::vector<gsl_matrix*>(rp1));

  std::vector<gsl_matrix*> dK(n);
  
  // filtering
  
  KF_deriv_aux_C(dim, sy, sZ, sT, sH, sR, sV, sQ, sa0, sP0, 
    &invf, &vof, dvof, &dfinvfsq, a_pred, &P_pred, K, 
    &L, &da_pred, &dP_pred, &dK);

  // state vector smoothing and disturbances smoothing

  gsl_matrix_view V = gsl_matrix_view_array(sV, ir, ir);  
  gsl_matrix_view R = gsl_matrix_view_array(sR, m, ir);
  
  gsl_vector_view vaux;
  gsl_vector *vaux2 = gsl_vector_alloc(m);
  
  gsl_matrix *Mmm = gsl_matrix_alloc(m, m);
  gsl_matrix *Mmm2 = gsl_matrix_alloc(m, m);
  gsl_matrix *Mrm = gsl_matrix_alloc(ir, m);

  gsl_vector_memcpy(Z_cp, &Z.vector);
  
  gsl_matrix *r0 = gsl_matrix_alloc(n + 1, m);
  gsl_vector_view r_row_t;
  gsl_vector_view r_row_tp1 = gsl_matrix_row(r0, n);
  gsl_vector_set_zero(&r_row_tp1.vector);

  std::vector<gsl_matrix*> N0(n + 1);
  N0.at(n) = gsl_matrix_calloc(m, m);
  gsl_vector_view Ndiag;

  gsl_vector *var_eps = gsl_vector_alloc(n);  
  msHsq = -1.0 * pow(*sH, 2);
  //vaux = gsl_vector_view_array(invf, n);
  vaux = gsl_vector_view_array(&invf[0], n);
  gsl_vector_set_all(var_eps, msHsq);
  gsl_vector_mul(var_eps, &vaux.vector);
  gsl_vector_add_constant(var_eps, *sH);

  gsl_vector *vr = gsl_vector_alloc(ir);

  gsl_matrix *dL = gsl_matrix_alloc(m, m);

  std::vector<gsl_matrix*> dr0(n + 1);
  dr0.at(n) = gsl_matrix_calloc(rp1, m);
  gsl_vector_view dr_row_t, dr_row_tp1;

  std::vector< std::vector<gsl_matrix*> > dN0(n + 1, std::vector<gsl_matrix*>(rp1));
  
  for (j = 0; j < rp1; j++)
  {
    (dN0.at(n)).at(j) = gsl_matrix_calloc(m, m);
  }

  for (i = n-1; i > -1; i--)
  {
    ip1 = i + 1;
    iaux = (i-1) * rp1m;
    irp1m = i * rp1m;

    if (i != n-1)  //the case i=n-1 was initialized above
      r_row_tp1 = gsl_matrix_row(r0, ip1);
    r_row_t = gsl_matrix_row(r0, i);

    gsl_blas_dgemv(CblasTrans, 1.0, L.at(i), &r_row_tp1.vector, 
      0.0, &r_row_t.vector);
    gsl_vector_memcpy(Z_cp, &Z.vector);
    gsl_vector_scale(Z_cp, vof.at(i));
    gsl_vector_add(&r_row_t.vector, Z_cp);

    gsl_vector_memcpy(vaux2, &r_row_tp1.vector);
    memcpy(&r[i * m], vaux2->data, msod);
    
    N0.at(i) = gsl_matrix_alloc(m, m);
    gsl_matrix_memcpy(N0.at(i), ZtZ);
    gsl_blas_dgemm(CblasTrans, CblasNoTrans, 1.0, L.at(i), N0.at(ip1), 0.0, Mmm);
    gsl_blas_dgemm(CblasNoTrans, CblasNoTrans, 1.0, Mmm, L.at(i), invf.at(i), N0.at(i));
    
    vaux = gsl_matrix_diagonal(N0.at(ip1));
    gsl_vector_memcpy(vaux2, &vaux.vector);
    memcpy(&N[i * m], vaux2->data, msod);

    K_irow = gsl_matrix_row(K, i);
    gsl_blas_ddot(&K_irow.vector, &r_row_tp1.vector, &epshat[i]);
    epshat[i] -= vof.at(i);
    epshat[i] *= -*sH;

    maux1 = gsl_matrix_view_array(gsl_vector_ptr(&K_irow.vector, 0), 1, m);
    maux2 = gsl_matrix_view_array(gsl_vector_ptr(Z_cp, 0), 1, m);    
    gsl_blas_dgemm(CblasNoTrans, CblasNoTrans, 1.0, &maux1.matrix, N0.at(ip1),
      0.0, &maux2.matrix);
    vaux = gsl_vector_view_array(gsl_vector_ptr(var_eps, i), 1);
    gsl_blas_dgemv(CblasNoTrans, msHsq, &maux2.matrix, &K_irow.vector, 
      1.0, &vaux.vector);

    gsl_blas_dgemm(CblasNoTrans, CblasTrans, 1.0, &V.matrix, &R.matrix,
      0.0, Mrm);
    gsl_blas_dgemv(CblasNoTrans, 1.0, Mrm, &r_row_tp1.vector,
      0.0, vr);
    memcpy(&etahat[i*ir], vr->data, irsod);

    Ndiag = gsl_matrix_diagonal(N0.at(ip1));
    gsl_vector_memcpy(Z_cp, &Ndiag.vector); 
    gsl_vector_mul(Z_cp, Qdiag_msq);
    gsl_vector_add(Z_cp, &Qdiag.vector);
    gsl_blas_dgemv(CblasTrans, 1.0, &R.matrix, Z_cp, 0.0, vr);    
    memcpy(&vareta[i*ir], vr->data, irsod);

    // derivatives 

    dr0.at(i) = gsl_matrix_alloc(rp1, m);
    
    for (j = 0; j < rp1; j++)
    {
      k = i + j * n;
      
      gsl_vector_memcpy(Z_cp, &Z.vector);
      gsl_vector_scale(Z_cp, dvof[k]);      

      vaux = gsl_matrix_row(dK.at(i), j);
      maux1 = gsl_matrix_view_array(gsl_vector_ptr(&vaux.vector, 0), m, 1);
      maux2 = gsl_matrix_view_array(gsl_vector_ptr(&Z.vector, 0), 1, m);
      gsl_blas_dgemm(CblasNoTrans, CblasNoTrans, -1.0, &maux1.matrix, 
        &maux2.matrix, 0.0, dL);

      dr_row_t = gsl_matrix_row(dr0.at(i), j);
      dr_row_tp1 = gsl_matrix_row(dr0.at(ip1), j);
      gsl_blas_dgemv(CblasTrans, 1.0, dL, &r_row_tp1.vector, 0.0, &dr_row_t.vector);
      gsl_vector_add(&dr_row_t.vector, Z_cp);
      gsl_blas_dgemv(CblasTrans, 1.0, L.at(i), &dr_row_tp1.vector, 1.0, &dr_row_t.vector);

      (dN0.at(i)).at(j) = gsl_matrix_alloc(m, m);
      gsl_matrix_memcpy((dN0.at(i)).at(j), ZtZ);
      gsl_matrix_scale((dN0.at(i)).at(j), -1.0 * dfinvfsq.at(k));
      gsl_blas_dgemm(CblasTrans, CblasNoTrans, 1.0, dL, N0.at(ip1), 0.0, Mmm);
      gsl_blas_dgemm(CblasNoTrans, CblasNoTrans, 1.0, Mmm, L.at(i), 
        1.0, (dN0.at(i)).at(j));
      gsl_blas_dgemm(CblasTrans, CblasNoTrans, 1.0, L.at(i), 
        (dN0.at(ip1)).at(j), 0.0, Mmm);
      gsl_blas_dgemm(CblasNoTrans, CblasNoTrans, 1.0, Mmm, L.at(i), 
        1.0, (dN0.at(i)).at(j));
      gsl_blas_dgemm(CblasTrans, CblasNoTrans, 1.0, L.at(i), 
        N0.at(ip1), 0.0, Mmm);
      gsl_blas_dgemm(CblasNoTrans, CblasNoTrans, 1.0, Mmm, dL, 
        1.0, (dN0.at(i)).at(j));
      if (i != 0)
      {
        vaux = gsl_matrix_diagonal((dN0.at(i)).at(j));
        gsl_vector_memcpy(vaux2, &vaux.vector);
        memcpy(&dN[iaux + j * m], vaux2->data, msod);
      }

      vaux = gsl_matrix_row(da_pred.at(j), i);
      gsl_blas_dgemv(CblasNoTrans, 1.0, (dP_pred.at(i)).at(j) , &r_row_t.vector, 
        1.0, &vaux.vector);
      gsl_blas_dgemv(CblasNoTrans, 1.0, P_pred.at(i), &dr_row_t.vector, 
        1.0, &vaux.vector);
      gsl_vector_memcpy(vaux2, &vaux.vector);
      memcpy(&dahat[irp1m + j * m], vaux2->data, msod);

      gsl_matrix_memcpy(Mmm, (dP_pred.at(i)).at(j));
      gsl_blas_dgemm(CblasNoTrans, CblasNoTrans, -1.0, (dP_pred.at(i)).at(j), 
        N0.at(i), 0.0, Mmm2);
      gsl_blas_dgemm(CblasNoTrans, CblasNoTrans, 1.0, Mmm2, P_pred.at(i),
        1.0, Mmm);
      gsl_blas_dgemm(CblasNoTrans, CblasNoTrans, -1.0, P_pred.at(i), 
        (dN0.at(i)).at(j), 0.0, Mmm2);
      gsl_blas_dgemm(CblasNoTrans, CblasNoTrans, 1.0, Mmm2, P_pred.at(i),
        1.0, Mmm);
      gsl_blas_dgemm(CblasNoTrans, CblasNoTrans, -1.0, P_pred.at(i), 
        N0.at(i), 0.0, Mmm2);
      gsl_blas_dgemm(CblasNoTrans, CblasNoTrans, 1.0, Mmm2,
        (dP_pred.at(i)).at(j), 1.0, Mmm);
      
      gsl_matrix_mul_elements(Mmm, ZtZ);
      std::vector<double> vmm(Mmm->data, Mmm->data + m*m);
      dvareps[i*rp1 + j] = std::accumulate(vmm.begin(), vmm.end(), 0.0);

      gsl_matrix_free((dN0.at(ip1)).at(j));    
      gsl_matrix_free((dP_pred.at(i)).at(j));

    }

    if (i != 0)
    {
      memcpy(&dr[iaux], (dr0.at(i))->data, rp1msod);
    }

    gsl_matrix_free(dr0.at(ip1));
    
    gsl_matrix_free(dK.at(i));
    gsl_matrix_free(P_pred.at(i));
    gsl_matrix_free(L.at(i));
    gsl_matrix_free(N0.at(ip1));
  }

  gsl_matrix_free(N0.at(0));
  gsl_matrix_free(dr0.at(0));
  for (j = 0; j < rp1; j++)
  {
    gsl_matrix_free((dN0.at(0)).at(j));
    gsl_matrix_free(da_pred.at(j));
  }
  
  memcpy(&vareps[0], var_eps->data, nsod);
  
  gsl_matrix_free(Mmm);
  gsl_matrix_free(Mmm2);
  gsl_matrix_free(Mrm);
  
  gsl_matrix_free(r0);
  gsl_matrix_free(K);
  gsl_matrix_free(dL);
  
  gsl_matrix_free(a_pred);
  
  gsl_vector_free(Z_cp);
  gsl_matrix_free(ZtZ);
  gsl_vector_free(var_eps);
  gsl_vector_free(vr);
  gsl_vector_free(Qdiag_msq);
  gsl_vector_free(vaux2);
}}
예제 #19
0
gsl_matrix* pca(gsl_matrix* feature_matrix, gsl_vector* means, float sig_limit) {

    // subtract means of columns
    for (unsigned int j = 0; j < feature_matrix->size2; j++) {
        gsl_vector_view vv = gsl_matrix_column(feature_matrix,j);
        gsl_vector* v = &vv.vector;
        gsl_vector_set(means, j, getVectorMean(v));
        gsl_vector_add_constant(v, (-1.0) * gsl_vector_get(means,j));
    }

    // initialise matrix
    SEXP m;
    double* matrix;
    PROTECT(m = allocMatrix(REALSXP, feature_matrix->size1, feature_matrix->size2));
    matrix = REAL(m);
    for (unsigned int i = 0; i < feature_matrix->size1; i++) {
        for (unsigned int j = 0; j < feature_matrix->size2; j++) {
            matrix[i+(feature_matrix->size1)*j] = gsl_matrix_get( feature_matrix, i, j);
        }
    }

    // do principal components analysis, using R
    //fprintf(stderr, "PCA\n"); fflush(stdout);
    SEXP pca;
    PROTECT(pca = R_exec("prcomp", m));							//R_exec("print", pca);
    SEXP summary;
    PROTECT(summary = R_exec("summary", pca));						//R_exec("print", summary);


    // get proportion of variance
    SEXP ev;
    PROTECT(ev = get_list_element(pca,(char*)"sdev"));						//R_exec("print",ev);
    unsigned int dim = length(ev);									//printf("dim: %i\n", dim);

    float sum_var = 0.0;
    float c_ev = 0.0;
    for (unsigned int i = 0; i < dim; i++) {
        c_ev = (REAL(ev)[i]) * (REAL(ev)[i]);
        sum_var += c_ev;
    }

    float cum_var = 0.0;
    unsigned int sig_cnt = 0;
    for (unsigned int i = 0; i < dim; i++) {
        c_ev = (REAL(ev)[i]) * (REAL(ev)[i]);
        cum_var += c_ev;							 	//printf("ev%i: %.7g\n", i, REAL(ev)[i]);
        sig_cnt++;
        if ((cum_var/sum_var) > sig_limit) break;
    }

    //fprintf(stderr, "Cumulative variance of %g reached by using %i eigen vector(s).\n" , (cum_var/sum_var), sig_cnt);

    // get loads (eigenvectors)
    SEXP loads;
    PROTECT(loads = get_list_element(pca, (char*)"rotation"));					//R_exec("print", loads);
    gsl_matrix* rot = gsl_matrix_alloc(dim, sig_cnt);
    for (unsigned int i = 0; i < dim; i++) {
        for (unsigned int j = 0; j < sig_cnt; j++) {
            gsl_matrix_set(rot, i, j, REAL(loads)[i+dim*j]);			//printf("%g \n", REAL(loads)[i+dim*j]);
        }
    }

    // de-initialise R
    UNPROTECT(4);
    end_R();
    return(rot);
}
예제 #20
0
int DPMHC_xi_smplr(struct str_DPMHC *ptr_DPMHC_data, int i_J, struct str_firm_data *a_firm_data)
{
    int j,i;
    int i_K = ptr_DPMHC_data->i_K;
    int i_n = ptr_DPMHC_data->v_y->size; // is this the same as i_J???
    if (i_n != i_J){
        fprintf(stderr,"Error in  DPMN_xi_smplr(): DPMHC.v_y length does not equal i_J\n");
        exit(1);
    }
    double d_sumT_si;

    gsl_vector_int *vi_S = ptr_DPMHC_data->vi_S;
    gsl_matrix *m_theta = ptr_DPMHC_data->m_DPtheta;
    double d_A = ptr_DPMHC_data->d_A;
    double d_mu_si, d_tau_si, d_ei;
    double d_mean_j, d_var_j;
    double d_xi_j;

    int i_Ti;
    int i_factors = (a_firm_data[0].v_beta)->size;
    gsl_vector *v_ret;
    gsl_matrix *m_factors;
    gsl_vector *v_betai;
    gsl_vector *v_rstar_i;
    gsl_matrix *m_Xi;
    gsl_matrix_view mv_Xi;
    double d_rstar_j;
    double d_s2i;


    for(j=0;j<i_K;j++){

        d_mu_si = mget(m_theta,j,0);
        d_tau_si = mget(m_theta,j,2);


        d_rstar_j = 0.;
        d_sumT_si = 0;
        for(i=0;i<i_J;i++){
            if( vget_int(vi_S,i) == j ){

                d_ei = vget(ptr_DPMHC_data->v_e,i);

                m_factors = a_firm_data[i].m_factors;
                i_Ti = a_firm_data[i].i_ni;
                d_s2i = a_firm_data[i].d_s2;
                m_Xi = gsl_matrix_alloc(i_Ti,i_factors);
                mv_Xi = gsl_matrix_submatrix(m_factors,0,0,i_Ti,i_factors);
                gsl_matrix_memcpy(m_Xi,&mv_Xi.matrix);

                v_betai = a_firm_data[i].v_beta;
                v_ret = a_firm_data[i].v_ret;
                v_rstar_i = gsl_vector_alloc(i_Ti);
                gsl_vector_memcpy(v_rstar_i,v_ret);
                gsl_blas_dgemv(CblasNoTrans, -1.0, m_Xi, v_betai, 1.0, v_rstar_i);

                gsl_vector_add_constant(v_rstar_i, -d_mu_si);
                gsl_vector_scale(v_rstar_i, 1./(sqrt(d_tau_si) * d_ei) );

                d_rstar_j += sum(v_rstar_i);

                d_sumT_si += i_Ti/(d_s2i/(d_tau_si * d_ei * d_ei) );

                gsl_matrix_free(m_Xi);
                gsl_vector_free(v_rstar_i);
            }
        }

        d_var_j = 1./( 1./(d_A * d_A) + d_sumT_si);
        d_mean_j = d_rstar_j * d_var_j;

        d_xi_j = d_mean_j + gsl_ran_gaussian_ziggurat(rng, sqrt(d_var_j) );

        mset(m_theta, j, 1, d_xi_j);

       // printf("%d: eta = %g lambda^2 = %g\n",j, mget(m_theta,j,0), mget(m_theta,j,1) );
     }


    return 0;
}
struct scaling gsl_vector_normalize(gsl_vector * v){
    struct scaling scale = {gsl_vector_max(v) - gsl_vector_min(v), gsl_stats_mean(v->data, v->stride, v->size)};
    gsl_vector_add_constant(v, -scale.center);
    if(scale.scale!=0){gsl_vector_scale(v,1/scale.scale);}
    return scale;
}
예제 #22
0
int
gsl_multifit_linear_Lsobolev(const size_t p, const size_t kmax,
                             const gsl_vector *alpha, gsl_matrix *L,
                             gsl_multifit_linear_workspace *work)
{
  if (p > work->pmax)
    {
      GSL_ERROR("p is larger than workspace", GSL_EBADLEN);
    }
  else if (p <= kmax)
    {
      GSL_ERROR("p must be larger than derivative order", GSL_EBADLEN);
    }
  else if (kmax + 1 != alpha->size)
    {
      GSL_ERROR("alpha must be size kmax + 1", GSL_EBADLEN);
    }
  else if (p != L->size1)
    {
      GSL_ERROR("L matrix is wrong size", GSL_EBADLEN);
    }
  else if (L->size1 != L->size2)
    {
      GSL_ERROR("L matrix is not square", GSL_ENOTSQR);
    }
  else
    {
      int s;
      size_t j, k;
      gsl_vector_view d = gsl_matrix_diagonal(L);
      const double alpha0 = gsl_vector_get(alpha, 0);

      /* initialize L to alpha0^2 I */
      gsl_matrix_set_zero(L);
      gsl_vector_add_constant(&d.vector, alpha0 * alpha0);

      for (k = 1; k <= kmax; ++k)
        {
          gsl_matrix_view Lk = gsl_matrix_submatrix(work->Q, 0, 0, p - k, p);
          double ak = gsl_vector_get(alpha, k);

          /* compute a_k L_k */
          s = gsl_multifit_linear_Lk(p, k, &Lk.matrix);
          if (s)
            return s;
          gsl_matrix_scale(&Lk.matrix, ak);

          /* LTL += L_k^T L_k */
          gsl_blas_dsyrk(CblasLower, CblasTrans, 1.0, &Lk.matrix, 1.0, L);
        }

      s = gsl_linalg_cholesky_decomp(L);
      if (s)
        return s;

      /* copy Cholesky factor to upper triangle and zero out bottom */
      gsl_matrix_transpose_tricpy('L', 1, L, L);

      for (j = 0; j < p; ++j)
        {
          for (k = 0; k < j; ++k)
            gsl_matrix_set(L, j, k, 0.0);
        }

      return GSL_SUCCESS;
    }
}
int Holling2(double t, const double y[], double ydot[], void *params){

	double alpha	= 0.3;						// respiration
	double lambda	= 0.65;						// ecologic efficiency
	double hand	= 0.35;						// handling time
	double beta	= 0.5;						// intraspecific competition
	double aij	= 6.0;						// attack rate
	//double migratingPop = 0.01;
	
	int i, j,l	= 0;						// Hilfsvariablen
	double rowsum	= 0;	
	//double colsum	= 0;		  

// 	int test = 0;
// 	
// 	if(test<5)
// 	{
// 	  printf("Richtiges Holling");
// 	}
// 	test++;
//-- Struktur zerlegen-------------------------------------------------------------------------------------------------------------------------------

  	struct foodweb *nicheweb = (struct foodweb *)params;			// pointer cast from (void*) to (struct foodweb*)
	//printf("t in Holling 2=%f\n", t);
	gsl_vector *network = (nicheweb->network);						// Inhalt: A+linksA+Y+linksY+Massen+Trophische_Level = (Rnum+S)²+1+Y²+1+(Rnum+S)+S

	int S 	 	= nicheweb->S;
	int Y 	 	= nicheweb->Y;
	int Rnum	= nicheweb->Rnum;
	//double d  	= nicheweb->d;
	int Z 		= nicheweb->Z;
	//double dij 	= pow(10, d);
	double Bmigr = gsl_vector_get(network, (Rnum+S)*(S+Rnum)+1+Y*Y+1+(Rnum+S)+S);
	//printf("Bmigr ist %f\n", Bmigr);
	
	double nu,mu, tau;
	
	int SpeciesNumber;
	
	tau =  gsl_vector_get(nicheweb->migrPara,0);
	
	mu = gsl_vector_get(nicheweb->migrPara,1);
// 	if((int)nu!=0)
// 	{
// 	  printf("nu ist nicht null sondern %f\n",nu);
// 	}
	
	nu = gsl_vector_get(nicheweb->migrPara,2);
	
	SpeciesNumber = gsl_vector_get(nicheweb->migrPara,3);
	double tlast = gsl_vector_get(nicheweb->migrPara,4);
	
//  	if(SpeciesNumber!= 0)
// 	{
// 	  //printf("SpeciesNumber %i\n", SpeciesNumber);
// 	}
	  //printf("t oben %f\n",t);
		//int len	 = (Rnum+S)*(Rnum+S)+2+Y*Y+(Rnum+S)+S;
	
	gsl_vector_view A_view = gsl_vector_subvector(network, 0, (Rnum+S)*(Rnum+S));						// Fressmatrix A als Vektor
	gsl_matrix_view EA_mat = gsl_matrix_view_vector(&A_view.vector, (Rnum+S), (Rnum+S));				// A als Matrix_view
	gsl_matrix *EAmat	   = &EA_mat.matrix;															// A als Matrix

	gsl_vector_view D_view = gsl_vector_subvector(network, (Rnum+S)*(Rnum+S)+1, Y*Y);					// Migrationsmatrix D als Vektor
	gsl_matrix_view ED_mat = gsl_matrix_view_vector(&D_view.vector, Y, Y);								// D als Matrixview
	gsl_matrix *EDmat	   = &ED_mat.matrix;		// D als Matrix
	
	
	gsl_vector_view M_vec  = gsl_vector_subvector(network, ((Rnum+S)*(Rnum+S))+1+(Y*Y)+1, (Rnum+S));	// Massenvektor
	gsl_vector *Mvec	   = &M_vec.vector;
	
	
 //-- verändere zu dem gewünschten Zeitpunkt Migrationsmatrix	
	
	if( (t > tau) && (tlast < tau))
	{	
	    //printf("mu ist %f\n", gsl_vector_get(nicheweb->migrPara,1));
	    //printf("nu ist %f\n", nu);
	    gsl_vector_set(nicheweb->migrPara,4,t);

	    //printf("Setze Link für gewünschte Migration\n");
// 	    printf("t oben %f\n",t);
// 	    printf("tlast oben %f\n",tlast);
	    gsl_matrix_set(EDmat, nu, mu, 1.);
	    //int m;
// 	    for(l = 0; l< Y;l++)
// 	    {
// 		for(m=0;m<Y;m++)
// 		{
// 		  printf("%f\t",gsl_matrix_get(EDmat,l,m));
// 		}
// 	     printf("\n");
// 	    }
	}
	else
	{
	  gsl_matrix_set_zero(EDmat);
	}
	

	


			
// 			printf("\ncheckpoint Holling2 I\n");
// 			printf("\nS = %i\n", S);
// 			printf("\nS + Rnum = %i\n", S+Rnum);
// 
// 			printf("\nSize A_view = %i\n", (int)A_view.vector.size);
// 			printf("\nSize D_view = %i\n", (int)D_view.vector.size);
// 			printf("\nSize M_vec  = %i\n", (int)M_vec.vector.size);


// 			for(i=0; i<(Rnum+S)*Y; i++){
// 				printf("\ny = %f\n", y[i]);
// 				}

// 			for(i=0; i<(Rnum+S)*Y; i++){
// 			printf("\nydot = %f\n", ydot[i]);
// 			}
		

//--zusätzliche Variablen anlegen-------------------------------------------------------------------------------------------------------------

  double ytemp[(Rnum+S)*Y];		 
	for(i=0; i<(Rnum+S)*Y; i++) ytemp[i] = y[i];							// temp array mit Kopie der Startwerte
 	
  for(i=0; i<(Rnum+S)*Y; i++) ydot[i] = 0;									// Ergebnis, in das evolve_apply schreibt
 						
  gsl_vector_view yfddot_vec	= gsl_vector_view_array(ydot, (Rnum+S)*Y);		//Notiz: vector_view_array etc. arbeiten auf den original Daten der ihnen zugeordneten Arrays/Vektoren!
  gsl_vector *yfddotvec		= &yfddot_vec.vector;							// zum einfacheren Rechnen ydot über vector_view_array ansprechen
  
  gsl_vector_view yfd_vec	= gsl_vector_view_array(ytemp, (Rnum+S)*Y);
  gsl_vector *yfdvec		= &yfd_vec.vector;								// Startwerte der Populationen

//-- neue Objekte zum Rechnen anlegen--------------------------------------------------------------------------------------------------------

  gsl_matrix *AFgsl	= gsl_matrix_calloc(Rnum+S, Rnum+S);	// matrix of foraging efforts
//   gsl_matrix *ADgsl	= gsl_matrix_calloc(Y,Y); 				// matrix of migration efforts
  
  gsl_matrix *Emat	= gsl_matrix_calloc(Rnum+S, Rnum+S);	// gsl objects for calculations of populations 
  gsl_vector *tvec	= gsl_vector_calloc(Rnum+S);
  gsl_vector *rvec	= gsl_vector_calloc(Rnum+S);
  gsl_vector *svec	= gsl_vector_calloc(Rnum+S);
  
//   gsl_matrix *Dmat	= gsl_matrix_calloc(Y,Y);				// gsl objects for calculations of migration
//   gsl_vector *d1vec	= gsl_vector_calloc(Y);
  gsl_vector *d2vec	= gsl_vector_calloc(Y);
  gsl_vector *d3vec	= gsl_vector_calloc(Y);
  
//	printf("\ncheckpoint Holling2 III\n");

//-- Einzelne Patches lösen------------------------------------------------------------------------------------------------------------    
  for(l=0; l<Y; l++)								// start of patch solving
  {
    gsl_matrix_set_zero(AFgsl);						// Objekte zum Rechnen vor jedem Patch nullen 
    gsl_matrix_set_zero(Emat);
    gsl_vector_set_zero(tvec);
    gsl_vector_set_zero(rvec);
    gsl_vector_set_zero(svec);
    
    gsl_vector_view ydot_vec = gsl_vector_subvector(yfddotvec, (Rnum+S)*l, (Rnum+S));	// enthält ydot von Patch l
    gsl_vector *ydotvec 	 = &ydot_vec.vector;

    gsl_vector_view y_vec	 = gsl_vector_subvector(yfdvec, (Rnum+S)*l, (Rnum+S));		// enthält Startwerte der Population in l
    gsl_vector *yvec 		 = &y_vec.vector;
    
    gsl_matrix_memcpy(AFgsl, EAmat);
    
    for(i=0; i<Rnum+S; i++)
    {
      gsl_vector_view rowA   = gsl_matrix_row(AFgsl,i);
      				  rowsum = gsl_blas_dasum(&rowA.vector);
      if(rowsum !=0 )
      {
		for(j=0; j<Rnum+S; j++)
	    gsl_matrix_set(AFgsl, i, j, (gsl_matrix_get(AFgsl,i,j)/rowsum));				// normiere Beute Afgsl = A(Beutelinks auf 1 normiert) = f(i,j)
      }
    }
    
    gsl_matrix_memcpy(Emat, EAmat);									//  Emat = A
    gsl_matrix_scale(Emat, aij);									//  Emat(i,j) = a(i,j)
    gsl_matrix_mul_elements(Emat, AFgsl);							//  Emat(i,j) = a(i,j)*f(i,j)

    gsl_vector_memcpy(svec, yvec);									// s(i) = y(i)
    gsl_vector_scale(svec, hand);									// s(i) = y(i)*h
    gsl_blas_dgemv(CblasNoTrans, 1, Emat, svec, 0, rvec);			// r(i) = Sum_k h*a(i,k)*f(i,k)*y(k)
    gsl_vector_add_constant(rvec, 1);								// r(i) = 1+Sum_k h*a(i,k)*f(i,k)*y(k)
    	
    gsl_vector_memcpy(tvec, Mvec);									// t(i) = masse(i)^(-0.25)
    gsl_vector_div(tvec, rvec);										// t(i) = masse(i)^(-0.25)/(1+Sum_k h*a(i,k)*f(i,k)*y(k))
    gsl_vector_mul(tvec, yvec);										// t(i) = masse(i)^(-0.25)*y(i)/(1+Sum_k h*a(i,k)*f(i,k)*y(k))

    gsl_blas_dgemv(CblasTrans, 1, Emat, tvec, 0, rvec);				// r(i) = Sum_j a(j,i)*f(j,i)*t(j)
    gsl_vector_mul(rvec, yvec);										// r(i) = Sum_j a(j,i)*f(j,i)*t(j)*y(i) [rvec: Praedation]

    gsl_blas_dgemv(CblasNoTrans, lambda, Emat, yvec, 0, ydotvec);	// ydot(i) = Sum_j lambda*a(i,j)*f(i,j)*y(j)
    gsl_vector_mul(ydotvec, tvec);									// ydot(i) = Sum_j lambda*a(i,j)*f(i,j)*y(j)*t(i)
    
    gsl_vector_memcpy(svec, Mvec);
    gsl_vector_scale(svec, alpha);								// s(i) = alpha*masse^(-0.25) [svec=Respiration bzw. Mortalitaet]

    gsl_vector_memcpy(tvec, Mvec);
    gsl_vector_scale(tvec, beta);								// t(i) = beta*masse^(-0.25)
    gsl_vector_mul(tvec, yvec);									// t(i) = beta*y(i)
    gsl_vector_add(svec, tvec);									// s(i) = alpha*masse^(-0.25)+beta*y(i)
    	
    gsl_vector_mul(svec, yvec);									// s(i) = alpha*masse^(-0.25)*y(i)+beta*y(i)*y(i)
    gsl_vector_add(svec, rvec);									// [svec: Respiration, competition und Praedation]
    
    gsl_vector_sub(ydotvec, svec);								// ydot(i) = Fressen-Respiration-Competition-Praedation
    
    for(i=0; i<Rnum; i++)
      gsl_vector_set(ydotvec, i, 0.0);							// konstante Ressourcen
      
  }// Ende Einzelpatch, Ergebnis steht in ydotvec 

//	printf("\ncheckpoint Holling2 IV\n");
  
//-- Migration lösen---------------------------------------------------------------------------------------------------------    
  gsl_vector *ydottest	= gsl_vector_calloc(Y);
  double ydotmigr = gsl_vector_get(nicheweb->migrPara, 5);

//   int count=0,m;
//   for(l = 0; l< Y;l++)
//   {
// 	for(m=0;m<Y;m++)
// 	{
// 	  count += gsl_matrix_get(EDmat,l,m);
// 	} 
//   }
//   if(count!=0)
//   {
//     //printf("count %i\n",count);
//     //printf("t unten %f\n",t);
//     //printf("tau %f\n",tau);
//     for(l = 0; l< Y;l++)
//     {
// 	for(m=0;m<Y;m++)
// 	{
// 	  printf("%f\t",gsl_matrix_get(EDmat,l,m));
// 	}
//      printf("\n");
//      }
//   }
  double max = gsl_matrix_max(EDmat); 
  for(l = Rnum; l< Rnum+S; l++)								// start of migration solving
  {
    if(l == SpeciesNumber+Rnum && max !=0 )
    {
      //printf("max ist %f\n",max);
      //printf("l ist %i\n",l);
//       gsl_matrix_set_zero(ADgsl);								// reset gsl objects for every patch
//       gsl_matrix_set_zero(Dmat);    
//       gsl_vector_set_zero(d1vec);
      gsl_vector_set_zero(d2vec);
      gsl_vector_set_zero(d3vec);
      gsl_vector_set_zero(ydottest);

	// Untervektor von yfddot (enthält ydot[]) mit offset l (Rnum...Rnum+S) und Abstand zwischen den Elementen (stride) von Rnum+S.
	// Dies ergibt gerade die Größe einer Spezies in jedem Patch in einem Vektor
      gsl_vector_view dydot_vec = gsl_vector_subvector_with_stride(yfddotvec, l, (Rnum+S), Y);	// ydot[]		
      gsl_vector *dydotvec	  = &dydot_vec.vector;
/*
      gsl_vector_view dy_vec	  = gsl_vector_subvector_with_stride(yfdvec, l, (Rnum+S), Y);			// Startgrößen der Spezies pro Patch
      gsl_vector *dyvec		  = &dy_vec.vector;
   */       
//       gsl_matrix_memcpy(ADgsl, EDmat);		// ADgsl = D
//     
//       if(nicheweb->M == 1)				// umschalten w: patchwise (Abwanderung aus jedem Patch gleich), sonst linkwise (Abwanderung pro link gleich) 
// 	   {
// 		  for(i=0; i<Y; i++)
// 		   {
// 				gsl_vector_view colD = gsl_matrix_column(ADgsl, i);					// Spalte i aus Migrationsmatrix
// 							  colsum = gsl_blas_dasum(&colD.vector);
// 				if(colsum!=0)
// 					{
// 					  for(j=0;j<Y;j++)
// 					  gsl_matrix_set(ADgsl,j,i,(gsl_matrix_get(ADgsl,j,i)/colsum));		// ADgsl: D mit normierten Links
// 					}
// 		    }
// 	   }
// 
//       gsl_matrix_memcpy(Dmat, EDmat);					// Dmat = D
//       gsl_matrix_scale(Dmat, dij);					// Dmat(i,j) = d(i,j) (Migrationsstärke)
//       gsl_matrix_mul_elements(Dmat, ADgsl);				// Dmat(i,j) = d(i,j)*xi(i,j)   (skalierte und normierte Migrationsmatrix)
//      
//       gsl_vector_set_all(d1vec, 1/gsl_vector_get(Mvec, l));		// d1(i)= m(l)^0.25
//       gsl_vector_mul(d1vec, dyvec);					// d1(i)= m(l)^0.25*y(i)
//       gsl_blas_dgemv(CblasNoTrans, 1, Dmat, d1vec, 0, d2vec);		// d2(i)= Sum_j d(i,j)*xi(i,j)*m(l)^0.25*y(j)
//     
//       gsl_vector_set_all(d1vec, 1);					// d1(i)= 1
//       gsl_blas_dgemv(CblasTrans, 1, Dmat, d1vec, 0, d3vec);		// d3(i)= Sum_j d(i,j)*xi(i,j)
//       gsl_vector_scale(d3vec, 1/gsl_vector_get(Mvec,l));			// d3(i)= Sum_j d(i,j)*xi(i,j)*m(l)^0.25
//       gsl_vector_mul(d3vec, dyvec);					// d3(i)= Sum_j d(i,j)*xi(i,j)*m(l)^0.25*y(i)
//     
    
    
      gsl_vector_set(d2vec,nu,Bmigr);
      gsl_vector_set(d3vec,mu,Bmigr);
      
      
      gsl_vector_add(ydottest,d2vec);
      gsl_vector_sub(ydottest,d3vec);
      //printf("d2vec ist %f\n",gsl_vector_get(d2vec,0));
      //printf("d3vec ist %f\n",gsl_vector_get(d3vec,0));
      //if(gsl_vector_get(ydottest,mu)!=0)
      //{
      ydotmigr += gsl_vector_get(ydottest,nu);
//       printf("ydotmigr ist %f\n",ydotmigr);
      
      gsl_vector_set(nicheweb->migrPara,5,ydotmigr);
//     if(ydotmigr !=0)
//     {
//       printf("ydottest aufaddiert ist %f\n",ydotmigr);
//       printf("ydottest aufaddiert ist %f\n",gsl_vector_get(nicheweb->migrPara,5));
//     }
    
      gsl_vector_add(dydotvec, d2vec);				// 
      gsl_vector_sub(dydotvec, d3vec);				// Ergebnis in dydotvec (also ydot[]) = Sum_j d(i,j)*xi(i,j)*m(l)^0.25*y(j) - Sum_j d(i,j)*xi(i,j)*m(l)^0.25*y(i) 
      }
  }// Patch i gewinnt das was aus allen j Patches zuwandert und verliert was von i auswandert
  //printf("ydot ist %f\n",gsl_vector_get(ydottest,0));

	//printf("\ncheckpoint Holling2 V\n");

	/*
	for(i=0; i<(Rnum+S)*Y; i++){
		printf("\ny = %f\tydot=%f\n", y[i], ydot[i]);
		}
    */
//--check for fixed point attractor-----------------------------------------------------------------------------------
	
	if(t>7800){

		gsl_vector_set(nicheweb->fixpunkte, 0, 0);	
		gsl_vector_set(nicheweb->fixpunkte, 1, 0);
		gsl_vector_set(nicheweb->fixpunkte, 2, 0);		 

		int fix0 = (int)gsl_vector_get(nicheweb->fixpunkte, 0);
		int fix1 = (int)gsl_vector_get(nicheweb->fixpunkte, 1);
		int fix2 = (int)gsl_vector_get(nicheweb->fixpunkte, 2);


	//printf("t unten = %f\n", t);
	
		for(i=0; i<(Rnum+S)*Y; i++)
		  {
			  if(y[i] <= 0)
			  {
				fix0++;
				fix1++;
				fix2++;
			  }
			  else 
			  {
				if((ydot[i]/y[i]<0.0001) || (ydot[i]<0.0001)) fix0++;
				if(ydot[i]/y[i]<0.0001) fix1++;
				if(ydot[i]<0.0001) fix2++;
			  }
		  }

    if(fix0==(Rnum+S)*Y) gsl_vector_set(nicheweb->fixpunkte, 3, 1);
    if(fix1==(Rnum+S)*Y) gsl_vector_set(nicheweb->fixpunkte, 4, 1);
    if(fix2==(Rnum+S)*Y) gsl_vector_set(nicheweb->fixpunkte, 5, 1);
  }

//--Speicher leeren----------------------------------------------------------------------------------------------------- 

  gsl_matrix_free(Emat);  
//   gsl_matrix_free(Dmat);  
  gsl_matrix_free(AFgsl);  
//   gsl_matrix_free(ADgsl);
  
  gsl_vector_free(tvec);
  gsl_vector_free(rvec);
  gsl_vector_free(svec);
//   gsl_vector_free(d1vec);
  gsl_vector_free(d2vec);
  gsl_vector_free(d3vec);
  gsl_vector_free(ydottest);
  
//	printf("\nCheckpoint Holling2 VI\n");

  return GSL_SUCCESS;

}
예제 #24
0
int model::train(const dataset &ds)
{
	int ret = -1;
	gsl_matrix *km = NULL;
	gsl_matrix *ikm = NULL;
	gsl_permutation *perm = NULL;
	gsl_vector_view dv;

	gsl_matrix_free(_ikm);

	if (load_training_data(ds)) {
		ULIB_FATAL("couldn't load training data");
		goto done;
	}
	dbg_print_mat(_fm, "Feature Matrix:");
	if (get_col_mean()) {
		ULIB_FATAL("couldn't get feature column means");
		goto done;
	}
	zero_out_mat(_fm);
	if (get_col_sd()) {
		ULIB_FATAL("couldn't get feature column standard deviations");
		goto done;
	}
	norm_mat(_fm);
	dbg_print_mat(_fm, "Normalized Feature Matrix:");

	km = comp_kern_mat(_fm, _kern);
	dbg_print_mat(km, "Kernel Matrix:");
	if (km == NULL) {
		ULIB_FATAL("couldn't compute kernel matrix");
		goto done;
	}

	dv = gsl_matrix_diagonal(km);
	gsl_vector_add_constant(&dv.vector, _noise_var);

	ikm = gsl_matrix_alloc(km->size1, km->size2);
	if (ikm == NULL) {
		ULIB_FATAL("couldn't allocate cost model");
		goto done;
	}

	int signum;
	perm = gsl_permutation_alloc(ikm->size1);
	if (perm == NULL) {
		ULIB_FATAL("couldn't allocate cost model");
		goto done;
	}
	gsl_linalg_LU_decomp(km, perm, &signum);
	gsl_linalg_LU_invert(km, perm, ikm);
        gsl_vector_add_constant(_tv, -_t_avg);

	_ikm = ikm;
	ikm = NULL;
	ret = 0;
done:
	gsl_permutation_free(perm);
	gsl_matrix_free(km);
	gsl_matrix_free(ikm);

	return ret;
}
예제 #25
0
파일: NumVec.cpp 프로젝트: IEDB/smmpmbec
void	CNumVec::operator+=(double x)
{
	assert(m_vec!=NULL);
	if(gsl_vector_add_constant(m_vec,x))
		throw BPException("gsl_vector_add_constant");
}
예제 #26
0
파일: BEF.c 프로젝트: tatilitudu/BEF
double* intraguildPred(struct foodweb nicheweb, const double y[], double* intraPred)
{
  int i,j,l;

  int S 	 	= nicheweb.S;
  int Y 	     	= nicheweb.Y;
  int Rnum 		= nicheweb.Rnum;
  gsl_vector *network 	= nicheweb.network;						// Inhalt: A+linksA+Y+linksY+Massen+Trophische_Level = (Rnum+S)²+1+Y²+1+(Rnum+S)+S
  
  double lambda		= nicheweb.lambda;
  double aij		= nicheweb.aij;
  double hand		= nicheweb.hand;

  /* Massen rausholen */
  gsl_vector_view A_view = gsl_vector_subvector(network, 0, (Rnum+S)*(Rnum+S));						// Fressmatrix A als Vektor
  gsl_matrix_view EA_mat = gsl_matrix_view_vector(&A_view.vector, (Rnum+S), (Rnum+S));				// A als Matrix_view
  gsl_matrix *EAmat	   = &EA_mat.matrix;		// A als Matrix

  gsl_vector_view M_vec  = gsl_vector_subvector(network, ((Rnum+S)*(Rnum+S))+1+(Y*Y)+1, (Rnum+S));	// Massenvektor
  gsl_vector *Mvec	   = &M_vec.vector;				// massvector: M(i)=m^(-0.25)
  
  double ytemp[(Rnum+S)*Y];		// tempvector for populations and efforts
  for(i=0;i<(Rnum+S)*Y;i++)
    ytemp[i]=y[i];

  /* Alles view_array */
  
  /* Auslesen von ytemp = y[]; sind Population */
  gsl_vector_view yfd_vec=gsl_vector_view_array(ytemp,(Rnum+S)*Y);
  gsl_vector *yfdvec=&yfd_vec.vector;				// populations and efforts for later use
  
 
  
  
  /* Initialisierungen */
  gsl_matrix *AFgsl=gsl_matrix_calloc(Rnum+S, Rnum+S);		// matrix of foraging efforts
  
  gsl_matrix *Emat=gsl_matrix_calloc(Rnum+S, Rnum+S);		// gsl objects for calculations of populations 
  gsl_vector *tvec=gsl_vector_calloc(Rnum+S);
  gsl_vector *rvec=gsl_vector_calloc(Rnum+S);
  gsl_vector *svec=gsl_vector_calloc(Rnum+S);
  gsl_vector *intraPredTemp=gsl_vector_calloc(Rnum+S);
  
  
  for(l=0;l<Y;l++)						// start of patch solving
  {
    /* Initialisierungen */
    gsl_matrix_set_zero(AFgsl);					// reset gsl objects for every patch
    gsl_matrix_set_zero(Emat);
    gsl_vector_set_zero(tvec);
    gsl_vector_set_zero(rvec);
    gsl_vector_set_zero(svec);
   
    
    /* Je Vektoren von (Res+S) Elementen */


    /* yfdvec enthält die Population */
    gsl_vector_view y_vec=gsl_vector_subvector(yfdvec,(Rnum+S)*l,(Rnum+S));
    gsl_vector *yvecint=&y_vec.vector;
    
    /* Kopie von EAmat erstellen */
    gsl_matrix_memcpy(AFgsl,EAmat);

    for(i=0;i<Rnum+S;i++)
    {
      /* Nehme i-te Zeile aus A */
      gsl_vector_view tempp=gsl_matrix_row(AFgsl,i);
      
      /* Summiere Absolutwerte der Zeile */
      double temp1;	
      temp1=gsl_blas_dasum(&tempp.vector);
      if(temp1!=0)
      {
	/* Teile die Einträge, die nicht- Null sind durch Anzahl an nicht-Nullen in dieser Zeile*/ 
	/* und setzte diesen Wert dann an den entsprechenden Platz */
	/* Man erhält also eine prozentuale Verbindung */
	for(j=0;j<Rnum+S;j++)
	  gsl_matrix_set(AFgsl,i,j,(gsl_matrix_get(AFgsl,i,j)/temp1));
      }
    }
  
  /* aij ist Attackrate; AFgsl ist jetzt normiert- also fij  */
    gsl_matrix_memcpy(Emat,EAmat);
    gsl_matrix_scale(Emat,aij);					//  Emat(i,j) = a(i,j)
    gsl_matrix_mul_elements(Emat,AFgsl);			//  Emat(i,j) = a(i,j)*f(i,j)

    
    /*  hand =  handling time */
    /* Berechnung wie aus Paper */
    gsl_vector_set(yvecint,0,0);
    printf("y: %f\n",gsl_vector_get(yvecint,0));
    gsl_vector_memcpy(svec,yvecint);				// s(i)=y(i)
    gsl_vector_scale(svec, hand);				// s(i)=y(i)*h
    gsl_blas_dgemv(CblasNoTrans,1,Emat,svec,0,rvec);		// r(i)=Sum_k h*a(i,k)*f(i,k)*y(k)
    gsl_vector_add_constant(rvec,1);				// r(i)=1+Sum_k h*a(i,k)*f(i,k)*y(k)
    
    gsl_vector_memcpy(tvec,Mvec);				// t(i)=masse(i)^(-0.25)
    gsl_vector_div(tvec,rvec);					// t(i)=masse(i)^(-0.25)/(1+Sum_k h*a(i,k)*f(i,k)*y(k))
    gsl_vector_mul(tvec,yvecint);					// t(i)=masse(i)^(-0.25)*y(i)/(1+Sum_k h*a(i,k)*f(i,k)*y(k))

    gsl_blas_dgemv(CblasNoTrans,lambda,Emat,yvecint,0,intraPredTemp);	// ydot(i)=Sum_j lambda*a(i,j)*f(i,j)*y(j)
    gsl_vector_mul(intraPredTemp,tvec);
    
    intraPred[l] = gsl_blas_dasum(intraPredTemp);
  }
  /* Speicher befreien */
  gsl_matrix_free(Emat); 
  gsl_matrix_free(AFgsl);  
  
  gsl_vector_free(tvec);
  gsl_vector_free(rvec);
  gsl_vector_free(svec);
  gsl_vector_free(intraPredTemp);
  
  return 0;
}