double lda_m_step(lda* model, lda_suff_stats* ss) { int k, w; double lhood = 0; for (k = 0; k < model->ntopics; k++) { gsl_vector ss_k = gsl_matrix_column(ss->topics_ss, k).vector; gsl_vector log_p = gsl_matrix_column(model->topics, k).vector; if (LDA_USE_VAR_BAYES == 0) { gsl_blas_dcopy(&ss_k, &log_p); normalize(&log_p); vct_log(&log_p); } else { double digsum = sum(&ss_k)+model->nterms*LDA_TOPIC_DIR_PARAM; digsum = gsl_sf_psi(digsum); double param_sum = 0; for (w = 0; w < model->nterms; w++) { double param = vget(&ss_k, w) + LDA_TOPIC_DIR_PARAM; param_sum += param; double elogprob = gsl_sf_psi(param) - digsum; vset(&log_p, w, elogprob); lhood += (LDA_TOPIC_DIR_PARAM - param) * elogprob + gsl_sf_lngamma(param); } lhood -= gsl_sf_lngamma(param_sum); } } return(lhood); }
void eigensolve(vector vec1, vector vec2, vector vec3, real *vals, matrix symmat) { int i, j; double data[9]; gsl_matrix_view mat; gsl_vector_view vec; gsl_vector *eigval = gsl_vector_alloc(3); gsl_matrix *eigvec = gsl_matrix_alloc(3, 3); gsl_eigen_symmv_workspace *work = gsl_eigen_symmv_alloc(3); for (i = 0; i < 3; i++) for (j = 0; j < 3; j++) data[3*i + j] = symmat[i][j]; mat = gsl_matrix_view_array(data, 3, 3); gsl_eigen_symmv(&mat.matrix, eigval, eigvec, work); gsl_eigen_symmv_free(work); gsl_eigen_symmv_sort(eigval, eigvec, GSL_EIGEN_SORT_VAL_DESC); for (i = 0; i < 3; i++) vals[i] = gsl_vector_get(eigval, i); vec = gsl_matrix_column(eigvec, 0); for (i = 0; i < 3; i++) vec1[i] = gsl_vector_get(&vec.vector, i); vec = gsl_matrix_column(eigvec, 1); for (i = 0; i < 3; i++) vec2[i] = gsl_vector_get(&vec.vector, i); vec = gsl_matrix_column(eigvec, 2); for (i = 0; i < 3; i++) vec3[i] = gsl_vector_get(&vec.vector, i); gsl_vector_free(eigval); gsl_matrix_free(eigvec); }
void ica_match_gt(gsl_matrix *true_a, gsl_matrix *true_s, gsl_matrix *esti_a, gsl_matrix *esti_s){ /* Sort estimated loading and source matrices to match ground truth*/ const size_t NCOMP = true_s->size1; const size_t NVOX = true_s->size2; const size_t NSUB = true_a->size1; gsl_matrix *cs = gsl_matrix_alloc(NCOMP, NCOMP); // cs <- CORR(S, S') matrix_cross_corr_row(cs, true_s, esti_s); matrix_apply_all(cs, absolute); // index <- cs.max(axis = 1 ); size_t i; gsl_vector_view a_row, b_row; gsl_vector *index = gsl_vector_alloc(NCOMP); for (i = 0; i < NCOMP; i++) { a_row = gsl_matrix_row(cs, i); gsl_vector_set(index, i, gsl_stats_max_index(a_row.vector.data, a_row.vector.stride, a_row.vector.size)); } // Sort estimated sources // S' <- S'[index,:] gsl_matrix *temp = gsl_matrix_alloc(NCOMP, NVOX); gsl_matrix_memcpy(temp, esti_s); #pragma omp parallel for private(i,a_row,b_row) for (i = 0; i < NCOMP; i++) { a_row = gsl_matrix_row(esti_s, i); b_row = gsl_matrix_row(temp, gsl_vector_get(index, i)); gsl_vector_memcpy(&a_row.vector, &b_row.vector); } gsl_matrix_free(temp); // Sort estimated loadings // A' <- A'[:,index] temp = gsl_matrix_alloc(NSUB, NCOMP); gsl_matrix_memcpy(temp, esti_a); #pragma omp parallel for private(i,a_row,b_row) for (i = 0; i < NCOMP; i++) { a_row = gsl_matrix_column(esti_a, i); b_row = gsl_matrix_column(temp, gsl_vector_get(index, i)); gsl_vector_memcpy(&a_row.vector, &b_row.vector); } gsl_matrix_free(temp); gsl_matrix_free(cs); gsl_vector_free(index); }
void gsl_matrix_normalize_columns(gsl_matrix * mat, struct scaling * scales){ if(scales == NULL){ for(unsigned i =0; i<mat->size2; i++){ gsl_vector_view col = gsl_matrix_column (mat, i); gsl_vector_normalize(&col.vector); } } else { for(unsigned i =0; i<mat->size2; i++){ gsl_vector_view col = gsl_matrix_column (mat, i); scales[i] = gsl_vector_normalize(&col.vector); } } }
void matrix_cross_corr(gsl_matrix *C, gsl_matrix *A, gsl_matrix *B){ size_t i,j; gsl_vector_view a, b; double c; #pragma omp parallel for private(i,j,a,b,c) for (i = 0; i < A->size2; i++) { for (j = 0; j < B->size2; j++) { a = gsl_matrix_column(A, i); b = gsl_matrix_column(B, j); c = gsl_stats_correlation(a.vector.data, a.vector.stride, b.vector.data, b.vector.stride, a.vector.size); gsl_matrix_set(C, i,j, c); } } }
static void set_intercept_vec_w(struct mvar_model *model, gsl_matrix *aug_A, gsl_vector *scale) { gsl_vector_view vec_view = gsl_matrix_column(aug_A, 0); gsl_vector_memcpy(model->w, &vec_view.vector); gsl_vector_scale(model->w, scale_factor(scale)); }
/* * Update the cost after swapping current medoid m with non-medoid n * Distance to closest medoid, closest medoid index are updated. */ static double pam_swap_cost(pam_partition p, size_t m, size_t n) { double cost = 0.0; size_t i, cl; gsl_vector_view col; /* Update for each column */ for (i = 0; i < p->M->size2; i++) { cl = gsl_vector_ulong_get(p->cl_index, i); /* If closest to medoid being removed, find new closest medoid */ if (cl == m) { col = gsl_matrix_column(p->M, i); gsl_vector_masked_min_index(&(col.vector), p->in_set, &cl, gsl_vector_ptr(p->cl_dist, i)); gsl_vector_ulong_set(p->cl_index, i, cl); } else { /* Check if the new medoid is closer than the old */ assert(gsl_vector_get(p->cl_dist, i) == gsl_matrix_get(p->M, gsl_vector_ulong_get(p->cl_index, i), i)); if (gsl_matrix_get(p->M, n, i) < gsl_vector_get(p->cl_dist, i)) { gsl_vector_set(p->cl_dist, i, gsl_matrix_get(p->M, n, i)); gsl_vector_ulong_set(p->cl_index, i, n); } } cost += gsl_vector_get(p->cl_dist, i); } return cost; }
int main (void) { size_t i,j; gsl_matrix *m = gsl_matrix_alloc (10, 10); for (i = 0; i < 10; i++) for (j = 0; j < 10; j++) gsl_matrix_set (m, i, j, sin (i) + cos (j)); for (j = 0; j < 10; j++) { gsl_vector_view column = gsl_matrix_column (m, j); double d; d = gsl_blas_dnrm2 (&column.vector); printf ("matrix column %d, norm = %g\n", j, d); } gsl_matrix_free (m); return 0; }
void find_eigens2(gsl_matrix *m, gsl_vector *eval,gsl_matrix *evec) { gsl_eigen_symmv_workspace * w = gsl_eigen_symmv_alloc (3); gsl_eigen_symmv (m, eval, evec, w); gsl_eigen_symmv_free (w); gsl_eigen_symmv_sort (eval, evec,GSL_EIGEN_SORT_ABS_ASC); { int i; for (i = 0; i < 3; i++) { double eval_i= gsl_vector_get (eval, i); gsl_vector_view evec_i= gsl_matrix_column (evec, i); gsl_vector_fprintf (stdout,&evec_i.vector, "%g"); } } gsl_vector_free (eval); gsl_matrix_free (evec); }
float calcular_norma(gsl_matrix *matriz, int columna) { int i; float normalizador=0; float norma; gsl_vector_view eval = gsl_matrix_column (matriz, columna); for (i = 0; i < 3; i++) { float eval_i = gsl_vector_get (&eval.vector, i); printf ("eigenvalue de la matriz %d = %g\n", columna, eval_i); float eval_i_sqr=eval_i*eval_i; printf ("eigenvalue cuadrado = %g\n", eval_i_sqr); normalizador=normalizador+eval_i_sqr; } norma=sqrt(normalizador); printf ("eigenvalue normalizado de la columna %d= %g\n", columna,norma); return norma; }
void gslu_rand_gaussian_matrix (const gsl_rng *r, gsl_matrix *A, const gsl_vector *mu, const gsl_matrix *Sigma, const gsl_matrix *L) { assert (A->size1 == mu->size && (Sigma || L)); for (size_t i=0; i<A->size1; i++) for (size_t j=0; j<A->size2; j++) gsl_matrix_set (A, i, j, gsl_ran_gaussian_ziggurat (r, 1.0)); if (L) { assert (L->size1 == L->size2 && L->size1 == mu->size); gsl_blas_dtrmm (CblasLeft, CblasLower, CblasNoTrans, CblasNonUnit, 1.0, L, A); } else { assert (Sigma->size1 == Sigma->size2 && Sigma->size1 == mu->size); gsl_matrix *_L = gsl_matrix_alloc (Sigma->size1, Sigma->size2); gsl_matrix_memcpy (_L, Sigma); gsl_linalg_cholesky_decomp (_L); gsl_blas_dtrmm (CblasLeft, CblasLower, CblasNoTrans, CblasNonUnit, 1.0, _L, A); gsl_matrix_free (_L); } for (size_t j=0; j<A->size2; j++) { gsl_vector_view a = gsl_matrix_column (A, j); gsl_vector_add (&a.vector, mu); } }
static void normalizeJacobian( gsl_matrix *jac, gsl_vector *scaling ) { for (int i = 0; i < jac->size2; i++) { gsl_vector jac_col = gsl_matrix_column(jac, i).vector; gsl_vector_set(scaling, i, 1 / gsl_blas_dnrm2(&jac_col)); gsl_vector_scale(&jac_col, gsl_vector_get(scaling, i)); } }
gsl_matrix * io_util_readMatFromTxt (const char *filename) { FILE *fp = fopen (filename, "r"); gsl_matrix *mat = NULL; if (!fp) { perror ("fopen"); return mat; } size_t N = 0, M = 0; N = io_util_numLinesInFile (fp); M = io_util_numFeatures (fp); mat = gsl_matrix_calloc (M, N); size_t len = 1024; char line[len]; int i = 0; while (fgets (line, len, fp)) { gsl_vector_view col = gsl_matrix_column (mat, i); _loadLineToVec (&col.vector, line, M); i++; } /* clean up */ fclose (fp); return mat; }
void VarproFunction::computeJacobianOfCorrection( const gsl_vector* yr, const gsl_matrix *Rorig, const gsl_matrix *perm, gsl_matrix *jac ) { size_t nrow = perm != NULL ? perm->size2 : getNrow(); gsl_matrix_set_zero(jac); gsl_matrix_set_zero(myTmpGradR); fillZmatTmpJac(myTmpJac, yr, Rorig, 1); for (size_t i = 0; i < perm->size2; i++) { for (size_t j = 0; j < getD(); j++) { gsl_vector_view jac_col = gsl_matrix_column(jac, i * getD() + j); /* Compute first term (correction of Gam^{-1} z_{ij}) */ gsl_vector_set_zero(myTmpCorr); mulZmatPerm(myTmpJacobianCol, myTmpJac, perm, i, j); myGam->multInvGammaVector(myTmpJacobianCol); myStruct->multByGtUnweighted(myTmpCorr, Rorig, myTmpJacobianCol, -1, 1); /* Compute second term (gamma * dG_{ij} * yr) */ gsl_matrix_set_zero(myTmpGradR); setPhiPermCol(i, perm, myPhiPermCol); gsl_matrix_set_col(myTmpGradR, j, myPhiPermCol); myStruct->multByGtUnweighted(myTmpCorr, myTmpGradR, yr, -1, 1); myStruct->multByWInv(myTmpCorr, 1); gsl_vector_memcpy(&jac_col.vector, myTmpCorr); } } }
int wrap_gsl_linalg_SV_solve(gsl_matrix* U, gsl_matrix* V, gsl_matrix* S, const gsl_matrix* b, gsl_matrix* x) { gsl_vector_view _S = gsl_matrix_diagonal(S); gsl_vector_const_view _b = gsl_matrix_const_column(b, 0); gsl_vector_view _x = gsl_matrix_column(x, 0); return gsl_linalg_SV_solve(U, V, &_S.vector, &_b.vector, &_x.vector); }
inline static void apply_givens_qr (size_t M, size_t N, gsl_matrix * Q, gsl_matrix * R, size_t i, size_t j, double c, double s) { size_t k; /* Apply rotation to matrix Q, Q' = Q G */ #if USE_BLAS { gsl_matrix_view Q0M = gsl_matrix_submatrix(Q,0,0,M,j+1); gsl_vector_view Qi = gsl_matrix_column(&Q0M.matrix,i); gsl_vector_view Qj = gsl_matrix_column(&Q0M.matrix,j); gsl_blas_drot(&Qi.vector, &Qj.vector, c, -s); } #else for (k = 0; k < M; k++) { double qki = gsl_matrix_get (Q, k, i); double qkj = gsl_matrix_get (Q, k, j); gsl_matrix_set (Q, k, i, qki * c - qkj * s); gsl_matrix_set (Q, k, j, qki * s + qkj * c); } #endif /* Apply rotation to matrix R, R' = G^T R (note: upper triangular so zero for column < row) */ #if USE_BLAS { k = GSL_MIN(i,j); gsl_matrix_view R0 = gsl_matrix_submatrix(R, 0, k, j+1, N-k); gsl_vector_view Ri = gsl_matrix_row(&R0.matrix,i); gsl_vector_view Rj = gsl_matrix_row(&R0.matrix,j); gsl_blas_drot(&Ri.vector, &Rj.vector, c, -s); } #else for (k = GSL_MIN (i, j); k < N; k++) { double rik = gsl_matrix_get (R, i, k); double rjk = gsl_matrix_get (R, j, k); gsl_matrix_set (R, i, k, c * rik - s * rjk); gsl_matrix_set (R, j, k, s * rik + c * rjk); } #endif }
inline static void apply_givens_lq (size_t M, size_t N, gsl_matrix * Q, gsl_matrix * L, size_t i, size_t j, double c, double s) { size_t k; /* Apply rotation to matrix Q, Q' = G Q */ #if USE_BLAS { gsl_matrix_view Q0M = gsl_matrix_submatrix(Q,0,0,j+1,M); gsl_vector_view Qi = gsl_matrix_row(&Q0M.matrix,i); gsl_vector_view Qj = gsl_matrix_row(&Q0M.matrix,j); gsl_blas_drot(&Qi.vector, &Qj.vector, c, -s); } #else for (k = 0; k < M; k++) { double qik = gsl_matrix_get (Q, i, k); double qjk = gsl_matrix_get (Q, j, k); gsl_matrix_set (Q, i, k, qik * c - qjk * s); gsl_matrix_set (Q, j, k, qik * s + qjk * c); } #endif /* Apply rotation to matrix L, L' = L G^T (note: lower triangular so zero for column > row) */ #if USE_BLAS { k = GSL_MIN(i,j); gsl_matrix_view L0 = gsl_matrix_submatrix(L, k, 0, N-k, j+1); gsl_vector_view Li = gsl_matrix_column(&L0.matrix,i); gsl_vector_view Lj = gsl_matrix_column(&L0.matrix,j); gsl_blas_drot(&Li.vector, &Lj.vector, c, -s); } #else for (k = GSL_MIN (i, j); k < N; k++) { double lki = gsl_matrix_get (L, k, i); double lkj = gsl_matrix_get (L, k, j); gsl_matrix_set (L, k, i, c * lki - s * lkj); gsl_matrix_set (L, k, j, s * lki + c * lkj); } #endif }
static int lmniel_set(void *vstate, const gsl_vector *swts, gsl_multifit_function_fdf *fdf, gsl_vector *x, gsl_vector *f, gsl_vector *dx) { int status; lmniel_state_t *state = (lmniel_state_t *) vstate; const size_t p = x->size; size_t i; /* initialize counters for function and Jacobian evaluations */ fdf->nevalf = 0; fdf->nevaldf = 0; /* evaluate function and Jacobian at x and apply weight transform */ status = gsl_multifit_eval_wf(fdf, x, swts, f); if (status) return status; if (fdf->df) status = gsl_multifit_eval_wdf(fdf, x, swts, state->J); else status = gsl_multifit_fdfsolver_dif_df(x, swts, fdf, f, state->J); if (status) return status; /* compute rhs = -J^T f */ gsl_blas_dgemv(CblasTrans, -1.0, state->J, f, 0.0, state->rhs); #if SCALE gsl_vector_set_zero(state->diag); #else gsl_vector_set_all(state->diag, 1.0); #endif /* set default parameters */ state->nu = 2; #if SCALE state->mu = state->tau; #else /* compute mu_0 = tau * max(diag(J^T J)) */ state->mu = -1.0; for (i = 0; i < p; ++i) { gsl_vector_view c = gsl_matrix_column(state->J, i); double result; /* (J^T J)_{ii} */ gsl_blas_ddot(&c.vector, &c.vector, &result); state->mu = GSL_MAX(state->mu, result); } state->mu *= state->tau; #endif return GSL_SUCCESS; } /* lmniel_set() */
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)); } }
int gsl_linalg_symmtd_decomp (gsl_matrix * A, gsl_vector * tau) { if (A->size1 != A->size2) { GSL_ERROR ("symmetric tridiagonal decomposition requires square matrix", GSL_ENOTSQR); } else if (tau->size + 1 != A->size1) { GSL_ERROR ("size of tau must be (matrix size - 1)", GSL_EBADLEN); } else { const size_t N = A->size1; size_t i; for (i = 0 ; i < N - 2; i++) { gsl_vector_view c = gsl_matrix_column (A, i); gsl_vector_view v = gsl_vector_subvector (&c.vector, i + 1, N - (i + 1)); double tau_i = gsl_linalg_householder_transform (&v.vector); /* Apply the transformation H^T A H to the remaining columns */ if (tau_i != 0.0) { gsl_matrix_view m = gsl_matrix_submatrix (A, i + 1, i + 1, N - (i+1), N - (i+1)); double ei = gsl_vector_get(&v.vector, 0); gsl_vector_view x = gsl_vector_subvector (tau, i, N-(i+1)); gsl_vector_set (&v.vector, 0, 1.0); /* x = tau * A * v */ gsl_blas_dsymv (CblasLower, tau_i, &m.matrix, &v.vector, 0.0, &x.vector); /* w = x - (1/2) tau * (x' * v) * v */ { double xv, alpha; gsl_blas_ddot(&x.vector, &v.vector, &xv); alpha = - (tau_i / 2.0) * xv; gsl_blas_daxpy(alpha, &v.vector, &x.vector); } /* apply the transformation A = A - v w' - w v' */ gsl_blas_dsyr2(CblasLower, -1.0, &v.vector, &x.vector, &m.matrix); gsl_vector_set (&v.vector, 0, ei); } gsl_vector_set (tau, i, tau_i); } return GSL_SUCCESS; } }
void pca_whiten( gsl_matrix *input,// NOBS x NVOX size_t const NCOMP, // gsl_matrix *x_white, // NCOMP x NVOX gsl_matrix *white, // NCOMP x NSUB gsl_matrix *dewhite, //NSUB x NCOMP int demean){ // get input reference size_t NSUB = input->size1; // demean input matrix if (demean){ matrix_demean(input); } // Convariance Matrix gsl_matrix *cov = gsl_matrix_alloc(NSUB, NSUB); matrix_cov(input, cov); // Set up eigen decomposition gsl_vector *eval = gsl_vector_alloc(NCOMP); //eigen values gsl_matrix *evec = gsl_matrix_alloc(NSUB, NCOMP); rr_eig(cov, eval, evec, NCOMP ); //Computing whitening matrix gsl_matrix_transpose_memcpy(white, evec); gsl_vector_view v; double e; size_t i; // white = eval^{-1/2} evec^T #pragma omp parallel for private(i,e,v) for (i = 0; i < NCOMP; i++) { e = gsl_vector_get(eval,i); v = gsl_matrix_row(white,i); gsl_blas_dscal(1/sqrt(e), &v.vector); } // Computing dewhitening matrix gsl_matrix_memcpy(dewhite, evec); // dewhite = evec eval^{1/2} #pragma omp parallel for private(i,e,v) for (i = 0; i < NCOMP; i++) { e = gsl_vector_get(eval,i); v = gsl_matrix_column(dewhite,i); gsl_blas_dscal(sqrt(e), &v.vector); } // whitening data (white x Input) gsl_blas_dgemm(CblasNoTrans,CblasNoTrans,1.0, white, input, 0.0, x_white); gsl_matrix_free(cov); gsl_matrix_free(evec); gsl_vector_free(eval); }
void VarproFunction::setPhiPermCol( size_t i, const gsl_matrix *perm, gsl_vector *phiPermCol ) { if (perm != NULL) { gsl_vector permCol = gsl_matrix_const_column(perm, i).vector; gsl_blas_dgemv(CblasNoTrans, 1.0, myPhi, &permCol, 0.0, phiPermCol); } else { gsl_vector phiCol = gsl_matrix_column(myPhi, i).vector; gsl_vector_memcpy(phiPermCol, &phiCol); } }
inline void model::norm_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); double d = gsl_vector_get(_col_sd, j); if (d > 1e-6) gsl_vector_scale(&cv.vector, 1/d); } }
int ap_gsl_linalg_SV_solve(gsl_matrix * x, gsl_matrix const * u, gsl_vector const * s, gsl_matrix const * v, gsl_matrix const * b){ const size_t p = x->size2; for(size_t i = 0; i < p; ++i){ gsl_vector_view xcol = gsl_matrix_column(x,i); gsl_vector_const_view bcol = gsl_matrix_const_column(b, i); gsl_linalg_SV_solve(u, v, s, &bcol.vector, &xcol.vector); } return GSL_SUCCESS; }
void solver_get_x0 (lua_State *L, gsl_vector_view *x0, size_t p) { gsl_matrix *m; lua_getfield (L, 1, "x0"); m = matrix_check (L, -1); if (m->size2 != 1 || m->size1 != p) luaL_error (L, "x0 should be a vector of length %d", p); *x0 = gsl_matrix_column (m, 0); lua_pop (L, 1); }
// f = I(||X||_2 <= 1) void project_spectral_norm_ball(gsl_matrix *X) { gsl_matrix *V = gsl_matrix_alloc(X->size1, X->size2); gsl_vector *d = gsl_vector_alloc(X->size2); gsl_vector *tmp = gsl_vector_alloc(X->size2); gsl_linalg_SV_decomp(X, W, d, tmp); int i; double d_i; gsl_matrix_set_zero(X); for (i = 0; i < X->size2; i++) { d_i = fmax(1, gsl_vector_get(d, i)); gsl_vector_view U_i = gsl_matrix_column(X, i); gsl_vector_view V_i = gsl_matrix_column(V, i); gsl_blas_dger(d_i, &U_i.vector, &V_i.vector, X); } gsl_vector_free(d); gsl_matrix_free(V); gsl_vector_free(tmp); }
static void set_data_mat_K_observations(struct mvar_fit *fit, gsl_matrix *K) { gsl_matrix_view mat_view; gsl_vector_view vec_view; size_t i, j; mat_view = gsl_matrix_submatrix(fit->v, fit->p, 0, fit->n - fit->p, fit->m); for (i = fit->nr_params, j = 0; i < K->size2; i++, j++) { vec_view = gsl_matrix_column(&mat_view.matrix, j); gsl_matrix_set_col(K, i, &vec_view.vector); } }
double PoissonGlm::getDisper( unsigned int id, double th )const { unsigned int i, df, nNonZero=0; double ss2, yij, mij, chi2=0; gsl_vector_view yj = gsl_matrix_column (Yref, id); gsl_vector_view mj = gsl_matrix_column (Mu, id); for (i=0; i<nRows; i++) { yij = gsl_vector_get (&yj.vector, i); mij = gsl_vector_get (&mj.vector, i); ss2 = (yij-mij)*(yij-mij); // ss = (y-mu)^2 if ( mij<mintol ) mij = 1; else nNonZero++; if ( varfunc(mij, th)>eps ) chi2 = chi2 + ss2/varfunc(mij, th); // dist dependant } if (nNonZero > nParams) df = nNonZero - nParams; else df = 1; // df = nRows - nParams; return chi2/df; }
/*same as above but with transpose for q; i.e QtS and not QS */ inline void qr_qtmproduct(double* a, double* tau, double* s, int m,int n,int p){ gsl_matrix_view av=gsl_matrix_view_array(a,m,n); gsl_matrix_view sv=gsl_matrix_view_array(s,m,p); int d; if (m<n) d=m; else d=n; gsl_vector_view tv=gsl_vector_view_array(tau,d); int i; for (i=0;i<p;i++){ gsl_vector_view scv=gsl_matrix_column(&sv.matrix,i); gsl_linalg_QR_QTvec(&av.matrix,&tv.vector,&scv.vector); } }
void initialize_lda_ss_from_random(corpus_t* data, lda_suff_stats* ss) { int k, n; gsl_rng * r = new_random_number_generator(); for (k = 0; k < ss->topics_ss->size2; k++) { gsl_vector topic = gsl_matrix_column(ss->topics_ss, k).vector; gsl_vector_set_all(&topic, 0); for (n = 0; n < topic.size; n++) { vset(&topic, n, gsl_rng_uniform(r) + 0.5 / data->ndocs + 4.0); } } }