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