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 ); }
static void lars_estimate_init( lars_type * lars, matrix_type * X , matrix_type * Y) { int nvar = matrix_get_columns( lars->X ); matrix_assign( X , lars->X ); matrix_assign( Y , lars->Y ); if (lars->X_norm != NULL) matrix_free( lars->X_norm ); lars->X_norm = matrix_alloc(1 , nvar ); if (lars->X_mean != NULL) matrix_free( lars->X_mean ); lars->X_mean = matrix_alloc(1 , nvar ); if (lars->beta != NULL) matrix_free( lars->beta ); lars->beta = matrix_alloc( nvar , nvar ); lars->Y_mean = regression_scale( X , Y , lars->X_mean , lars->X_norm); }
matrix_type * matrix_realloc_copy(matrix_type * T , const matrix_type * src) { if (T == NULL) return matrix_alloc_copy( src ); else { matrix_resize( T , src->rows , src->columns , false ); matrix_assign( T , src ); return T; } }
void test_column_equal() { matrix_type * m1 = matrix_alloc(5,5); matrix_type * m2 = matrix_alloc(5,5); matrix_type * m3 = matrix_alloc(6,5); rng_type * rng = rng_alloc( MZRAN , INIT_DEFAULT ); matrix_random_init( m1 , rng ); matrix_assign( m2 , m1 ); test_assert_true( matrix_columns_equal( m1 , 2 , m2 , 2 )); test_assert_false( matrix_columns_equal( m1 , 2 , m2 , 3 )); test_assert_false( matrix_columns_equal( m1 , 2 , m3 , 3 )); rng_free( rng ); matrix_free( m1 ); matrix_free( m2 ); matrix_free( m3 ); }
void test_resize() { matrix_type * m1 = matrix_alloc(5,5); matrix_type * m2 = matrix_alloc(5,5); rng_type * rng = rng_alloc( MZRAN , INIT_DEFAULT ); matrix_random_init( m1 , rng ); matrix_assign( m2 , m1 ); test_assert_true( matrix_equal( m1 , m2 )); matrix_resize( m1 , 5 , 5 , false ); test_assert_true( matrix_equal( m1 , m2 )); matrix_resize( m1 , 5 , 5 , true ); test_assert_true( matrix_equal( m1 , m2 )); rng_free( rng ); matrix_free( m1 ); matrix_free( m2 ); }
static bool matrix_resize__(matrix_type * matrix , int rows , int columns , bool copy_content , bool safe_mode) { if (!matrix->data_owner) util_abort("%s: sorry - can not resize shared matrizes. \n",__func__); { bool resize_OK = true; if ((rows != matrix->rows) || (columns != matrix->columns)) { int copy_rows = util_int_min( rows , matrix->rows ); int copy_columns = util_int_min( columns , matrix->columns); matrix_type * copy_view = NULL; matrix_type * copy = NULL; if (copy_content) { copy_view = matrix_alloc_shared( matrix , 0 , 0 , copy_rows , copy_columns); /* This is the part of the old matrix which should be copied over to the new. */ copy = matrix_alloc_copy__( copy_view , safe_mode ); /* Now copy contains the part of the old matrix which should be copied over - with private storage. */ } { int old_rows , old_columns, old_row_stride , old_column_stride; matrix_get_dims( matrix , &old_rows , &old_columns , &old_row_stride , &old_column_stride); /* Storing the old header information - in case the realloc() fails. */ matrix_init_header(matrix , rows , columns , 1 , rows); /* Resetting the header for the matrix */ matrix_realloc_data__(matrix , safe_mode); if (matrix->data != NULL) { /* Realloc succeeded */ if (copy_content) { matrix_type * target_view = matrix_alloc_shared(matrix , 0 , 0 , copy_rows , copy_columns); matrix_assign( target_view , copy); matrix_free( target_view ); } } else { /* Failed to realloc new storage; RETURNING AN INVALID MATRIX */ matrix_init_header(matrix , old_rows , old_columns , old_row_stride , old_column_stride); resize_OK = false; } } if (copy_content) { matrix_free(copy_view); matrix_free(copy); } } return resize_OK; } }
void test_readwrite() { test_work_area_type * test_area = test_work_area_alloc("matrix-test"); { rng_type * rng = rng_alloc(MZRAN , INIT_DEV_URANDOM ); matrix_type * m1 = matrix_alloc(3 , 3); matrix_type * m2 = matrix_alloc(3 , 3); matrix_random_init( m1 , rng ); matrix_assign(m2 , m1); test_assert_true( matrix_equal( m1 , m2 ) ); { FILE * stream = util_fopen("m1" , "w"); matrix_fwrite( m1 , stream ); fclose( stream ); } matrix_random_init( m1 , rng ); test_assert_false( matrix_equal( m1 , m2 ) ); { FILE * stream = util_fopen("m1" , "r"); matrix_free( m1 ); m1 = matrix_alloc(1,1); printf("-----------------------------------------------------------------\n"); matrix_fread( m1 , stream ); test_assert_int_equal( matrix_get_rows(m1) , matrix_get_rows( m2)); test_assert_int_equal( matrix_get_columns(m1) , matrix_get_columns( m2)); util_fseek( stream , 0 , SEEK_SET); { matrix_type * m3 = matrix_fread_alloc( stream ); test_assert_true( matrix_equal( m2 , m3 )); matrix_free( m3 ); } fclose( stream ); } test_assert_true( matrix_equal( m1 , m2 ) ); matrix_free( m2 ); matrix_free( m1 ); rng_free( rng ); } test_work_area_free( test_area ); }
int main( int argc, char ** argv) { rng_type * rng = rng_alloc( MZRAN , INIT_DEV_RANDOM ); matrix_type * A = matrix_alloc( 12 , 12 ); matrix_type * B = matrix_alloc( 12 , 12 ); matrix_random_init( A , rng ); matrix_assign( B , A ); matrix_pretty_print( A , " A " , "%8.4f" ); #ifdef WITH_LAPACK matrix_inv( B ); printf("\n"); matrix_pretty_print( B , "inv(A)" , "%8.4f" ); matrix_inplace_matmul( B , A ); printf("\n"); matrix_pretty_print( B , " I " , "%8.4f" ); { matrix_type * A3 = matrix_alloc(3,3); matrix_random_init( A3 , rng ); matrix_iset( A3 , 0 , 0 , sin(0.98)); printf("matrix_det3:%g ",matrix_det3( A3 )); printf("matrix_det:%g \n",matrix_det( A3 )); } { matrix_type * A4 = matrix_alloc(4,4); matrix_random_init( A4 , rng ); matrix_iset( A4 , 0 , 0 , sin(0.98)); printf("matrix_det4:%g ",matrix_det4( A4 )); printf("matrix_det:%g \n",matrix_det( A4 )); } #endif matrix_free( A ); matrix_free( B ); rng_free( rng ); }
/** Will not respect strides - that is considered low level data layout. */ static matrix_type * matrix_alloc_copy__( const matrix_type * src , bool safe_mode) { matrix_type * copy = matrix_alloc__( matrix_get_rows( src ), matrix_get_columns( src ) , safe_mode); if (copy != NULL) matrix_assign(copy , src); return copy; }