void estimate_rank_and_buildQ2(mat *M, int kblock, double TOL, mat **Y, mat **Q, int *good_rank){ int m,n,i,j,ind,exit_loop = 0; double error_norm; mat *RN,*Y_new,*Y_big,*QtM,*QQtM; vec *vi,*vj,*p,*p1; m = M->nrows; n = M->ncols; // build random matrix printf("form RN..\n"); RN = matrix_new(n,kblock); initialize_random_matrix(RN); // multiply to get matrix of random samples Y printf("form Y: %d x %d..\n",m,kblock); *Y = matrix_new(m, kblock); matrix_matrix_mult(M, RN, *Y); ind = 0; while(!exit_loop){ printf("form Q..\n"); if(ind > 0){ matrix_delete(*Q); } *Q = matrix_new((*Y)->nrows, (*Y)->ncols); QR_factorization_getQ(*Y, *Q); // compute QtM QtM = matrix_new((*Q)->ncols, M->ncols); matrix_transpose_matrix_mult(*Q,M,QtM); // compute QQtM QQtM = matrix_new(M->nrows, M->ncols); matrix_matrix_mult(*Q,QtM,QQtM); error_norm = 0.01*get_percent_error_between_two_mats(QQtM, M); printf("Y is of size %d x %d and error_norm = %f\n", (*Y)->nrows, (*Y)->ncols, error_norm); *good_rank = (*Y)->ncols; // add more samples if needed if(error_norm > TOL){ Y_new = matrix_new(m, kblock); initialize_random_matrix(RN); matrix_matrix_mult(M, RN, Y_new); Y_big = matrix_new((*Y)->nrows, (*Y)->ncols + Y_new->ncols); append_matrices_horizontally(*Y, Y_new, Y_big); matrix_delete(*Y); *Y = matrix_new(Y_big->nrows,Y_big->ncols); matrix_copy(*Y,Y_big); matrix_delete(Y_big); matrix_delete(Y_new); matrix_delete(QtM); matrix_delete(QQtM); ind++; } else{ matrix_delete(RN); exit_loop = 1; } } }
static Matrix *new_matrix(void) { Config *config = config_new(TEST_RAW_LEN, TEST_COL_LEN); return matrix_new(config); }
void estimate_rank_and_buildQ(mat *M, double frac_of_max_rank, double TOL, mat **Q, int *good_rank){ int m,n,i,j,ind,maxdim; double vec_norm; mat *RN,*Y,*Qbig,*Qsmall; vec *vi,*vj,*p,*p1; m = M->nrows; n = M->ncols; maxdim = round(min(m,n)*frac_of_max_rank); vi = vector_new(m); vj = vector_new(m); p = vector_new(m); p1 = vector_new(m); // build random matrix printf("form RN..\n"); RN = matrix_new(n, maxdim); initialize_random_matrix(RN); // multiply to get matrix of random samples Y printf("form Y: %d x %d..\n",m,maxdim); Y = matrix_new(m, maxdim); matrix_matrix_mult(M, RN, Y); // estimate rank k and build Q from Y printf("form Qbig..\n"); Qbig = matrix_new(m, maxdim); matrix_copy(Qbig, Y); printf("estimate rank with TOL = %f..\n", TOL); *good_rank = maxdim; int forbreak = 0; for(j=0; !forbreak && j<maxdim; j++){ matrix_get_col(Qbig, j, vj); for(i=0; i<j; i++){ matrix_get_col(Qbig, i, vi); project_vector(vj, vi, p); vector_sub(vj, p); if(vector_get2norm(p) < TOL && vector_get2norm(p1) < TOL){ *good_rank = j; forbreak = 1; break; } vector_copy(p1,p); } vec_norm = vector_get2norm(vj); vector_scale(vj, 1.0/vec_norm); matrix_set_col(Qbig, j, vj); } printf("estimated rank = %d\n", *good_rank); Qsmall = matrix_new(m, *good_rank); *Q = matrix_new(m, *good_rank); matrix_copy_first_columns(Qsmall, Qbig); QR_factorization_getQ(Qsmall, *Q); matrix_delete(RN); matrix_delete(Y); matrix_delete(Qsmall); matrix_delete(Qbig); }
} void matrix_transpose(mat m) { for (int i = 0; i < m->m; i++) { for (int j = 0; j < i; j++) { double t = m->v[i][j]; m->v[i][j] = m->v[j][i]; m->v[j][i] = t; } } } mat matrix_copy(int n;double a[][n], int m, int n) { mat x = matrix_new(m, n); for (int i = 0; i < m; i++) for (int j = 0; j < n; j++) x->v[i][j] = a[i][j]; return x; } mat matrix_mul(mat x, mat y) { if (x->n != y->m) return 0; mat r = matrix_new(x->m, y->n); for (int i = 0; i < x->m; i++) for (int j = 0; j < y->n; j++) for (int k = 0; k < x->n; k++) r->v[i][j] += x->v[i][k] * y->v[k][j]; return r;
int test_sparse_vector() { starting_tests(); learner_error error; SparseVector *v1, *v2; // create a generic matrix Matrix *m; error = matrix_new(&m); // creating error = sparse_vector_new(&v1, m); test_error(error); error = sparse_vector_new(&v2, m); test_error(error); // setting test_set_value(v1, 1, 2.0); test_set_value(v1, 0, 1.0); test_set_value(v2, 0, 3.0); test_set_value(v2, 3, 4.0); test_set_value(v2, 2, 5.0); // getting float value; test_get_value(v1, 0, 1.0); test_get_value(v1, 1, 2.0); test_get_value(v2, 0, 3.0); test_get_value(v2, 2, 5.0); test_get_value(v2, 3, 4.0); // freezing int frozen; error = sparse_vector_freeze(v1); test_error(error); error = sparse_vector_freeze(v2); test_error(error); error = sparse_vector_frozen(v1, &frozen); test_error(error); test(frozen); error = sparse_vector_frozen(v2, &frozen); test_error(error); test(frozen); // magnitude error = sparse_vector_magnitude(v1, &value); test_error(error); test_float(value, sqrtf(5.0)); error = sparse_vector_magnitude(v2, &value); test_error(error); test_float(value, sqrtf(50.0)); // euclidean distance error = sparse_vector_euclidean_distance(v1, v2, &value); test_error(error); test_float(value, sqrtf(4.0 + 4.0 + 25.0 + 16.0)); // dot product error = sparse_vector_dot_product(v1, v2, &value); test_error(error); test_float(value, 3.0); // cosine similarity error = sparse_vector_cosine_similarity(v1, v2, &value); test_error(error); test_float(value, ((3.0) / (sqrtf(5.0) * sqrtf(50.0)))); // setting existing values test_set_value(v1, 1, 12.0); test_set_value(v1, 0, 11.0); test_set_value(v2, 0, 13.0); test_set_value(v2, 3, 14.0); test_set_value(v2, 2, 15.0); // getting changed values test_get_value(v1, 0, 11.0); test_get_value(v1, 1, 12.0); test_get_value(v2, 0, 13.0); test_get_value(v2, 2, 15.0); test_get_value(v2, 3, 14.0); // cleanup error = sparse_vector_free(v1); test_error(error); error = sparse_vector_free(v2); test_error(error); finished_tests(); }
struct ekf *ekf_new(int n, int m, int nw, int nv) { struct ekf *ekf = malloc(sizeof(struct ekf)); if (ekf) { /* X(nx1) */ ekf->X = matrix_new(n, 1); /* P(nxn) */ ekf->P = matrix_new(n, n); /* A(nxn) */ ekf->A = matrix_new(n, n); /* H(mxn) */ ekf->H = matrix_new(n, m); /* V(nxnw) */ ekf->V = matrix_new(m, nv); /* R(mxm) */ ekf->R = matrix_new(m, m); /* W(nxnw) */ ekf->W = matrix_new(n, nw); /* Q(nxn) */ ekf->Q = matrix_new(n, n); /* E(?x?) */ /* K(nxm) */ ekf->K = matrix_new(n, m); /* Tnxm(nxm) */ ekf->Tnxm = matrix_new(n, m); /* Tnxn(nxn) */ ekf->Tnxn = matrix_new(n, n); /* Tmxm(mxm) */ ekf->Tmxm = matrix_new(m, m); ekf->n = n; ekf->m = m; ekf->nw = nw; ekf->nv = nv; } return ekf; }
/* main: application entry point. * @argc: the number of commandline arguments. * @argv: the commandline argument string array. */ int main (int argc, char **argv) { /* declare required variables. */ pca_distance_metric metric; char *ifname, *metstr; struct matrix *D; struct pca *P; /* parse the command-line arguments. */ if (!opts_init (argc, argv)) { /* output an error message and exit. */ ferror ("failed to parse arguments"); fprintf (stdout, HELP); return 1; } /* see if we should display the help message. */ if (opts_geti (OPTS_S_HELP)) { /* print the help message and quit. */ fprintf (stdout, HELP); return 0; } /* get the input filename. */ ifname = opts_gets (OPTS_S_INPUT); /* ensure the input filename was provided. */ if (!ifname) { /* output an error message and exit. */ ferror ("input file required"); fprintf (stdout, HELP); return 1; } /* read in the input file. */ P = pca_new (ifname); /* make sure we read in the file. */ if (!P) { /* output an error message and exit. */ ferror ("failed to read '%s'", ifname); return 1; } /* set the default distance metric. */ metric = pca_group_distance_euclidean; /* get the distance metric string. */ metstr = opts_gets (OPTS_S_METRIC); /* see if the distance metric was provided. */ if (metstr) { /* check the distance metric argument. */ if (strncmp (metstr, "EUC", 3) == 0 || strncmp (metstr, "euc", 3) == 0) { /* set the euclidean metric. */ metric = pca_group_distance_euclidean; } else if (strncmp (metstr, "MAH", 3) == 0 || strncmp (metstr, "mah", 3) == 0) { /* set the mahalanobis distance. */ metric = pca_group_distance_mahalanobis; } else if (strncmp (metstr, "BHA", 3) == 0 || strncmp (metstr, "bha", 3) == 0) { /* set the bhattacharyya distance. */ metric = pca_group_distance_bhattacharyya; } else if (strncmp (metstr, "HEL", 3) == 0 || strncmp (metstr, "hel", 3) == 0) { /* set the hellinger distance. */ metric = pca_group_distance_hellinger; } else if (strncmp (metstr, "MIX", 3) == 0 || strncmp (metstr, "mix", 3) == 0) { /* set the mixture distance. */ metric = pca_group_distance_mixture; } else if (strncmp (metstr, "CHI", 3) == 0 || strncmp (metstr, "chi", 3) == 0) { /* set the mixture distance. */ metric = pca_group_distance_chisq; } else { /* output an error message and exit. */ ferror ("unrecognized distance metric '%s'", metstr); fprintf (stdout, HELP); return 1; } } /* allocate a distance matrix. */ D = matrix_new (P->n_groups, P->n_groups); /* make sure we allocated a matrix. */ if (!D) { /* output an error message and exit. */ ferror ("failed to allocate distance matrix"); return 1; } /* calculate the distance matrix. */ if (!pca_distances (P, D, metric)) { /* output an error message and exit. */ ferror ("failed to calculate distance matrix"); return 1; } /* write out the distance matrix. */ pca_distances_print (P, D); /* free the distance matrix. */ matrix_free (D); /* free the pca structure. */ pca_free (P); /* return success. */ return 0; }
/* main: application entry point. * @argc: the number of commandline arguments. * @argv: the commandline argument string array. */ int main (int argc, char **argv) { /* declare required variables. */ struct vector *x, *y, *z, *u; struct matrix *V, *R, *C; double theta; char *smean, *svar, *label; unsigned long n; int i; /* initialize the random number generator. */ rand_init (time (NULL)); /* parse the command-line arguments. */ if (!opts_init (argc, argv)) { /* output an error message and exit. */ ferror ("failed to parse arguments"); fprintf (stdout, HELP); return 1; } /* see if we should display the help message. */ if (opts_geti (OPTS_S_HELP)) { /* print the help message and quit. */ fprintf (stdout, HELP); return 0; } /* get the number of points to produce. */ n = opts_geti (OPTS_S_COUNT); /* ensure the point count is valid. */ if (!n) { /* output an error message and exit. */ ferror ("invalid point count (%lu)", n); fprintf (stdout, HELP); return 1; } /* get the points label. */ label = opts_gets (OPTS_S_LABEL); /* ensure the points label is valid. */ if (!label) { /* output an error message and exit. */ ferror ("invalid label '%s'", label); fprintf (stdout, HELP); return 1; } /* allocate the math structures. */ x = vector_new (2); y = vector_new (2); z = vector_new (2); u = vector_new (2); V = matrix_new (2, 2); R = matrix_new (2, 2); C = matrix_new (2, 2); /* ensure we allocated the math structures. */ if (!x || !y || !z || !u || !V || !R || !C) { /* output an error message and exit. */ ferror ("failed to allocate math structures"); return 1; } /* get the mean string. */ smean = opts_gets (OPTS_S_MEAN); /* did we get a mean string? */ if (smean) { /* try to parse the string. */ if (sscanf (smean, "(%lf,%lf)", &u->d[0], &u->d[1]) != 2) { /* output an error message and exit. */ ferror ("failed to parse mean string '%s'", smean); fprintf (stdout, HELP); return 1; } } else { /* initialize to the origin. */ u->d[0] = u->d[1] = 0.0; } /* get the variance string. */ svar = opts_gets (OPTS_S_VAR); /* did we get a variance string? */ if (svar) { /* try to parse the string. */ if (sscanf (svar, "(%lf,%lf)", &V->d[0][0], &V->d[1][1]) != 2) { /* output an error message and exit. */ ferror ("failed to parse variance string '%s'", svar); fprintf (stdout, HELP); return 1; } } else { /* initialize to unit variances. */ V->d[0][0] = V->d[1][1] = 1.0; } /* get the rotation value. */ theta = opts_getf (OPTS_S_ROT) / 180.0 * M_PI; /* build the rotation matrix. */ R->d[0][0] = cos (theta); R->d[0][1] = -sin (theta); R->d[1][0] = sin (theta); R->d[1][1] = cos (theta); /* calculate the covariance matrix. */ if (!matrix_matrix_mul (1.0, R, V, C)) { /* output an error message and exit. */ ferror ("failed to calculate covariance matrix"); return 1; } /* see if we should produce a header. */ if (opts_geti (OPTS_S_HEADER)) { /* yep. print one. */ fprintf (stdout, "Obs ID (Primary)\tObs ID (Obs. Sec. ID:1)\tM1.t[2]\tM1.t[1]\n"); } /* loop a set number of times. */ for (i = 0; i < n; i++) { /* calculate the two values. */ x->d[0] = randnormal (); x->d[1] = randnormal (); /* scale the values. */ if (!matrix_vector_mul (1.0, C, x, y)) { /* output an error message and exit. */ ferror ("failed to scale random variate %d", i + 1); return 1; } /* translate the values. */ if (!vector_sum (1.0, y, 1.0, u, z)) { /* output an error message and exit. */ ferror ("failed to translate random variate %d", i + 1); return 1; } /* print the values. */ fprintf (stdout, "%d\t%s\t%lf\t%lf\n", i + 1, label, z->d[0], z->d[1]); } /* free the math structures. */ vector_free (x); vector_free (y); vector_free (z); vector_free (u); matrix_free (V); matrix_free (R); matrix_free (C); /* return success. */ return 0; }
int main() { int i, j, m, n, k, p, q, s, vnum, offset; int64_t frank, numnnz; double val,normM,normU,normS,normV,normP,percent_error; mat *M, *U, *S, *V, *P; struct timeval start_time, end_time; m = 50000; n = 100000; numnnz = m*n; // dense M = matrix_new(m,n); m = M->nrows; n = M->ncols; printf("sizes of M are %d by %d\n", m, n); printf("m*n = %" PRId64 "\n", numnnz); // this is bigger than a 32 bit int can hold printf("initializing random matrix..\n"); gettimeofday(&start_time,NULL); initialize_random_matrix(M); gettimeofday(&end_time,NULL); printf("done loading..\n"); printf("elapsed time: about %4.2f seconds\n", get_seconds_frac(start_time,end_time)); // now test low rank SVD of M.. k = 1000; // rank we want p = 20; // oversampling q = 3; // power scheme s = 1; // re-rotho for power scheme vnum = 1; // scheme to use printf("calling random SVD..\n"); gettimeofday(&start_time,NULL); low_rank_svd_rand_decomp_fixed_rank(M, k, p, vnum, q, s, &frank, &U, &S, &V); gettimeofday(&end_time,NULL); printf("elapsed time: about %4.2f seconds\n", get_seconds_frac(start_time,end_time)); // form product matrix P = matrix_new(m,n); form_svd_product_matrix(U,S,V,P); // get norms of each normM = get_matrix_frobenius_norm(M); normU = get_matrix_frobenius_norm(U); normS = get_matrix_frobenius_norm(S); normV = get_matrix_frobenius_norm(V); normP = get_matrix_frobenius_norm(P); printf("normM = %f ; normU = %f ; normS = %f ; normV = %f ; normP = %f\n", normM, normU, normS, normV, normP); // calculate percent error percent_error = get_percent_error_between_two_mats(M,P); printf("percent_error between M and U S V^T = %f\n", percent_error); // delete and exit printf("delete and exit..\n"); matrix_delete(M); matrix_delete(U); matrix_delete(S); matrix_delete(V); matrix_delete(P); return 0; }
int main (int argc, char **argv) { SDL_Surface *image; nile_t *nl; char mem[500000]; uint32_t texture_pixels[TEXTURE_WIDTH * TEXTURE_HEIGHT] = {0}; real angle = 0; real scale; if (SDL_Init (SDL_INIT_VIDEO) == -1) DIE ("SDL_Init failed: %s", SDL_GetError ()); if (!SDL_SetVideoMode (DEFAULT_WIDTH, DEFAULT_HEIGHT, 0, SDL_HWSURFACE | SDL_ANYFORMAT | SDL_DOUBLEBUF)) DIE ("SDL_SetVideoMode failed: %s", SDL_GetError ()); image = SDL_GetVideoSurface (); nl = nile_new (NTHREADS, mem, sizeof (mem)); ilInit (); ilBindImage (iluGenImage ()); if (argc < 3) return -1; printf ("loading: %s\n", argv[1]); ilLoadImage (argv[1]); ilCopyPixels (0, 0, 0, TEXTURE_WIDTH, TEXTURE_HEIGHT, 1, IL_BGRA, IL_UNSIGNED_BYTE, &texture_pixels); int filter = atoi (argv[2]); for (;;) { angle += 0.001; scale = fabs (angle - (int) angle - 0.5) * 10; SDL_Event event; if (SDL_PollEvent (&event) && event.type == SDL_QUIT) break; SDL_FillRect (image, NULL, 0); SDL_LockSurface (image); matrix_t M = matrix_new (); M = matrix_translate (M, 250, 250); M = matrix_rotate (M, angle); M = matrix_scale (M, scale, scale); M = matrix_translate (M, -250, -250); matrix_t I = matrix_inverse (M); nile_Kernel_t *texture = gezira_ReadFromImage_ARGB32 (nl, texture_pixels, TEXTURE_WIDTH, TEXTURE_HEIGHT, TEXTURE_WIDTH); /* */ texture = nile_Pipeline (nl, gezira_ImageExtendReflect (nl, TEXTURE_WIDTH, TEXTURE_HEIGHT), texture, NULL); if (filter == 2) texture = gezira_BilinearFilter (nl, texture); if (filter == 3) texture = gezira_BicubicFilter (nl, texture); /* */ texture = nile_Pipeline (nl, gezira_TransformPoints (nl, I.a, I.b, I.c, I.d, I.e - 150, I.f - 125), texture, NULL); nile_Kernel_t *pipeline = nile_Pipeline (nl, gezira_TransformBeziers (nl, M.a, M.b, M.c, M.d, M.e, M.f), gezira_ClipBeziers (nl, 0, 0, DEFAULT_WIDTH, DEFAULT_HEIGHT), gezira_Rasterize (nl), gezira_ApplyTexture (nl, texture), gezira_WriteToImage_ARGB32 (nl, image->pixels, DEFAULT_WIDTH, DEFAULT_HEIGHT, image->pitch / 4), NULL); nile_feed (nl, pipeline, path, 6, path_n, 1); nile_sync (nl); SDL_UnlockSurface (image); SDL_Flip (image); } nile_free (nl); printf ("done\n"); return 0; }
mat matrix_solve_qr(mat xMatrix, mat yMatrix) { mat qr,x,result; double *rDiag,s; int i,n,m,k,j,nx; /* Initial validations */ if (xMatrix->m != yMatrix->m) { printf("Matrix row dimensions must agree.\n"); exit(1); } /* Perform a QR decomp. */ n = xMatrix->n; m = xMatrix->m; rDiag = (double*)calloc(n,sizeof(double)); qr = matrix_copy(xMatrix); // Main loop. for (k = 0; k < n; k++) { // Compute 2-norm of k-th column without under/overflow. double nrm = 0; for (i = k; i < m; i++) { nrm = calc_hypot(nrm, qr->v[i][k]); } if (nrm != 0.0) { // Form k-th Householder vector. if (qr->v[k][k] < 0) { nrm = -nrm; } for (i = k; i < m; i++) { qr->v[i][k] /= nrm; } qr->v[k][k] += 1.0; // Apply transformation to remaining columns. for (j = k + 1; j < n; j++) { s = 0.0; for (i = k; i < m; i++) { s += qr->v[i][k] * qr->v[i][j]; } s = -s / qr->v[k][k]; for (i = k; i < m; i++) { qr->v[i][j] += s * qr->v[i][k]; } } } rDiag[k] = -nrm; } /* Validate */ for(i=0;i<n;i++) { if( fabs(rDiag[i])==0 ) { printf("Matrix is rank deficient. Data fails to converge."); exit(1); } } /* Now solve */ /* Copy right hand side */ nx = yMatrix->n; x = matrix_copy(yMatrix); /* Compute Y = transpose(Q)*B */ for (k = 0; k < n; k++) { for (j = 0; j < nx; j++) { s = 0.0; for (i = k; i < m; i++) { s += qr->v[i][k] * x->v[i][j]; } s = -s / qr->v[k][k]; for (i = k; i < m; i++) { x->v[i][j] += s * qr->v[i][k]; } } } /* Solve R*X = Y; */ for (k = n - 1; k >= 0; k--) { for (j = 0; j < nx; j++) { x->v[k][j] /= rDiag[k]; } for (i = 0; i < k; i++) { for (j = 0; j < nx; j++) { x->v[i][j] -= x->v[k][j] * qr->v[i][k]; } } } /* Build result matrix */ result = matrix_new(n,nx); for(i=0;i<n;i++) { for(j=0;j<nx;j++) { result->v[i][j] = x->v[i][j]; } } /* Cleanup */ matrix_delete(qr); matrix_delete(x); /* Return the result */ return result; }
/* read problem data from file * returns amount of lines * returns -1 when there was a reading error * returns -2 when the problem is infeasible */ int process_file(const char* filename, Matrix** matrix) { assert(NULL != filename); assert(0 < strlen(filename)); FILE* fp; char buf[MAX_LINE_LEN]; char* s; char* tok; char delimiter[2] = " "; char* test; char relation[3]; int lines = 0; int m = -1; int n = -1; TYPE* coefs = NULL; TYPE rhs; int i = 0; int j = 0; if (NULL == (fp = fopen(filename, "r"))) { fprintf(stderr, "Can't open file %s\n", filename); return -1; } while(NULL != (s = fgets(buf, sizeof(buf), fp))) { char* t = strpbrk(s, "#\n\r"); lines++; if (NULL != t) /* else line is not terminated or too long */ *t = '\0'; /* clip comment or newline */ /* Skip over leading space */ while(isspace(*s)) s++; /* Skip over empty lines */ if (!*s) /* <=> (*s == '\0') */ continue; /* read lines */ i++; j = 0; #ifdef debug fprintf(stdout, "line %i: %s\n", lines, s); #endif tok = strtok(s, delimiter); switch(i) { /* first line contains amount of columns (variables) */ case 1: { n = strtol(tok, &test, 10); if ((int)strlen(test) != 0) { fprintf(stderr, "Wrong input data for number of variables.\n"); return -1; } if (n <= 0 || n > MAX_MATRIX_SIZE) { fprintf(stderr, "Dimension of columns is not right. (%i not in {1, ..., %i})\n", n, MAX_MATRIX_SIZE); return -1; } coefs = allocate(n, sizeof(*coefs)); assert(coefs != NULL); break; } /* second line contains amount of rows (constraints) */ case 2: { m = strtol(tok, &test, 10); if ((int)strlen(test) != 0) { fprintf(stderr, "Wrong input data for number of constraints.\n"); return -1; } if (m <= 0 || m > MAX_MATRIX_SIZE) { fprintf(stderr, "Dimension of rows is not right. (%i not in {1, ..., %i})\n", m, MAX_MATRIX_SIZE); deallocate(coefs); return -1; } *matrix = matrix_new(m, n); break; } /* other lines contain rows (constraints) of matrix and right-hand sides */ default: { if (m == -1 || n == -1 || coefs == NULL) { fprintf(stderr, "Dimension not set or coefficient array not allocated.\n"); deallocate(coefs); return -1; } while(tok != NULL && strcmp(tok, "<=") != 0 && strcmp(tok, "=<") != 0 && strcmp(tok, ">=") != 0 && strcmp(tok, "=>") != 0 && strcmp(tok, "==") != 0 && strcmp(tok, "=") != 0) { if (j >= n) { fprintf(stderr, "Too many coefficients or no relation sign.\n"); deallocate(coefs); return -1; } coefs[j] = strtov(tok, &test); if ((int)strlen(test) != 0) { fprintf(stderr, "Wrong input data in line %i. Wrong type of coefficient (%s) of variable %i.\n", lines, tok, j+1); deallocate(coefs); return -1; } tok = strtok(NULL, delimiter); j++; } /* when j < n, then we have not enough coefficient entries in this line */ if (j < n ) { fprintf(stderr, "Not enough entries in line %i.\n", lines); deallocate(coefs); return -1; } /* when tok is NULL, then there is no relation operator given in this line */ if (tok == NULL) { fprintf(stderr, "No relation operator in line %i.\n", lines); deallocate(coefs); return -1; } /* copy relation operator */ assert(strlen(tok) <= 2); strncpy(relation, tok, sizeof(relation)); /* get next token, which is right-hand side */ tok = strtok(NULL, delimiter); /* when tok is NULL, then there is no right-hand side given in this line */ if (tok == NULL) { fprintf(stderr, "Wrong input data in line %i. (no right-hand side)\n", lines); deallocate(coefs); return -1; } /* convert right-hand side and check whether the format is correct */ rhs = strtov(tok, &test); if ((int)strlen(test) != 0) { fprintf(stderr, "Wrong input data in line %i. (wrong type of right-hand side)\n", lines); deallocate(coefs); return -1; } /* check for additional information after right-hand side */ tok = strtok(NULL, delimiter); if (tok != NULL) { fprintf(stderr, "Too many information after relation sign of line %i.\n", lines); deallocate(coefs); return -1; } /* add constraint(s) to the problem */ if (strcmp(relation, "<=") == 0 || strcmp(relation, "=<") == 0 || strcmp(relation, "=") == 0 || strcmp(relation, "==") == 0) { if (!matrix_put(*matrix, coefs, rhs)) { fprintf(stderr, "Problem is infeasible.\n"); deallocate(coefs); return -2; } } if (strcmp(relation, ">=") == 0 || strcmp(relation, "=>") == 0 || strcmp(relation, "=") == 0 || strcmp(relation, "==") == 0) { for (int k = 0; k < n; k++) coefs[k] *= -1; rhs *= -1; if (!matrix_put(*matrix, coefs, rhs)) { fprintf(stderr, "Problem is infeasible.\n"); deallocate(coefs); return -2; } } if (strcmp(relation, "=") == 0 || strcmp(relation, "==") == 0) m++; /* check whether we have too many rows */ if (matrix_getM(*matrix) + matrix_getRedundant(*matrix) > m) { fprintf(stderr, "Too many rows.\n"); deallocate(coefs); return -1; } } } } deallocate(coefs); if (matrix_getM(*matrix) + matrix_getRedundant(*matrix) < m) { fprintf(stderr, "Not enough rows.\n"); return -1; } fclose(fp); return lines; }
matrix_p koeffizienten_xi_1dim(int grad) { matrix_p back, matrix; int q, m, n; fepc_real_t **x; fepc_real_t *a, *b; fepc_real_t rat, reell, faktor, temp; ASSERT(grad >= 0); a = (fepc_real_t*) malloc(sizeof(fepc_real_t) * (2*grad + 1) ); ASSERT(a != NULL); b = (fepc_real_t*) malloc(sizeof(fepc_real_t) * (2*grad + 1) ); ASSERT(b != NULL); matrix = matrix_new( 2*grad+1, 2*grad+1 ); x = matrix->a; for (n=0;n<=2*grad;n++) { a[n] = sqrt(2*n+3)*sqrt(2*n+1)/(fepc_real_t)(n+1); } b[0] = 0.0; for (n=1;n<=2*grad;n++) { b[n] = (sqrt(2*n+3)/sqrt(2*n-1)) * ( (fepc_real_t)n/(fepc_real_t)(n+1) ); } x[0][0] = 1./sqrt(2); for (q=1;q<=2*grad;q++) { for (n=0;n<=q;n++) { m = q-n; if (n<m) { x[n][m] = 0.0; } else { temp = a[n-1]/2.0*(x[n-1][m+1]/a[m]+x[n-1][m]); if (m>0) { temp = temp + a[n-1]/2.0*b[m]/a[m]*x[n-1][m-1]; } if (n>=2) { temp = temp - b[n-1]*x[n-2][m]; } /*Korrektur der Werte (siehe Dokumentation)*/ faktor = pow(2,((fepc_real_t)n+0.5))/sqrt( (2*n+1)*(2*m+1) ); reell = temp; rat = reell*faktor; rat = get_rational(rat,1e-14,10000); reell = rat/faktor; x[n][m] = reell; } } } back = matrix_new(grad+1,grad+1); for (m=0;m<=grad;m++) { for (n=0;n<=grad;n++) { back->a[m][n] = matrix->a[m][n]; } } free(a); free(b); matrix_del(matrix); return back; }
/* * Kalman filter process */ static PyObject * kf_process(PyObject *self, PyObject *args, PyObject *kws) { MatrixObject *A, *B, *C, *D, *x0, *P0, *Q, *R, *x, *P; Float *x_est, *y_est, *P_est; PyObject *out, *tmp, *tmp1, *x_est_out, *y_est_out, *P_est_out, *result; PyObject *mupdate_callback = NULL, *arglist; int i, j, k, n, p, q, datalength; MatrixObject *y, *u; static char *kwlist[] = {"A", "B", "C", "D", "y", "u", "x0", "P0", "Q", "R", "mupdate_callback", NULL}; if (!PyArg_ParseTupleAndKeywords(args, kws, "O!O!O!O!O!O!O!O!O!O!|O:set_callback", kwlist, &MatrixType, &A, &MatrixType, &B, &MatrixType, &C, &MatrixType, &D, &MatrixType, &y, &MatrixType, &u, &MatrixType, &x0, &MatrixType, &P0, &MatrixType, &Q, &MatrixType, &R, &mupdate_callback)) return NULL; if (A->rows != A->cols) { PyErr_SetString(PyExc_ValueError, "A must be a square matrix"); return NULL; } n = A->rows; p = B->cols; q = C->rows; if (B->rows != n) { PyErr_SetString(PyExc_ValueError, "B must be Nxp matrix"); return NULL; } if (C->cols != n) { PyErr_SetString(PyExc_ValueError, "C must be qxN matrix"); return NULL; } if (D->rows != p || D->cols != q) { PyErr_SetString(PyExc_ValueError, "D must be pxq matrix"); return NULL; } datalength = y->cols; if (y->cols != u->cols) { PyErr_SetString(PyExc_ValueError, "y and u data lengths does not match"); return NULL; } if (y->rows != q) { PyErr_SetString(PyExc_ValueError, "y must be qxlength matrix"); return NULL; } if (u->rows != p) { PyErr_SetString(PyExc_ValueError, "u must be pxlength matrix"); return NULL; } if (x0->rows != n || x0->cols != 1) { PyErr_SetString(PyExc_ValueError, "x0 must be Nx1 matrix"); return NULL; } if (P0->rows != n || P0->cols != n) { PyErr_SetString(PyExc_ValueError, "P0 must be NxN matrix"); return NULL; } if (Q->rows != n || Q->cols != n) { PyErr_SetString(PyExc_ValueError, "Q must be NxN matrix"); return NULL; } if (R->rows != q || R->cols != q) { PyErr_SetString(PyExc_ValueError, "R must be qxq matrix"); return NULL; } if (!PyCallable_Check(mupdate_callback)) { if (mupdate_callback != NULL) { PyErr_SetString(PyExc_TypeError, "parameter must be callable"); return NULL; } } x_est = m_new(n, datalength); y_est = m_new(n, datalength); P_est = m_new(n, n*datalength); if (mupdate_callback != NULL) { Py_XINCREF(mupdate_callback); // Add a reference to new callback x = matrix_new(n, 1); P = matrix_new(n, n); // initialize x and P m_copy(x->data, x0->data, n, 1); m_copy(P->data, P0->data, n, n); for (i=0; i<datalength; i++) { tick(A->data, B->data, C->data, D->data, n, p, q, y->data+i*q, u->data+i*p, x->data, P->data, Q->data, R->data, x_est+i*n, y_est+i*q, P_est+i*n*n); // copy x and P values into output array m_copy(x->data, x_est+i*n, n, 1); m_copy(P->data, P_est+i*n*n, n, n); // update the matrixes arglist = Py_BuildValue("(i, O, O, O, O, O)", i, A, B, C, D, x); result = PyEval_CallObject(mupdate_callback, arglist); Py_DECREF(arglist); } Py_DECREF(x); Py_DECREF(P); } else { // model update not needed process(A->data, B->data, C->data, D->data, n, p, q, y->data, u->data, x0->data, P0->data, Q->data, R->data, datalength, x_est, y_est, P_est); } // create lists from matrixes x_est_out = PyList_New(datalength); for (i=0; i<datalength; i++) { tmp = PyList_New(n); for (j=0; j<n; j++) { PyList_SetItem(tmp, j, PyFloat_FromDouble( *(x_est+i*n+j) )); } PyList_SetItem(x_est_out, i, tmp); } y_est_out = PyList_New(datalength); for (i=0; i<datalength; i++) { tmp = PyFloat_FromDouble( *(y_est+i) ); PyList_SetItem(y_est_out, i, tmp); } P_est_out = PyList_New(datalength); for (i=0; i<datalength; i++) { tmp = PyList_New(n); for (j=0; j<n; j++) { tmp1 = PyList_New(n); for (k=0; k<n; k++) { PyList_SetItem(tmp1, k, PyFloat_FromDouble( *(x_est+i*n+j*n+k) )); } PyList_SetItem(tmp, j, tmp1); } tmp = PyFloat_FromDouble( *(P_est+i) ); PyList_SetItem(P_est_out, i, tmp); } m_free(x_est); m_free(y_est); m_free(P_est); out = PyTuple_New(3); PyTuple_SetItem(out, 0, x_est_out); PyTuple_SetItem(out, 1, y_est_out); PyTuple_SetItem(out, 2, P_est_out); Py_INCREF(out); // TODO add Py_INCREF every time when returning object from fnc return out; }
/* initialize variables */ int init_hist_np() { chamber_p chamb; int ipl; double d; int i, n; /* initialyze for Target Chamber MWDC */ chamb = &tgc_mwdc; chamb->name = "TGC"; chamb->type = CHAMB_MWDC; chamb->npl = 10; chamb->plane = (plane_p)malloc(sizeof(plane_t)*chamb->npl); chamb->plane[0].name = "VT1"; chamb->plane[1].name = "VT2"; chamb->plane[2].name = "VT3"; chamb->plane[3].name = "VT4"; chamb->plane[4].name = "X1"; chamb->plane[5].name = "X2"; chamb->plane[6].name = "U1"; chamb->plane[7].name = "U2"; chamb->plane[8].name = "V1"; chamb->plane[9].name = "V2"; for(ipl=0; ipl<chamb->npl; ipl++){ chamb->plane[ipl].chamb = chamb; } chamb_init_hist(chamb); n = 1<<chamb->npl; chamb->matrix = (void*)malloc(sizeof(mat_p)*n); for(i=0; i<n; i++) ((mat_p*)chamb->matrix)[i] = (mat_p)NULL; chamb->mb = matrix_new(4,1); chamb->mc = matrix_new(4,1); if(chamb->matrix==NULL||chamb->mb==NULL||chamb->mc==NULL){ showerr("init_hist_np: No enough memory available\n"); exit(1); } /* initialyze for Front-end Chamber MWDC */ chamb = &fec_mwdc; chamb->name = "FEC"; chamb->type = CHAMB_MWDC; chamb->npl = 6; chamb->plane = (plane_p)malloc(sizeof(plane_t)*chamb->npl); chamb->plane[0].name = "Y1"; chamb->plane[1].name = "Y2"; chamb->plane[2].name = "V1"; chamb->plane[3].name = "V2"; chamb->plane[4].name = "U1"; chamb->plane[5].name = "U2"; for(ipl=0; ipl<chamb->npl; ipl++){ chamb->plane[ipl].chamb = chamb; } chamb_init_hist(chamb); n = 1<<chamb->npl; chamb->matrix = (void*)malloc(sizeof(mat_p)*n); for(i=0; i<n; i++) ((mat_p*)chamb->matrix)[i] = (mat_p)NULL; chamb->mb = matrix_new(4,1); chamb->mc = matrix_new(4,1); if(chamb->matrix==NULL||chamb->mb==NULL||chamb->mc==NULL){ showerr("init_hist_np: No enough memory available\n"); exit(1); } }
void cox_test(double** covariates, size_t num_features_in_covariate, size_t num_samples, double* time, double* censor, double* coefficients, double** variance) { // declare variables, init values and allocate memory // gsl matrices matrix_t* coefficients_matrix_p = NULL; matrix_t* information_matrix_p = NULL; matrix_t* information_matrix_inverse_p = NULL; matrix_t* score_matrix_p = NULL; matrix_t* error_matrix_p = NULL; matrix_t* variance_matrix_p = NULL; // other variables double denominator = 0, numerator = 0; double error1 = 1, error2 = 1; double* risk_factor = (double*) calloc(num_samples, sizeof(double)); double* score = (double*) calloc(num_features_in_covariate, sizeof(double)); double** expected_covariate = (double**) calloc(num_features_in_covariate, sizeof(double*)); double** information = (double**) calloc(num_features_in_covariate, sizeof(double*)); for (size_t i = 0; i < num_features_in_covariate; i++) { coefficients[i] = 0.1; expected_covariate[i] = (double*) calloc(num_samples, sizeof(double)); information[i] = (double*) calloc(num_features_in_covariate, sizeof(double)); } // create gsl matrices coefficients_matrix_p = matrix_new(num_features_in_covariate, 1); matrix_init(0.1, coefficients_matrix_p); information_matrix_p = matrix_new(num_features_in_covariate, num_features_in_covariate); score_matrix_p = matrix_new(num_features_in_covariate, 1); error_matrix_p = matrix_new(num_features_in_covariate, 1); information_matrix_inverse_p = matrix_new(num_features_in_covariate, num_features_in_covariate); while((error1 > COX_ERROR_LIMIT) || (error2 > COX_ERROR_LIMIT)) { for (size_t i = 0; i < num_samples; ++i) { risk_factor[i] = 1.0; for (size_t s = 0; s < num_features_in_covariate; ++s) { risk_factor[i] *= exp(coefficients[s] * covariates[s][i]); } } for (size_t j = 0; j < num_features_in_covariate; j++) { score[j] = 0.0; for (size_t i = 0; i < num_samples; i++) { for (size_t k = 0; k < num_samples; k++) { if (time[k] >= time[i]) { denominator += risk_factor[k]; numerator += covariates[j][k] * risk_factor[k]; } } expected_covariate[j][i] = numerator / denominator; score[j] += censor[i] * (covariates[j][i] - expected_covariate[j][i]); numerator = 0.0; denominator = 0.0; } } for (size_t r = 0; r < num_features_in_covariate; r++) { for (size_t s = 0; s < num_features_in_covariate; s++) { information[r][s] = 0.0; for (size_t i = 0; i < num_samples; i++) { for (size_t k = 0; k < num_samples; k++) { if (time[k] >= time[i]) { denominator += risk_factor[k]; numerator += (covariates[r][k] * covariates[s][k] * risk_factor[k]); } } information[r][s] += censor[i] * (expected_covariate[r][i] * expected_covariate[s][i] - (numerator / denominator)); numerator = 0.0; denominator = 0.0; } } } // fill information_matrix matrix_fill(information, num_features_in_covariate, num_features_in_covariate, information_matrix_p); // fill the matrix with data // fill score_matrix from score array for (size_t i = 0; i < num_features_in_covariate; i++) { matrix_set(i, 0, score[i], score_matrix_p); } // calculate error matrix: inv(information_matrix) * score_matrix matrix_inv(information_matrix_p, information_matrix_inverse_p); matrix_mul(information_matrix_inverse_p, score_matrix_p, error_matrix_p); // calculate coefficients matrix coefficients_matrix_p = matrix_sub(coefficients_matrix_p, error_matrix_p); // fill coefficientes for (size_t i = 0; i < num_features_in_covariate; i++) { coefficients[i] = matrix_get(i, 0, coefficients_matrix_p); } error1 = sqrt(matrix_Fnorm(error_matrix_p)); error2 = sqrt(matrix_Fnorm(score_matrix_p)); } // end of while // calculate variance: (-1 * inv(information_matrix)) variance_matrix_p = matrix_scale(information_matrix_inverse_p, -1.0); for (size_t i = 0; i < num_features_in_covariate; i++) { for (size_t j = 0; j < num_features_in_covariate; j++) { variance[i][j] = matrix_get(i, j, variance_matrix_p); } } // free gsl matrices matrix_free(coefficients_matrix_p); matrix_free(information_matrix_p); matrix_free(information_matrix_inverse_p); matrix_free(score_matrix_p); matrix_free(error_matrix_p); variance_matrix_p = NULL; // points to information_matrix_inverse_p previously freed matrix_free(variance_matrix_p); // free other resources free(risk_factor); free(score); for (size_t i = 0; i < num_features_in_covariate; i++) { free(expected_covariate[i]); free(information[i]); } free(expected_covariate); free(information); return; }