extern void page_rank(size_t size) { matrix w; matrix_init(&w, size); gen_web_matrix(&w); matrix g; matrix_init(&g, size); gen_google_matrix(&g, &w); matrix_free(&w); vector p; vector_init(&p, size); matrix_transpose(&g); matrix_solve(&p, &g); vector_sort(&p); vector_save(&p); matrix_free(&g); vector_free(&p); }
void test_content() { rng_type * rng = rng_alloc(MZRAN , INIT_DEFAULT); matrix_type * PC = matrix_alloc( 3 , 10); matrix_type * PC_obs = matrix_alloc( 3 , 1 ); double_vector_type * singular_values = double_vector_alloc(3 , 1); matrix_random_init( PC , rng ); matrix_random_init( PC_obs , rng ); { pca_plot_data_type * data = pca_plot_data_alloc("KEY" , PC , PC_obs, singular_values); for (int i=0; i < matrix_get_rows( PC ); i++) { const pca_plot_vector_type * vector = pca_plot_data_iget_vector( data , i ); test_assert_double_equal( matrix_iget( PC_obs , i , 0) , pca_plot_vector_get_obs_value( vector ) ); test_assert_double_equal( double_vector_iget( singular_values , i), pca_plot_vector_get_singular_value( vector ) ); for (int j=0; j < matrix_get_columns( PC ); j++) test_assert_double_equal( matrix_iget( PC , i , j ) , pca_plot_vector_iget_sim_value( vector , j )); test_assert_int_equal( matrix_get_columns( PC ) , pca_plot_vector_get_size( vector )); } pca_plot_data_free( data ); } double_vector_free( singular_values ); matrix_free( PC ); matrix_free( PC_obs ); }
void construct_C2_i(polymatrix_t *game, strategy_profile_t *x, int *scount, int i, int sKx, int k, double *b, matrix_t *C2) { int j; C2->data[k][0] = -1; C2->data[k][k + 1] = 1; matrix_t *vi = polymatrix_compute_vi(game, x, i); matrix_t *xt = matrix_trans(x->strategies[i]); matrix_t *u = matrix_mul_vec_mat(xt, vi); *b = -u->data[0][0]; matrix_free(u); int c_off = sKx + 1; for (j = 0; j < game->players; ++j) { matrix_t *Ax; //printf("+++x++\n"); //matrix_print(matrix_trans(x->strategies[j])); if (i == j) { Ax = matrix_trans(vi); matrix_mul_const_in(Ax, -1); } else if (game->payoffs[i][j]) { Ax = matrix_mul_vec_mat(xt, game->payoffs[i][j]); matrix_mul_const_in(Ax, -1); } else { Ax = matrix_alloc(1, scount[j]); } matrix_copy_to_offset(C2, Ax, i, c_off); c_off += Ax->ncols; matrix_free(Ax); } matrix_free(vi); matrix_free(xt); }
void bayesian_set_game(bayesian_t *game, int i, int j, matrix_t **bimat) { game->payoffs[i][j] = matrix_copy(bimat[0]); game->payoffs[j+game->m][i] = matrix_trans(bimat[1]); matrix_free(bimat[0]); matrix_free(bimat[1]); free(bimat); }
void matrix_copy_block( matrix_type * target_matrix , int target_row , int target_column , int rows , int columns, const matrix_type * src_matrix , int src_row , int src_column) { matrix_type * target_view = matrix_alloc_shared(target_matrix , target_row , target_column , rows , columns); matrix_type * src_view = matrix_alloc_shared( src_matrix , src_row , src_column , rows , columns); matrix_assign( target_view , src_view ); matrix_free( target_view ); matrix_free( src_view ); }
//memory freeing function void ising_free (struct ising model) { if (model.cluster != NULL) { matrix_free (model.cluster); } matrix_free (model.s); gsl_rng_free (model.r); }
clsLinearModelEM::~clsLinearModelEM(void) { if (mobj_X != NULL) { matrix_free(mobj_X) ; matrix_free(mobj_Y) ; matrix_free(mobj_Weights) ; matrix_free(mobj_XTranspose) ; } }
bip_context* bip_context_new(int num_vars, int num_rest) { /* Check input is correct */ if((num_vars < 1) || (num_rest < 0)) { return NULL; } /* Allocate structure */ bip_context* c = (bip_context*) malloc(sizeof(bip_context)); if(c == NULL) { return NULL; } /* Try to allocate dynamic memory */ c->restrictions = NULL; if(num_rest > 0) { c->restrictions = matrix_new(num_rest, num_vars + 2, 0); if(c->restrictions == NULL) { free(c); return NULL; } } c->function = (int*) malloc(num_vars * sizeof(int)); if(c->function == NULL) { matrix_free(c->restrictions); free(c); return NULL; } /* Initialize values */ for(int i = 0; i < num_vars; i++) { c->function[i] = 0; } /* Save variables */ c->num_vars = num_vars; c->num_rest = num_rest; c->maximize = true; /* Common */ c->status = -1; c->execution_time = 0.0; c->memory_required = matrix_sizeof(c->restrictions) + (num_vars * sizeof(int)) + sizeof(bip_context); c->report_buffer = tmpfile(); if(c->report_buffer == NULL) { matrix_free(c->restrictions); free(c->function); free(c); return NULL; } return c; }
void poly_set_bottom(pk_internal_t* pk, pk_t* po) { if (po->C) matrix_free(po->C); if (po->F) matrix_free(po->F); if (po->satC) satmat_free(po->satC); if (po->satF) satmat_free(po->satF); po->C = po->F = NULL; po->satC = po->satF = NULL; po->status = pk_status_conseps | pk_status_minimaleps; po->nbeq = po->nbline = 0; }
pca_plot_data_type * create_data() { matrix_type * PC = matrix_alloc( 3 , 10); matrix_type * PC_obs = matrix_alloc( 3 , 1 ); double_vector_type * singular_values = double_vector_alloc(3 , 1); pca_plot_data_type * data = pca_plot_data_alloc("KEY" , PC , PC_obs , singular_values); double_vector_free( singular_values ); matrix_free( PC ); matrix_free( PC_obs ); return data; }
//matrix_sub static void matrix_sub_TwoMatrixesWithElementsSixTenTwoElevenAndOneTwoThreeFour_MatrixWithElementsFiveEightMinusOneSeven(void ** state) { matrix_t * mat1 = matrix_test(6,10,2,11); matrix_t * mat2 = matrix_test(1,2,3,4); assert_int_equal(matrix_getElementOfMatrix(matrix_sub(mat1,mat2),0,0),5); assert_int_equal(matrix_getElementOfMatrix(matrix_sub(mat1,mat2),0,1),8); assert_int_equal(matrix_getElementOfMatrix(matrix_sub(mat1,mat2),1,0),-1); assert_int_equal(matrix_getElementOfMatrix(matrix_sub(mat1,mat2),1,1),7); matrix_free(mat1); matrix_free(mat2); }
//matrix_add static void matrix_add_TwoMatrixesWithElementsOneTwoThreeFour_MatrixWithElementsTwoFourSixEight(void ** state) { matrix_t * mat1 =matrix_test(1,2,3,4); matrix_t * mat2 =matrix_test(1,2,3,4); assert_int_equal(matrix_getElementOfMatrix(matrix_add(mat1,mat2),0,0),2); assert_int_equal(matrix_getElementOfMatrix(matrix_add(mat1,mat2),0,1),4); assert_int_equal(matrix_getElementOfMatrix(matrix_add(mat1,mat2),1,0),6); assert_int_equal(matrix_getElementOfMatrix(matrix_add(mat1,mat2),1,1),8); matrix_free(mat1); matrix_free(mat2); }
void matrix_test(void) { Matrix* pMatrix = matrix_identity(3); matrix_print(pMatrix); printf("Inicio: \n"); for (int y = 0; y < 3; y++) { for (int x = 0; x < 3; x++) { printf("pMatrix(%d,%d) = %f\n", x, y, matrix_get_elem(pMatrix, x, y)); } } printf("\nModificado: \n"); int i = 0; for (int y = 0; y < 3; y++) { for (int x = 0; x < 3; x++) { matrix_set_elem(pMatrix, x, y, i++); } } for (int y = 0; y < 3; y++) { for (int x = 0; x < 3; x++) { printf("pMatrix(%d,%d) = %f\n", x, y, matrix_get_elem(pMatrix, x, y)); } } matrix_free(pMatrix); printf("\nMultiplicacion: \n"); Matrix* pA = matrix_new(2, 3); Matrix* pB = matrix_new(3, 2); Matrix* pC = matrix_new(2, 2); matrix_set_elem(pA, 0, 0, 2.0f); matrix_set_elem(pA, 0, 1, 2.0f); matrix_set_elem(pA, 1, 1, 2.0f); matrix_set_elem(pA, 1, 0, 2.0f); matrix_set_elem(pB, 0, 0, 1.0f); matrix_set_elem(pB, 0, 1, 2.0f); matrix_set_elem(pB, 1, 1, 3.0f); matrix_set_elem(pB, 1, 0, 4.0f); matrix_print(pA); matrix_print(pB); matrix_mult(pA, pB, pC); matrix_print(pC); matrix_free(pA); matrix_free(pB); matrix_free(pC); }
//multiplication of two matrixes static void matrix_mult_TwoMatrixesWithElementsOneTwoThreeFour_TwoMatrixesWithElementsSevenTenFifteenTwentytwo(void ** state) { matrix_t * mat1 = matrix_test(1,2,3,4); matrix_t * mat2 = matrix_test(1,2,3,4); assert_int_equal(matrix_getElementOfMatrix(matrix_mult(mat1,mat2),0,0),7); assert_int_equal(matrix_getElementOfMatrix(matrix_mult(mat1,mat2),0,1),10); assert_int_equal(matrix_getElementOfMatrix(matrix_mult(mat1,mat2),1,0),15); assert_int_equal(matrix_getElementOfMatrix(matrix_mult(mat1,mat2),1,1),22); matrix_free(mat1); matrix_free(mat2); }
void test_matrix() { struct Matrix* m = matrix_generate(5,5); printf("Matrix null: %d\n", matrix_is_null(m)); matrix_make_identity(m); struct Matrix* m2 = matrix_copy(m); matrix_set(m2,1,2,1); struct Matrix* m3 = matrix_mul(m2,m); matrix_show(m3); matrix_free(m); matrix_free(m2); matrix_free(m3); }
void test_create_vector() { matrix_type * PC = matrix_alloc( 3 , 10); matrix_type * PC_obs = matrix_alloc( 3 , 1 ); double_vector_type * singular_values = double_vector_alloc(3 , 1); { pca_plot_vector_type * vector = pca_plot_vector_alloc(0 , PC , PC_obs, singular_values); test_assert_true( pca_plot_vector_is_instance( vector )); pca_plot_vector_free( vector ); } double_vector_free( singular_values ); matrix_free( PC ); matrix_free( PC_obs ); }
static void test_forward_for_output() { NetworkState *network_state = network_state_basic(); Matrix sample = data_sample_basic(); Matrix output; int32_t result; output = forward_for_output(network_state, sample); result = presentation_closure_call(network_state->presentation, output); assert(result == 1); /* LCOV_EXCL_BR_LINE */ matrix_free(&output); matrix_free(&sample); network_state_free(&network_state); }
void correction_free(Correction **correction_address) { Correction *correction = *correction_address; for (int32_t layer = 0; layer < correction->layers; layer += 1) { matrix_free(&correction->biases[layer]); matrix_free(&correction->weights[layer]); } free(correction->biases); free(correction->weights); free(correction); *correction_address = NULL; }
int main(int argc, char** argv) { if (argc != 3) { fprintf(stderr, "Usage: %s <size> <n>\n", argv[0]); return 1; } int size = atoi(argv[1]); int n = atoi(argv[2]); printf("%d\n", n); matrix* m = matrix_new(size, size); int num_cells = size * size; int print_interval = num_cells / n; int i; timer* t = timer_new(); for (i = 0; i < num_cells; i++) { int next = i; int row = next / size; int col = next % size; matrix_set(m, row, col, (double) i); if (i % print_interval == 0) { timer_start(t); m = matrix_mmul(m, m); printf("%2f %lu\n", ((i + 0.0) / num_cells) * 100, timer_nsec(t)); } } matrix_free(m); return 0; }
void stepwise_set_Y0( stepwise_type * stepwise , matrix_type * Y) { if (stepwise->Y0 != NULL) { matrix_free( stepwise->Y0 ); } stepwise->Y0 = Y; }
// calculate gradients for the pyramid // lum_temp gets overwritten! static void pyramid_calculate_gradient(pyramid_t* pyramid, float* lum_temp) { float* temp = matrix_alloc((pyramid->rows/2)*(pyramid->cols/2)); float* const temp_saved = temp; calculate_gradient(pyramid->cols, pyramid->rows, lum_temp, pyramid->Gx, pyramid->Gy); pyramid = pyramid->next; // int l = 1; while(pyramid) { matrix_downsample(pyramid->prev->cols, pyramid->prev->rows, lum_temp, temp); // fprintf( stderr, "%d x %d -> %d x %d\n", pyramid->cols, pyramid->rows, // prev_pp->cols, prev_pp->rows ); // char name[40]; // sprintf( name, "ds_%d.pfs", l++ ); // dump_matrix_to_file( pyramid->cols, pyramid->rows, temp, name ); calculate_gradient(pyramid->cols, pyramid->rows, temp, pyramid->Gx, pyramid->Gy); float* const dummy = lum_temp; lum_temp = temp; temp = dummy; pyramid = pyramid->next; } matrix_free(temp_saved); }
void stepwise_set_X0( stepwise_type * stepwise , matrix_type * X) { if (stepwise->X0 != NULL) matrix_free( stepwise->X0 ); stepwise->X0 = X; }
static void check_new_test_matrix_print_and_free____sent_n_m_matrix_array____returned(void **state){ const int test_arr[3][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}; matrix_t * mt =matrix_new_test(3, 3,test_arr); //assert_int_equal(matrix_print(mt),1); assert_int_equal(matrix_print(mt),1); assert_int_equal(matrix_free(mt),1); }
void eta_file_free(eta_file* ef) { int i; free(ef->P); for (i = 0; i < ef->lp_rows; i ++) { eta_matrix_free(ef->L[i]); } free(ef->L); for (i = 0; i < ef->lp_rows*ETA_MAX; i ++) { eta_singleton_free(ef->Ls[i]); } free(ef->Ls); for (i = 0; i < ef->lp_rows; i ++) { eta_matrix_d_free(ef->L_d[i]); } free(ef->L_d); for (i = 0; i < ef->lp_rows*ETA_MAX; i ++) { eta_singleton_d_free(ef->Ls_d[i]); } free(ef->Ls_d); matrix_free(ef->U); for (i = 0; i < ef->lp_rows; i ++) vector_d_free(&ef->U_d[i]); free(ef->U_d); permutation_matrix_free(ef->Q); permutation_matrix_free(ef->R); free(ef); }
void stepwise_set_E0( stepwise_type * stepwise , matrix_type * E) { if (stepwise->E0 != NULL) matrix_free( stepwise->E0 ); stepwise->E0 = E; }
void sqrt_enkf_complete_update( void * arg ) { sqrt_enkf_data_type * sqrt_data = sqrt_enkf_data_safe_cast( arg ); { matrix_free( sqrt_data->randrot ); sqrt_data->randrot = NULL; } }
void sqrt_enkf_initX(void * module_data , matrix_type * X , matrix_type * A , matrix_type * S , matrix_type * R , matrix_type * dObs , matrix_type * E , matrix_type *D ) { sqrt_enkf_data_type * data = sqrt_enkf_data_safe_cast( module_data ); { int ncomp = std_enkf_get_subspace_dimension( data->std_data ); double truncation = std_enkf_get_truncation( data->std_data ); int nrobs = matrix_get_rows( S ); int ens_size = matrix_get_columns( S ); int nrmin = util_int_min( ens_size , nrobs); matrix_type * W = matrix_alloc(nrobs , nrmin); double * eig = util_calloc( nrmin , sizeof * eig ); matrix_subtract_row_mean( S ); /* Shift away the mean */ enkf_linalg_lowrankCinv( S , R , W , eig , truncation , ncomp); enkf_linalg_init_sqrtX( X , S , data->randrot , dObs , W , eig , false); matrix_free( W ); free( eig ); enkf_linalg_checkX( X , false ); } }
static void poly_approximate_1x(ap_manager_t* man, pk_t* po, bool outerfallback, bool combine) { bool change; pk_internal_t* pk = (pk_internal_t*)man->internal; poly_chernikova(man,po,"of the argument"); if (pk->exn){ pk->exn = AP_EXC_NONE; return; } if (!po->C && !po->F){ return; } assert(po->C && po->F); change = matrix_approximate_constraint_1x(pk, po->C, po->F, outerfallback,combine); if (change){ if (po->F) matrix_free(po->F); if (po->satC) satmat_free(po->satC); if (po->satF) satmat_free(po->satF); po->F = NULL; po->satC = NULL; po->satF = NULL; man->result.flag_exact = false; } else { man->result.flag_exact = true; } }
static bool poly_approximate_1(ap_manager_t* man, pk_t* po, pk_t* pa) { bool change; pk_internal_t* pk = (pk_internal_t*)man->internal; poly_obtain_C(man,pa,NULL); if (!pa->C){ poly_set(po,pa); return false; } if (po!=pa){ po->C = matrix_copy(pa->C); } change = matrix_approximate_constraint_1(pk,po->C); if (change){ if (po==pa){ if (po->F){ matrix_free(po->F); po->F = NULL; } if (po->satC){ satmat_free(po->satC); po->satC = NULL; } if (po->satF){ satmat_free(po->satF); po->satF = NULL; } } po->status = 0; man->result.flag_exact = false; } else { poly_set_save_C(po,pa); man->result.flag_exact = true; } return change; }
Matrix* matrix_qr_decomposition(Matrix M) { assert(is_matrix(M)); int m = M->r; int n = M->c; Matrix Q = matrix_new_empty(m, n); for(int i = 0; i < n; i++) { double* u = matrix_column_vector(M, i); double* a = matrix_column_vector(M, i); for(int k = 0; k < i; k++) { double* e = matrix_column_vector(Q, k); double* p = vector_projection(e, a, m); free(e); for(int j = 0; j < m; j++) u[j] -= p[j]; free(p); } free(a); double* e = vector_normalize(u, m); free(u); for(int l = 0; l < m; l++) Q->A[l][i] = e[l]; free(e); } Matrix Qt = matrix_transpose(Q); Matrix R = matrix_multiply(Qt, M); matrix_free(Qt); Matrix* QR = calloc(2, sizeof(Matrix)); QR[0] = Q; QR[1] = R; return QR; }