MATRIX __mat_creat(int row, int col)
{
MATRIX mat = NULL;
int i;
if((mat = (MATRIX)malloc(sizeof(mtype *)*(row+2)))==NULL)
return (mat_error( MAT_MALLOC ));
for(i=2; i<row+2; ++i)
{
if((*((mtype **)(mat + i)) = (mtype *)malloc(sizeof(mtype)*col))==NULL)
return (mat_error(MAT_MALLOC));
}
*((int*)(mat)) = row;
*((int*)(mat+1)) = col;
return (mat+2);
}
MATRIX mat_randn(int n, int m, MATRIX result)
{
int i, j;
mtype tmp0;
if(result==NULL) if((result = mat_creat(n, m, UNDEFINED))==NULL)
return mat_error(MAT_MALLOC);
if(!MAT_SET_SEED)mat_set_seed(0);
for(i=0; i<n; ++i)
{
for(j=0; j<m; ++j)
{
result[i][j] = (mtype)((mtype)rand()/((mtype)RAND_MAX+1.0f)+EPS);
}
}
if(MatNumel(result)>0) srand((unsigned int)(result[0][0]*7923+1));
for(i=0; i<n; ++i)
{
for(j=0; j<m; ++j)
{
tmp0 =((mtype)rand())/((mtype)RAND_MAX+1.0f);
if(result[i][j]!=0) result[i][j] = (mtype)(sqrt(-2.0f*log(result[i][j]))*cos(2.0f*3.141592f*tmp0));
}
}
return result;
}
MATRIX mat_xcopy(MATRIX A, int si, int ei, int sj, int ej, MATRIX result)
{
int i, j, m, n;
m = MatCol(A);
n = MatRow(A);
if(si<0 || sj<0 || ei>n || ei>m) mat_error(MAT_SIZEMISMATCH);
if(result== NULL) if((result = mat_creat(ei-si, ej-sj, UNDEFINED))==NULL)
return mat_error(MAT_MALLOC);
#pragma omp parallel for private(j)
for(i=si; i<ei; ++i)
for(j=sj; j<ej; ++j)
{
result[i-si][j-sj] = A[i][j];
}
return result;
}
MATRIX mat_xjoin(MATRIX A11, MATRIX A12, MATRIX A21, MATRIX A22, MATRIX result)
{
int i, j, m, n;
m = MatCol(A11)+MatCol(A12);
n = MatRow(A11)+MatRow(A21);
if(result== NULL) if((result = mat_creat(m, n, UNDEFINED))==NULL)
return mat_error(MAT_MALLOC);
#pragma omp parallel for private(j)
for(i=0; i<MatRow(A11); ++i)
for(j=0; j<MatCol(A11); ++j)
{
result[i][j] = A11[i][j];
}
#pragma omp parallel for private(j)
for(i=0; i<MatRow(A12); ++i)
for(j=0; j<MatCol(A12); ++j)
{
result[i][j+MatCol(A11)] = A12[i][j];
}
#pragma omp parallel for private(j)
for(i=0; i<MatRow(A21); ++i)
for(j=0; j<MatCol(A21); ++j)
{
result[i+MatRow(A21)][j] = A21[i][j];
}
#pragma omp parallel for private(j)
for(i=0; i<MatRow(A22); ++i)
for(j=0; j<MatCol(A22); ++j)
{
result[i+MatRow(A11)][j+MatCol(A22)] = A22[i][j];
}
return result;
}
MATSTACK mat_eig_sym(MATRIX symmat, MATSTACK result)
{
int m, n;
MATRIX im, tmp_result0 = NULL, tmp_result1 = NULL;
INT_VECTOR indcs = NULL;
MATSTACK tmp = NULL;
m = MatCol(symmat);
n = MatRow(symmat);
if(m!=n) mat_error(MAT_SIZEMISMATCH);
if(result==NULL)
{
if ((result = matstack_creat(2)) == NULL)
return matstack_error(MATSTACK_MALLOC);
result[0] = NULL;
result[1] = NULL;
}
im = mat_creat(m, 1, UNDEFINED);
tmp_result0 = mat_creat(m, 1, UNDEFINED);
tmp_result1 = mat_copy(symmat, tmp_result1);
mat_tred2(tmp_result1, tmp_result0, im);
mat_tqli(tmp_result0, im, tmp_result1);
tmp = mat_qsort(tmp_result0, ROWS, tmp);
result[0] = mat_copy(tmp[0], result[0]);
indcs = mat_2int_vec(tmp[1]);
result[1] = mat_get_sub_matrix_from_cols(tmp_result1, indcs, result[1]);
int_vec_free(indcs);
mat_free(im);
mat_free(tmp_result0);
mat_free(tmp_result1);
return result;
}
/*
Function which make the transposition operation of a
matrix passed as a parameter.
It returns a double pointer which points to the current location
in which the new trasposed matrix will be.
*/
matrice* trasposta( matrice *mt, matrice *m )
{
int i,j;
if ( !matrixExist(m) )
{
set_error(EMNI);
printf("PROVA");
mat_error("PROVAAAAA");
}
else
if ( ( leggiRighe(mt) != leggiColonne(m) && leggiColonne(mt) != leggiRighe(m) ) )
{
if ( get_curr_error() == EMNOTF )
set_error(EMTRASP);
}
else
{
for ( i=0; i < leggiRighe(mt); i++ )
for ( j = 0; j < leggiColonne(mt); j++ )
scriviElemento(mt,i,j,leggiElemento(m,j,i));
}
return ( get_curr_error() == EMNOTF ) ? mt : NULL;
}
MATRIX mat_pick_col(MATRIX A, int c, MATRIX result)
{
int n, i;
n = MatRow(A);
if(result==NULL) if((result = mat_creat(n, 1, UNDEFINED))==NULL) mat_error(MAT_MALLOC);
for(i=0; i<n; ++i) result[i][0] = A[i][c];
return result;
}
MATRIX mat_pick_row(MATRIX A, int r, MATRIX result)
{
int m, i;
m = MatCol(A);
if(result==NULL) if((result = mat_creat(1, m, UNDEFINED))==NULL) mat_error(MAT_MALLOC);
for(i=0; i<m; ++i) result[0][i] = A[r][i];
return result;
}
MATRIX mat_concat(MATRIX A, MATRIX B, int dim)
{
int i, j, m, n, o, p;
MATRIX result;
if(A==NULL)
{
return mat_copy(B, NULL);
}
else
{
m = MatCol(A);
n = MatRow(A);
}
if(B==NULL)
{
return mat_copy(A, NULL);
}
else
{
o = MatCol(B);
p = MatRow(B);
}
if((dim==ROWS)&&((m==o) ||!((m==0)&&(o==0))))
{
if((result = mat_creat(n+p, m, UNDEFINED))==NULL) return NULL;
#pragma omp parallel for private(j)
for(i=0; i<n; ++i)
{
for(j=0; j<m; ++j)
{
result[i][j] = A[i][j];
}
}
#pragma omp parallel for private(j)
for(i=0; i<p; ++i)
{
for(j=0; j<m; ++j)
{
result[i+n][j] = B[i][j];
}
}
return result;
}
if((dim==COLS)&&((n==p) ||!((n==0)&&(p==0))))
{
if((result = mat_creat(n, m+o, UNDEFINED))==NULL) return NULL;
#pragma omp parallel for private(j)
for(i=0; i<n; ++i)
{
for(j=0; j<m; ++j) result[i][j] = A[i][j];
for(j=0; j<o; ++j) result[i][j+m] = B[i][j];
}
return result;
}
return mat_error(MAT_SIZEMISMATCH);
}
MATRIX mat_get_sub_matrix_from_cols(MATRIX A, INT_VECTOR indices, MATRIX result)
{
int i, j, k, n;
k = MatRow(A);
n = Int_VecLen(indices);
if(result==NULL) if((result = mat_creat(k, n, UNDEFINED))==NULL)
return mat_error(MAT_MALLOC);
for(i=0; i<n; ++i)
{
for(j=0; j<k; ++j) result[j][i] = A[j][indices[i]];
}
return result;
}
MATRIX mat_sum_col(MATRIX A, MATRIX result)
{
int i, j, m, n;
m = MatCol(A);
n = MatRow(A);
if(result==NULL) if((result = mat_creat(1, m, ZERO_MATRIX))==NULL) mat_error(MAT_MALLOC);
#pragma omp parallel for private(j)
for(i=0; i<m; ++i)
{
result[0][i] = 0.0;
for(j=0; j<n; ++j) result[0][i] += A[j][i];
}
return result;
}
MATRIX mat_randperm(int m, int n, MATRIX result)
{
int i, j;
MATRIX tmp = NULL;
if(result==NULL) if((result = mat_creat(m, n, UNDEFINED))==NULL)
return mat_error(MAT_MALLOC);
for(i=0; i<m; ++i)
{
tmp = mat_randperm_n(n, tmp);
for(j=0; j<n; ++j) result[i][j] = tmp[0][j];
}
mat_free(tmp);
return result;
}
MATRIX mat_creat_diag(MATRIX diag_vals, MATRIX result)
{
int i, sz;
if(MatCol(diag_vals)==1) sz = MatRow(diag_vals);
else sz = MatCol(diag_vals);
if(result==NULL) if((result = mat_creat(sz, sz, ZERO_MATRIX))==NULL) mat_error(MAT_MALLOC);
{
if(MatCol(diag_vals)==1)
for(i=0; i<sz; ++i) result[i][i] = diag_vals[i][0];
else
for(i=0; i<sz; ++i) result[i][i] = diag_vals[0][i];
return result;
}
}
MATRIX mat_rand(int n, int m, MATRIX result)
{
int i, j;
if(result==NULL) if((result = mat_creat(n, m, UNDEFINED))==NULL)
return mat_error(MAT_MALLOC);
if(!MAT_SET_SEED)mat_set_seed(0);
for(i=0; i<n; ++i)
{
for(j=0; j<m; ++j)
{
result[i][j] = ((mtype)rand())/((mtype)RAND_MAX+1.0);
}
}
return result;
}
MATRIX mat_randfun(int n, int m, mtype (*fun)(mtype), mtype xmin, mtype xmax, MATRIX result)
{
int i, j;
if(result==NULL) if((result = mat_creat(n, m, UNDEFINED))==NULL)
return mat_error(MAT_MALLOC);
if(!MAT_SET_SEED)mat_set_seed(0);
for(i=0; i<n; ++i)
{
for(j=0; j<m; ++j)
{
result[i][j] = __mat_randfun(fun, xmin, xmax);
}
}
return result;
}
MATRIX mat_copy(MATRIX A, MATRIX result)
{
int i, j, m, n;
m = MatCol(A);
n = MatRow(A);
if(result==NULL) if((result = mat_creat(n, m, UNDEFINED))==NULL)
return mat_error(MAT_MALLOC);
#pragma omp parallel for private(j)
for(i=0; i<n; ++i)
for(j=0; j<m; ++j)
{
result[i][j] = A[i][j];
}
return result;
}
MATRIX mat_tran(MATRIX A, MATRIX result)
{
int i, j, m, n;
m = MatCol(A);
n = MatRow(A);
if(result== NULL) if((result = mat_creat(m,n, UNDEFINED))==NULL)
return mat_error(MAT_MALLOC);
for(i=0; i<m; ++i)
for (j=0; j<n; ++j)
{
result[i][j] = A[j][i];
}
return result;
}
MATRIX mat_div_dot(MATRIX A, MATRIX B, MATRIX result)
{
int i, j, m, n, o, p;
m = MatCol(A);
n = MatRow(A);
o = MatCol(B);
p = MatRow(B);
if(result==NULL) if((result = mat_creat(MatRow(A), MatCol(A), UNDEFINED))==NULL)
return mat_error(MAT_MALLOC);
if(o==m &&p==n)
{
#pragma omp parallel for private(j)
for(i=0; i<n; ++i)
{
for(j=0; j<m; ++j)
{
result[i][j] = A[i][j]/B[i][j];
}
}
}
else if(o==1 && p!=1)
{
#pragma omp parallel for private(j)
for(i=0; i<n; ++i)
{
for(j=0; j<m; ++j)
{
result[i][j] = A[i][j]/B[i][0];
}
}
}
else if(p==1 && o!=1)
{
#pragma omp parallel for private(j)
for(i=0; i<n; ++i)
{
for(j=0; j<m; ++j)
{
result[i][j] = A[i][j]/B[0][j];
}
}
}
else gen_error(GEN_SIZEMISMATCH);
return result;
}
MATRIX mat_calc_dist_sq(MATRIX A, MATRIX d, MATRIX result)
{
int i, j, m, n;
mtype dist;
m = MatRow(A);
n = MatCol(A);
if(result==NULL) if((result = mat_creat(1, n, ZERO_MATRIX))==NULL) return mat_error(MAT_MALLOC);;
for(i=0; i<n; ++i)
{
dist = 0.0;
for(j=0; j<m; ++j)
{
dist += (A[j][i]-d[j][0])*(A[j][i]-d[j][0]);
}
result[0][i] = dist;
}
return result;
}
MATRIX mat_randperm_n(int n, MATRIX result)
{
int i, j;
mtype t = 0.0;
if(result==NULL) if((result = mat_creat(1, n, UNDEFINED))==NULL)
return mat_error(MAT_MALLOC);
if(!MAT_SET_SEED) mat_set_seed(0);
for(i=0; i<n; ++i)
result[0][i] = i;
for(i=0; i<n; ++i)
{
j = rand()%(n-i)+i;
t = result[0][j];
result[0][j] =result[0][i];
result[0][i] = t;
}
return result;
}
MATRIX mat_pol2cart(MATRIX A, int dim, MATRIX result)
{
int m, n, i;
m = MatCol(A);
n = MatRow(A);
if(dim==0 && n>1)
{
if(result==NULL)if((result = mat_creat(2, m, ZERO_MATRIX))==NULL) return NULL;
for(i=0; i<m; ++i)
__pol2cart(A[0][i], A[1][i], result[0][i], result[1][i]);
return result;
}
if(dim==1 && m>1)
{
if(result==NULL)if((result = mat_creat(n, 2, ZERO_MATRIX))==NULL) return NULL;
for(i=0; i<n; ++i)
__pol2cart(A[i][0], A[i][1], result[i][0], result[i][1]);
return result;
}
return mat_error (MAT_SIZEMISMATCH);
}
MATRIX mat_bsxfun(MATRIX A, MATRIX B, mtype (*func)(mtype, mtype), MATRIX result)
{
int m, n, o, p, i, j;
m = MatRow(A);
n = MatCol(A);
o = MatRow(B);
p = MatCol(B);
if(m<o && n==p && m==1)
{
if(result== NULL) if((result = mat_creat(o, n, UNDEFINED))==NULL) return mat_error(MAT_MALLOC);
for(i=0; i<o; ++i)
{
for(j=0; j<n; ++j)
{
result[i][j] = (*func)(A[0][j], B[i][j]);
}
}
}
else if(m>o && n==p && o==1)
{
if(result== NULL) if((result = mat_creat(m, n, UNDEFINED))==NULL) return mat_error(MAT_MALLOC);
for(i=0; i<m; ++i)
{
for(j=0; j<n; ++j)
{
result[i][j] = (*func)(A[i][j], B[0][j]);
}
}
}
else if(m==o && n<p && n==1)
{
if(result== NULL) if((result = mat_creat(m, p, UNDEFINED))==NULL) return mat_error(MAT_MALLOC);
for(i=0; i<m; ++i)
{
for(j=0; j<p; ++j)
{
result[i][j] = (*func)(A[i][0], B[i][j]);
}
}
}
else if(m==o && n>p && p==1)
{
if(result== NULL) if((result = mat_creat(m, n, UNDEFINED))==NULL) return mat_error(MAT_MALLOC);
for(i=0; i<m; ++i)
{
for(j=0; j<n; ++j)
{
result[i][j] = (*func)(A[i][j], B[i][0]);
}
}
}
else if(m==1 && p==1)
{
if(result== NULL) if((result = mat_creat(o, n, UNDEFINED))==NULL) return mat_error(MAT_MALLOC);
for(i=0; i<o; ++i)
{
for(j=0; j<n; ++j)
{
result[i][j] = (*func)(A[0][j], B[i][0]);
}
}
}
else if(n==1 && o==1)
{
if(result== NULL) if((result = mat_creat(m, p, UNDEFINED))==NULL) return mat_error(MAT_MALLOC);
for(i=0; i<m; ++i)
{
for(j=0; j<p; ++j)
{
result[i][j] = (*func)(A[i][0], B[0][j]);
}
}
}
else mat_error(MAT_SIZEMISMATCH);
return result;
}
