int main()
{
// Declare
int size = 3;
int **matrix = matrix_create(size, size);
// Modify
matrix[0][0] = 3;
matrix[0][2] = -2;
matrix[1][2] = 4;
matrix[2][1] = 1;
int row;
for (row = 0; row < size; row++)
{
int col;
for (col = 0; col < size; col++)
{
printf("%d ", matrix[row][col]);
}
printf("\n");
}
int i;
for (i = 0; i < size; i++)
{
free(matrix[i]);
}
// Free
free(matrix);
return (EXIT_SUCCESS);
}
/*! @brief Add two matrix between them
@param A First matrix
@param B Second matrix
@return Added matrix
*/
struct Matrix *matrix_addition (struct Matrix *A, struct Matrix *B)
{
struct Matrix *m_added = NULL;
size_t i = 0, j = 0;
// Check pointers
if (!A)
{
printf("matrix_addition: Matrix A is null\n");
return NULL;
}
if (!B)
{
printf("matrix_addition: Matrix B is null\n");
return NULL;
}
// A and B must be of the same size
if ( (A->nc != B->nc) && (A->nr != B->nr) )
{
printf("matrix_addition: Matrix A and B are not of the same size\n");
return NULL;
}
// Allocate a matrix object
m_added = matrix_create(A->nr, A->nc);
// Compute matrix addition
for (i = 0; i < A->nr; i++)
for (j = 0; j < A->nc; j++)
m_added->data[i][j] = A->data[i][j] + B->data[i][j];
return m_added;
}
void test11() {
int dim = 5;
Matrix m1 = matrix_create( dim, dim );
Matrix m2;
int i,j;
for ( i=0; i<dim; ++i ) { for ( j=0; j<dim; ++j ) { m1[i][j] = 3*i-j; } }
printf( "m1 =\n" );
matrix_print( m1, dim, dim );
while ( dim > 1 ) {
printf( "delete row %d =\n", dim-1 );
matrix_delete_row( m1, dim-1, dim );
matrix_print( m1, dim-1, dim );
printf( "transpose =\n" );
m2 = matrix_transpose( m1, dim-1, dim );
matrix_print( m2, dim, dim-1 );
matrix_delete( m1, dim-1 );
printf( "delete row %d =\n", dim-1 );
matrix_delete_row( m2, dim-1, dim );
matrix_print( m2, dim-1, dim-1 );
printf( "transpose =\n" );
m1 = matrix_transpose( m2, dim-1, dim-1 );
matrix_print( m1, dim-1, dim-1 );
matrix_delete( m2, dim-1 );
--dim;
}
matrix_delete( m1, dim );
}
int matrix_resize(void* matrix, size_t width, size_t height, size_t new_width, size_t new_height, size_t size, const void* zero, void (*destruct)(void*))
{
void* new_matrix;
int i;
if (matrix == NULL)
goto exception_matrix_null;
new_matrix = matrix_create(new_width, new_height, size, NULL);
if (new_matrix == NULL)
goto exception_new_matrix_bad_alloc;
for (i = 0; (i < new_width && zero != NULL) || i < width; i++)
{
if (i < new_width && i < width)
array_get_into((*(void***)matrix)[i], height, ((void**)new_matrix)[i], new_height, size, zero, destruct);
else if (i < new_width)
array_fill(((void**)new_matrix)[i], new_height, size, zero);
else if (i < width)
array_destroy((*(void***)matrix)[i], height, size, destruct);
}
*(void**)matrix = new_matrix;
return 1;
exception_new_matrix_bad_alloc:
exception_matrix_null:
return 0;
}
matrix matrix_create_identity(int r, int c){
double data[r*c];
for (int i = 0; i < r; ++i){
data[i*c + i] = 1.0;
}
return matrix_create(r, c, data);
}
static char * test_create_initial_board_from_file_with_empty_lines() {
Matrix* board;
Matrix* expected_matrix;
char* filename;
filename = "test_island/test_island_empty_lines.txt";
expected_matrix = matrix_create(2, 2);
/*
1 2
3 4
*/
matrix_set(expected_matrix, 0, 0, 1);
matrix_set(expected_matrix, 0, 1, 2);
matrix_set(expected_matrix, 1, 0, 3);
matrix_set(expected_matrix, 1, 1, 4);
board = create_initial_board_from_file(filename);
/*
print_board("board: ", board);
print_board("expected: ", expected_matrix);
*/
mu_assert("error, expected_matrix != board_from_file", matrix_equal(board, expected_matrix));
return 0;
}
/*! @brief Comatrix function
* @param matrix Matrix to search co-matrix for
* @param row Row index to cross out
* @return comatrix
*/
struct Matrix *matrix_com (struct Matrix *matrix, size_t row)
{
size_t i, j;
struct Matrix *comatrix;
// Check pointers
if (!matrix)
{
printf("matrix_com: matrix is null\n");
return NULL;
}
if (row >= matrix->nr)
{
printf("matrix_com: row deprecated is higher than max rows\n");
return NULL;
}
comatrix = matrix_create (matrix->nr, matrix->nc);
for (i = row; i < matrix->nr; i++)
{
for (j = 0; j < matrix->nc; j++)
{
}
}
return comatrix;
}
int main(int argc, char **argv)
{
FILE *swp;
struct cache *c;
struct matrix *m;
FILE *matrix_shared;
readargs(argc, argv);
if ((swp = fopen(swapfile, "w+")) == NULL)
error("cannot open swap file");
c = cache_create(&access_info, swp, CACHE_SIZE);
/* Read traces. */
for (int i = 0; i < ntraces; i++)
{
FILE *trace;
if ((trace = fopen(tracefiles[i], "r")) == NULL)
error("cannot open trace file");
trace_read(c, trace, i);
fclose(trace);
fprintf(stderr, "\nFechado arquivo de trace da thread %d\n\n", i);
}
/* Flushe traces on swap file. */
cache_flush(c);
/* Create communication matrix. */
fseek(swp, 0, SEEK_SET);
m = matrix_create(QTD_THREADS, QTD_THREADS);
fprintf(stderr, "\nMatriz criada\n");
matrix_generate(swp, m);
if ((matrix_shared = fopen(outfile, "w")) == NULL)
error("cannot open output file");
fprintf(stderr, "\nGravar matriz no arquivo\n");
for (int i = 0; i < ntraces; i++)
{
for(int j = 0; j < ntraces; j++)
fprintf(matrix_shared, "%d;%d;%d\n", i, j, (int) matrix_get(m, i, j));
}
/* House keeping. */
fclose(matrix_shared);
fclose(swp);
fprintf(stderr, "\n\n FIM!\n");
return (EXIT_SUCCESS);
}
void test9() {
Matrix m1 = matrix_create( 3, 3 );
int i,j;
for ( i=0; i<3; ++i ) { for ( j=0; j<3; ++j ) { m1[i][j] = 3*i-j; } }
printf( "m1 =\n" );
matrix_print( m1, 3, 3 );
printf( "delete column 2 =\n" );
matrix_delete_column( m1, 2, 3, 3 );
matrix_print( m1, 3, 2 );
printf( "delete row 1 =\n" );
matrix_delete_row( m1, 1, 3 );
matrix_print( m1, 2, 2 );
printf( "delete column 1 =\n" );
matrix_delete_column( m1, 1, 2, 2 );
matrix_print( m1, 2, 1 );
printf( "delete row 0 =\n" );
matrix_delete_row( m1, 0, 2 );
matrix_print( m1, 1, 1 );
matrix_delete( m1, 1 );
}
int main(int argc, char** argv)
{
cc_config_t config;
dataset_t* data;
clique_list_t* cl;
matrix_t* matrix;
group_list_t* groups;
#ifdef WITH_LIMITS
struct rlimit cpu_limit = { 900, 900 };
struct rlimit mem_limit = { 419430400, 419430400};
setrlimit(RLIMIT_CPU, &cpu_limit );
setrlimit(RLIMIT_AS, &mem_limit );
#endif
configure(&config, argc, argv);
data = dataset_load(config.datfile);
cl = clique_list_load(config.clfile);
printf("Generate matrix...\n");
matrix = matrix_create(data, cl, sizeof(int), NULL, boolean_connection);
/* matrix_print_int(matrix); */
printf("Generate group list...\n");
groups = group_list_from_clique_list(cl);
/* group_list_print(groups); */
printf("Merging groups...\n");
group_list_merge(groups, boolean_strength, NULL, matrix);
group_list_save(groups, config.grpfile);
group_list_destroy(groups);
matrix_destroy(matrix);
clique_list_destroy(cl);
dataset_destroy(&data);
return 0;
}
int main(int argc, char **argv)
{
int n = (argc > 1) ? atoi(argv[1]) : 100;
const char* matr_fname = (argc > 2) ? argv[2] : "l2_default.csr";
const char* pict_fname = (argc > 3) ? argv[3] : NULL;
real h = 1. / n;
int size = (n - 1) * (n - 1);
int nonz = 4 * size;
int err;
TMatrix_DCSR _m;
TMatrix_DCSR *m = &_m;
err = matrix_create(m, size, nonz, 1);
if (err) PRINT_ERROR_MESSAGE_AND_EXIT(err);
for (int i = 1; i <= size; ++i)
m->row_ptr[i] = 4 * i;
for (int i = 1; i <= n; ++i)
{
for (int j = 1; j <= n; ++j)
{
int todo[4] = {
ij2k(n, i - 1, j - 1), // bl
ij2k(n, i - 1, j - 0), // br
ij2k(n, i - 0, j - 1), // tl
ij2k(n, i - 0, j - 0), // tr
};
for (int ci = 0; ci < 4; ++ci) {
int k = todo[ci];
if (k < 0) continue;
real coeff = get_coeff(j*h - h/2, i*h - h/2);
m->diag[k] += 1 * coeff;
for (int cj = 0; cj < 4; ++cj) {
int off = loc_off(ci, cj);
if (off < 0) continue;
m->col_ind[m->row_ptr[k] + off] = todo[cj];
m->val [m->row_ptr[k] + off] -= 0.5 * coeff;
}
}
}
}
TMatrix_DCSR _l2;
TMatrix_DCSR *l2 = &_l2;
matrix_copy_fix(m, l2);
matrix_destroy(m);
if (pict_fname) matrix_portrait(l2, pict_fname, 5., 0, NULL);
if (strstr(matr_fname, ".mtx") != NULL) matrix_save_fmc(l2, matr_fname);
else matrix_save(l2, matr_fname);
return 0;
}
double lik(POPROT *pop)
{/* Function to compute the inverse of the Fisher information matrix of the
population protocol pop. Returns the determinant of the matrix, also stored in
pop->det. The Fisher information matrix of the population protocol is stored
in pop->fisher and the inverse is stored in pop->finv
*/
int ndim = pop->ndim;
int ncase = (int)(ndim*(ndim+1)/2);
int i,j,jj,ifail;
int *indx;
double *col;
matrix *xa;
double cri;
/* POPROT_print(pop,1);
PROTOC_print(&prot[7]);
*/
indx = (int *)calloc(ndim,sizeof(int));
col = (double *)calloc(ndim,sizeof(double));
xa = matrix_create(ndim,ndim);
for(i = 0;i<ncase;i++)
{
pop->fisher[i] = 0;
for(j = 0;j<pop->np;j++)
{
pop->fisher[i] = pop->fisher[i]+pop->freq[j]*pop->pind[j].fisher[i];
}
}
jj = 0;
for(i = 0;i<ndim;i++)
{
for(j = 0;j<=i;j++)
{
xa->m[i][j] = pop->fisher[jj];
xa->m[j][i] = pop->fisher[jj];
jj++;
}
}
ifail = ludcmp(xa->m,ndim,indx,&cri);
if(ifail==1) return CRI_MAX;
for(i = 0;i<ndim;i++) cri = cri*xa->m[i][i];
pop->det = cri;
for(i = 0;i<ndim;i++)
{
for(j = 0;j<ndim;j++) col[j] = 0.0;
col[i] = 1.0;
lubksb(xa->m,ndim,indx,col);
for(j = 0;j<ndim;j++)
{
jj = i*(i+1)/2+j;
pop->finv[jj] = col[j]; /*=xb[j][i] using another matrix*/
}
}
/* desallocation */
matrix_destroy(xa);
free(indx);
return cri;
}
void test0() {
Matrix m1 = matrix_create( 3, 3 );
int i,j;
for ( i=0; i<3; ++i ) { for ( j=0; j<3; ++j ) { m1[i][j] = i+j; } }
printf( "m1 =\n" );
matrix_print( m1, 3, 3 );
matrix_delete( m1, 3 );
}
// only works for 2x2 matrices
matrix matrix_inverse(matrix A){
double data[A.rows*A.columns];
data[0] = *A.data[0];
data[3] = *A.data[3];
data[1] = -*A.data[2];
data[2] = -*A.data[1];
double s = data[0] * *A.data[3] - data[2] * *A.data[1];
matrix m = matrix_create(A.rows, A.columns, data);
return matrix_scale(m, 1.0/s);
}
matrix matrix_transpose(matrix A){
double data[A.columns*A.rows];
matrix m = matrix_create(A.columns, A.rows, data);
for (int i = 0; i < A.rows; ++i){
for (int j = 0; i < A.columns; ++j){
*m.data[i*A.columns + j] = *A.data[i*A.columns + i];
}
}
return m;
}
matrix matrix_subtract(matrix A, matrix B){
double data[A.rows*A.columns];
matrix m = matrix_create(A.rows, A.columns, data);
for (int i = 0; i < A.rows; ++i){
for (int j = 0; i < A.columns; ++j){
*m.data[i*A.columns + j] = *A.data[i*A.columns + j] - *B.data[i*A.columns + j];
}
}
return m;
}
matrix matrix_scale(matrix A, double b){
double data[A.rows*A.columns];
matrix m = matrix_create(A.rows, A.columns, data);
for (int i = 0; i < A.rows; ++i){
for (int j = 0; i < A.columns; ++j){
*m.data[i*A.columns + j] = *A.data[i*A.columns + j] * b;
}
}
return m;
}
/* matrix transposition, returns a new matrix, does not delete the original */
Matrix matrix_transpose( Matrix m, int num_rows, int num_columns )
{
int i, j;
Matrix Result = matrix_create( num_columns, num_rows);
for(i = 0; i < num_rows ; i++)
for(j = 0; j < num_columns; j++)
Result[j][i] = m[i][j];
return Result;
}
void test1() {
Matrix m1 = matrix_create( 3, 3 );
Matrix m2 = matrix_create( 3, 3 );
Matrix m3 = matrix_create( 3, 3 );
int i,j;
for ( i=0; i<3; ++i ) { for ( j=0; j<3; ++j ) { m1[i][j] = i+j; } }
for ( i=0; i<3; ++i ) { for ( j=0; j<3; ++j ) { m2[i][j] = 5; } }
printf( "m1 =\n" );
matrix_print( m1, 3, 3 );
printf( "m2 =\n" );
matrix_print( m2, 3, 3 );
matrix_add( m1, m2, m3, 3, 3 );
printf( "m1 + m2 =\n" );
matrix_print( m3, 3, 3 );
matrix_delete( m1, 3 );
matrix_delete( m2, 3 );
matrix_delete( m3, 3 );
}
/* Matrix transposition */
Matrix matrix_transpose(Matrix m, int num_rows, int num_columns)
{
int i,j;
Matrix m_t = matrix_create(num_rows, num_columns);
for(i = 0; i < num_rows; i++)
{
for(j=0; j < num_columns; j++)
{
m_t[i][j] = m[j][i];
}
}
return m_t;
}
/*! @brief Multiply a matrix with another matrix
@param A First Matrix
@param B Second Matrix
@return Multiplied matrix
*/
struct Matrix *matrix_multiplication (struct Matrix *A, struct Matrix *B)
{
// A column number is equal to B row number
size_t rowA = 0, colB = 0;
size_t colA = 0, rowB = 0;
double lineValue = 0;
// Result matrix
struct Matrix *matrix = NULL;
// Check pointers
if (!A)
{
printf("matrix_multiplication: Matrix A is null\n");
return NULL;
}
if (!B)
{
printf("matrix_multiplication: Matrix B is null\n");
return NULL;
}
// A column number must be equal to B row number
if ( A->nc != B->nr )
{
printf("matrix_multiplication: A->nc != B->nr\n");
return NULL;
}
// Allocate memory for multiplied matrix
matrix = matrix_create(A->nr, B->nc);
// Compute multiplication ( complexity of O(n^3) ,
// the best is O(n^2,36) but isn't implemented here )
for (rowA = 0; rowA < A->nr; rowA++)
{
for (colB = 0; colB < B->nc; colB++)
{
for (colA = 0; colA < A->nc; colA++)
{
rowB = colA;
lineValue += A->data[rowA][colA] * B->data[rowB][colB];
}
matrix->data[rowA][colB] = lineValue;
lineValue = 0;
}
}
return matrix;
}
void test4() {
Matrix m1 = matrix_create( 3, 3 );
int i,j;
for ( i=0; i<3; ++i ) { for ( j=0; j<3; ++j ) { m1[i][j] = i+2*j; } }
printf( "m1 =\n" );
matrix_print( m1, 3, 3 );
printf( "delete column 1 from m1 =\n" );
matrix_delete_column( m1, 1, 3, 3 );
matrix_print( m1, 3, 2 );
matrix_delete( m1, 3 );
}
void test3() {
Matrix m1 = matrix_create( 3, 3 );
int i,j;
for ( i=0; i<3; ++i ) { for ( j=0; j<3; ++j ) { m1[i][j] = i+2*j; } }
printf( "m1 =\n" );
matrix_print( m1, 3, 3 );
printf( "delete row 0 from m1 =\n" );
matrix_delete_row( m1, 0, 3 );
matrix_print( m1, 2, 3 );
matrix_delete( m1, 2 );
}
/*! @brief Convert an array of dots to a matrix
* @param dots Array of dots
* @return Converted array of dots
*/
struct Matrix *dotArray_to_vector2d (struct t_dot *dots, size_t size)
{
size_t i;
struct Matrix *vector2d;
vector2d = matrix_create(2, size);
for (i = 0; i < size; i++)
{
vector2d->data[X_AXIS][i] = dots[i].x;
vector2d->data[Y_AXIS][i] = dots[i].y;
}
return vector2d;
}
/*! @brief Compute the augmented matrix of A and B : (A|B)
@param A First Matrix : Matrix to augment
@param B Second Matrix : Matrix to append
@return The augmented matrix of the form (A|B)
*/
struct Matrix* matrix_augment (struct Matrix *A, struct Matrix *B)
{
// Index for A and m_augmented
size_t i = 0, j = 0;
// Index for B
size_t k = 0;
// Augmented matrix
struct Matrix *m_augmented = NULL;
// Check for valid matrix
if (!A)
{
fprintf(stderr, "matrix_augment: Matrix A is null\n");
return NULL;
}
if (!B)
{
fprintf(stderr, "matrix_augment: Matrix A is null\n");
return NULL;
}
// The two matrix has to have the same number of rows
if (A->nr != B->nr)
{
fprintf(stderr, "matrix_augment: Matrix A and B"
"don't have the same number of rows\n");
return NULL;
}
// Allocate the matrix
m_augmented = matrix_create(A->nr, A->nc + B->nc);
// Construct the augmented matrix
for (i = 0; i < m_augmented->nr; i++)
{
for (j = 0; j < A->nc; j++)
m_augmented->data[i][j] = A->data[i][j];
for (j = A->nc; j < m_augmented->nc; j++)
{
m_augmented->data[i][j] = B->data[i][k];
k++;
}
k = 0;
}
return m_augmented;
}
void test2() {
Matrix m1 = matrix_create( 3, 3 );
Matrix m1_t;
int i,j;
for ( i=0; i<3; ++i ) { for ( j=0; j<3; ++j ) { m1[i][j] = i+2*j; } }
printf( "m1 =\n" );
matrix_print( m1, 3, 3 );
printf( "transpose m1 =\n" );
m1_t = matrix_transpose( m1, 3, 3 );
matrix_print( m1_t, 3, 3 );
matrix_delete( m1, 3 );
matrix_delete( m1_t, 3 );
}
matrix matrix_multiply(matrix A, matrix B){
double data[A.rows*B.columns];
matrix m = matrix_create(A.rows, B.columns, data);
for (int i = 0; i < A.rows; ++i){
for (int j = 0; i < B.columns; ++j){
double s = 0;
for (int k = 0; i < B.rows; ++k){
s += (*A.data[i*A.columns + k]) * (*B.data[k*B.rows + j]);
}
*m.data[i*m.columns + j] = s;
}
}
return m;
}
//
// find edges
//
matrix_t* findEdges(matrix_t* matrix1, float allowedDifference)
{
matrix_t* result;
int x,y;
// sanity check parameters
if(!matrix_create(&result, matrix1->rows, matrix1->cols))
{
perror("failed to create result");
return 0;
}
for (y = 0; y < matrix1->rows; ++y)
{
for (x = 0; x < matrix1->cols; ++x)
{
// check parameters
char tooDifferent = 0;
if (y > 0)
tooDifferent |=
cellDifference(matrix1, x, y, x, y - 1) > allowedDifference;
if (y < matrix1->rows)
tooDifferent |=
cellDifference(matrix1, x, y, x, y + 1) > allowedDifference;
if (x > 0)
tooDifferent |=
cellDifference(matrix1, x, y, x - 1, y) > allowedDifference;
if (x < matrix1->cols)
tooDifferent |=
cellDifference(matrix1, x, y, x + 1, y) > allowedDifference;
//get matrix position
element_t* res = matrix_index(result, x, y);
res->red = res->green = res->blue =
tooDifferent ? 1 : 0;
}
}
return result;
}
int
main(int argc, char **argv)
{
const int m = 10000, n = 10000;
double tbeg, tend;
tbeg = WTime();
struct vector *x = vector_create(n);
struct vector *y = vector_create(m);
struct vector *y_ref = vector_create(m);
struct matrix *A = matrix_create(m, n);
// setup values in our test vector and in our reference result
setup_test_vectors(x, y_ref);
// build a test matrix
setup_test_matrix(A);
tend = WTime();
printf("setup took %g sec\n", tend - tbeg);
// calculate y = Ax
tbeg = WTime();
matrix_vector_multiply(y, A, x);
tend = WTime();
printf("matrix_vector_multiply() took %g sec\n", tend - tbeg);
// the resulting vector for this test should equal our reference result
tbeg = WTime();
assert(vector_is_equal(y, y_ref));
tend = WTime();
printf("checking result took %g sec\n", tend - tbeg);
// clean up
vector_destroy(x);
vector_destroy(y);
vector_destroy(y_ref);
matrix_destroy(A);
return 0;
}
void input_hilbert_m(matrix_t *m)
{
int N;
fprintf(stderr, "[INPUT] Type N\n");
scanf("%d", &N);
*m = matrix_create(N);
for (int i=0; i<N; i++) {
for (int j=0; j<N; j++) {
m->matrix[i][j] = (number_t) 1 / ((number_t) i + j + 1);
}
}
if (N <= 10) {
fprintf(stderr, "[INPUT] Matrix:\n");
matrix_print(stderr, *m, FORMAT_TEXT);
}
}
