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);
}
}
}
