Matrix *Matrix_inverse(Matrix *mat){ double det=Matrix_determinant(mat); if(mat->rows != mat->cols || det == 0.0){ return Matrix_create(mat->rows, mat->cols); } Matrix *temp = Matrix_clone(mat); int n = temp->rows; int m = temp->cols; int i,j; double tempdet,val; Matrix *Cofactor = Matrix_create(n, m); for(j = 0; j < m; j++){ for(i = 0; i < n; i++){ Matrix *Mintemp = Matrix_minor(temp,i, j); tempdet = Matrix_determinant(Mintemp); Matrix_set(Cofactor,i,j,tempdet); } } Cofactor = Matrix_transpose(Cofactor); for(i = 0; i < n; i++){ for(j = 0; j < m; j++){ val=Matrix_get(Cofactor,i,j) * pow(-1.0,(i+j)) /det; if(isnan(val)) val=0; Matrix_set(Cofactor,i,j, val); //Cofactor.setValue(i, j, (Cofactor.getValue(i, j) * Math.pow(-1D, i + j + 2)) / det); } } return Cofactor; }
structMesh* MeshCreate() { structMesh *mesh = (structMesh*)calloc(1, sizeof(structMesh)); double xmin, xmax, ymin, ymax; int dim1, dim2; // initialize the mesh xmin = 0.0; xmax = 2.0; ymin = 0.0; ymax = 2.0; mesh->ndim1 = np; // No. of points along x coordinate mesh->ndim2 = np; // No. of points along y coordinate mesh->dx = (xmax - xmin)/(double)(np - 1.0); mesh->dy = (ymax - ymin)/(double)(np - 1.0); mesh->x = Matrix_create(mesh->ndim1, mesh->ndim2); mesh->y = Matrix_create(mesh->ndim1, mesh->ndim2); // initialize the condition for (dim1=0; dim1<mesh->ndim1; dim1++) { for (dim2=0; dim2<mesh->ndim2; dim2++) { mesh->x[dim1][dim2] = dim2*mesh->dx; mesh->y[dim1][dim2] = dim1*mesh->dy; } } return mesh; }
structMesh* ParallelMeshCreate(){ structMesh *mesh = (structMesh*)calloc(1, sizeof(structMesh)); double xmin, xmax, ymin, ymax; int dim1, dim2; // start and end row number int procid, nprocs; MPI_Comm_rank(MPI_COMM_WORLD, &procid); MPI_Comm_size(MPI_COMM_WORLD, &nprocs); int Rstart=0, Rend=0, Rnum; int p=0; int Rlocal=(np+nprocs-1)/nprocs; for (p=0; p<=procid; p++){ Rend += Rlocal; } Rstart = Rend-Rlocal; if (Rend>np){ Rend = np; } // Add two rows as ghost points. Rstart -= 1; Rend += 1; Rnum = Rend-Rstart; // printf("procid=%d, Rstart=%d, Rlocal=%d, Rend=%d, Rnum=%d\n", // procid, Rstart, Rlocal, Rend, Rnum); // initialize the mesh xmin = 0.0; xmax = 2.0; ymin = 0.0; ymax = 2.0; mesh->ndim1 = Rnum; // No. of points along y coordinate mesh->ndim2 = np; // No. of points along x coordinate mesh->dx = (xmax - xmin)/(double)(np - 1.0); mesh->dy = (ymax - ymin)/(double)(np - 1.0); mesh->x = Matrix_create(mesh->ndim1, mesh->ndim2); mesh->y = Matrix_create(mesh->ndim1, mesh->ndim2); // initialize the condition for (dim1=0; dim1<Rnum; dim1++) { for (dim2=0; dim2<mesh->ndim2; dim2++) { int id = Rstart + dim1; mesh->x[dim1][dim2] = dim2*mesh->dx; mesh->y[dim1][dim2] = id*mesh->dy; } } // printf("procid=%d, Rstart=%d, Rend=%d, Rnum=%d, ymin=%f, ymax=%f\n", // procid, Rstart, Rend, Rnum, mesh->y[0][0], mesh->y[Rnum-1][0]); return mesh; }
/** * @brief * Use Euler Advection Scheme to Solve the PDE. */ int ConvectionSolve2d(structMesh *mesh, physics *phy, double** c, double finalTime){ double time, CFL, dt; double **rhs = Matrix_create(mesh->ndim1, mesh->ndim2); time = 0.0; CFL = 0.1; // calculate time interval - dt dt = getTimeInterval(mesh, phy, CFL); double start, stop; start = MPI_Wtime(); while (time < finalTime) { // increase local time if (time+dt > finalTime) { dt = finalTime - time; time = finalTime; }else{ time += dt; } TimeEvolution(mesh, phy, c, time, dt, rhs); } stop = MPI_Wtime(); printf("Time Usaged: %f\n", (stop-start)*1000.0 ); Matrix_free(rhs); return 0; }
Matrix *Util_get_distance_matrix(Point * PointArr){ Matrix *DM = Matrix_create(4,4); double d0 = NAN; double d01 = Point_get_distance_between(&PointArr[0], &PointArr[1]); double d02 = Point_get_distance_between(&PointArr[0], &PointArr[2]); double d03 = Point_get_distance_between(&PointArr[0], &PointArr[3]); double d12 = Point_get_distance_between(&PointArr[1], &PointArr[2]); double d13 = Point_get_distance_between(&PointArr[1], &PointArr[3]); double d23 = Point_get_distance_between(&PointArr[2], &PointArr[3]); //diagonals Matrix_set(DM, 0, 0, d0); Matrix_set(DM, 1, 1, d0); Matrix_set(DM, 2, 2, d0); Matrix_set(DM, 3, 3, d0); Matrix_set(DM,0,1, d01); Matrix_set(DM,1,0, d01); Matrix_set(DM,0,2, d02); Matrix_set(DM,2,0, d02); Matrix_set(DM,0,3, d03); Matrix_set(DM,3,0, d03); Matrix_set(DM,1,2, d12); Matrix_set(DM,2,1, d12); Matrix_set(DM,1,3, d13); Matrix_set(DM,3,1, d13); Matrix_set(DM,2,3, d23); Matrix_set(DM,3,2, d23); return DM; }
autoMatrix Matrix_readAP (MelderFile file) { try { autofile f = Melder_fopen (file, "rb"); int16_t header [256]; for (long i = 0; i < 256; i ++) header [i] = bingeti2LE (f); double samplingFrequency = header [100]; // converting up (from 16 to 54 bytes) Melder_casual (U"Sampling frequency ", samplingFrequency); autoMatrix me = Matrix_create (0.0, (double) header [34], header [34] /* Number of frames. */, 1.0, 0.5, 0.0, (double) header [35], header [35] /* Number of words per frame. */, 1.0, 0.5); /*Mat := MATRIX_create (Buffer.I2 [36], (* Number of words per frame. *) Buffer.I2 [35], (* Number of frames. *) 1.0, Buffer.I2 [111] / (* Samples per frame. *) Buffer.I2 [101]); (* Sampling frequency. *)*/ Melder_casual (U"... Loading ", header [34], U" frames", U" of ", header [35], U" words ..."); for (long i = 1; i <= my nx; i ++) for (long j = 1; j <= my ny; j ++) my z [j] [i] = bingeti2LE (f); // converting up (from 16 to 54 bytes) /* * Get pitch frequencies. */ for (long i = 1; i <= my nx; i ++) if (my z [1] [i] != 0.0) my z [1] [i] = - samplingFrequency / my z [1] [i]; f.close (file); return me; } catch (MelderError) { Melder_throw (U"Matrix object not read from AP file ", file); } }
autoMatrix Matrix_solveEquation (Matrix me, double /* tolerance */) { try { long nr = my ny, nc = my nx - 1; if (nc == 0) { Melder_throw (U"Matrix_solveEquation: there must be at least 2 columns in the matrix."); } if (nr < nc) { Melder_warning (U"Matrix_solveEquation: solution is not unique (fewer equations than unknowns)."); } autoNUMmatrix<double> u (1, nr, 1, nc); autoNUMvector<double> b (1, nr); autoNUMvector<double> x (1, nc); autoMatrix thee = Matrix_create (0.5, 0.5 + nc, nc, 1, 1, 0.5, 1.5, 1, 1, 1); for (long i = 1; i <= nr; i++) { for (long j = 1; j <= nc; j++) { u[i][j] = my z[i][j]; } b[i] = my z[i][my nx]; } NUMsolveEquation (u.peek(), nr, nc, b.peek(), 0, x.peek()); for (long j = 1; j <= nc; j++) { thy z[1][j] = x[j]; } return thee; } catch (MelderError) { Melder_throw (U"Matrix equation not solved."); } }
Matrix* Matrix_minor(Matrix *mat, int x, int y){ Matrix *temp = Matrix_clone(mat); Matrix *newmat = Matrix_create(temp->rows - 1, temp->cols - 1); int i,j; int n = temp->rows; int m = temp->cols; int cnt = 0; double *myArr = (double*)malloc((n - 1) * (m - 1) * sizeof(double)); for(i = 0; i < n; i++){ for(j = 0; j < m; j++){ if(i != x && j != y){ myArr[cnt] = Matrix_get(temp,i,j); cnt++; } } } cnt = 0; for(i = 0; i < n - 1; i++){ for(j = 0; j < m - 1; j++){ Matrix_set(newmat,i,j,myArr[cnt]); cnt++; } } return newmat; }
Any Activation_to_Matrix (I) { iam (Activation); Matrix thee = Matrix_create (my xmin, my xmax, my nx, my dx, my x1, my ymin, my ymax, my ny, my dy, my y1); if (! thee) return NULL; NUMdmatrix_copyElements (my z, thy z, 1, my ny, 1, my nx); return thee; }
/*====================================================================================================*/ Matrix_TypeDef *Matrix_copyArray( double *pArray, uint16_t rows, uint16_t cols ) { Matrix_TypeDef *matrix = Matrix_create(rows, cols); for(uint32_t i = 0; i < matrix->rows * matrix->cols; i++) matrix->arr[i] = pArray[i]; return matrix; }
/*====================================================================================================*/ Matrix_TypeDef *Matrix_createDiag( uint16_t cols, double data ) { Matrix_TypeDef *matrix = Matrix_create(cols, cols); for(uint16_t i = 0; i < cols; i++) matrix->arr[i * matrix->cols + i] = data; return matrix; }
/*====================================================================================================*/ Matrix_TypeDef *Matrix_copyMatrix( Matrix_TypeDef *pMatrix ) { Matrix_TypeDef *matrix = Matrix_create(pMatrix->rows, pMatrix->cols); for(uint32_t i = 0; i < pMatrix->rows * pMatrix->cols; i++) matrix->arr[i] = pMatrix->arr[i]; return matrix; }
autoMatrix Activation_to_Matrix (Activation me) { try { autoMatrix thee = Matrix_create (my xmin, my xmax, my nx, my dx, my x1, my ymin, my ymax, my ny, my dy, my y1); NUMmatrix_copyElements (my z, thy z, 1, my ny, 1, my nx); return thee; } catch (MelderError) { Melder_throw (me, U": not converted to Matrix."); } }
autoMatrix VocalTract_to_Matrix (VocalTract me) { try { autoMatrix thee = Matrix_create (my xmin, my xmax, my nx, my dx, my x1, my ymin, my ymax, my ny, my dy, my y1); NUMvector_copyElements (my z [1], thy z [1], 1, my nx); return thee; } catch (MelderError) { Melder_throw (me, U": not converted to Matrix."); } }
Matrix Spectrogram_to_Matrix (Spectrogram me) { try { autoMatrix thee = Matrix_create (my xmin, my xmax, my nx, my dx, my x1, my ymin, my ymax, my ny, my dy, my y1); NUMmatrix_copyElements (my z, thy z, 1, my ny, 1, my nx); return thee.transfer(); } catch (MelderError) { Melder_throw (me, U": not converted to Matrix."); } }
Matrix Polygon_to_Matrix (Polygon me) { try { autoMatrix thee = Matrix_create (1, my numberOfPoints, my numberOfPoints, 1, 1, 1, 2, 2, 1, 1); NUMvector_copyElements (my x, thy z [1], 1, my numberOfPoints); NUMvector_copyElements (my y, thy z [2], 1, my numberOfPoints); return thee.transfer(); } catch (MelderError) { Melder_throw (me, U": not converted to Matrix."); } }
Matrix *Matrix_transpose(Matrix *m){ Matrix *newmatrix=Matrix_create(m->cols, m->rows); int i,j; for (i=0;i<m->rows;i++){ for (j=0;j<m->cols;j++){ Matrix_set(newmatrix,j,i,Matrix_get(m,i,j)); } } return(newmatrix); }
/* void MelFilter_drawFilters (MelFilter me, Graphics g, long from, long to, double fmin, double fmax, double ymin, double ymax, int dbscale, int garnish) { long i; double df = my dy; if (fmin >= fmax) { fmin = my ymin; fmax = my ymax; } if (from >= to) { from = 1; to = my ny; } Graphics_setWindow (g, my ymin, my ymax, 0, 1); Graphics_setInner (g); for (i = from; i <= to; i++) { double fc = my y1 + (i - 1) * df; double fc_hz = MELTOHZ (fc); double fl_hz = MELTOHZ (fc - df); double fh_hz = MELTOHZ (fc + df); *//* Draw triangle *//* Graphics_line (g, fl_hz, 0, fc_hz, 1); Graphics_line (g, fc_hz, 1, fh_hz, 0); } Graphics_unsetInner (g); } */ Matrix FilterBank_to_Matrix (I) { iam (Matrix); try { autoMatrix thee = Matrix_create (my xmin, my xmax, my nx, my dx, my x1, my ymin, my ymax, my ny, my dy, my y1); NUMmatrix_copyElements (my z, thy z, 1, my ny, 1, my nx); return thee.transfer(); } catch (MelderError) { Melder_throw (me, U": not converted to Matrix."); } }
Matrix *Matrix_product_scaler(Matrix *m, double s){ Matrix* newm=Matrix_create(m->rows, m->cols); int i,total=m->cols*m->rows; double *p=m->data; double *np=newm->data; for (i=0;i<total;i++){ *np=*p*s; np++;p++; } return(newm); }
Matrix* Matrix_clone(Matrix *source){ Matrix* newmatrix=Matrix_create(source->rows,source->cols); int total=source->rows * source->cols; int i; double *p=newmatrix->data; double *sourcedata=source->data; for (i=0;i<total;i++){ *p=*sourcedata; p++;sourcedata++; } return(newmatrix); }
Matrix Pitch_to_Matrix (Pitch me) { try { autoMatrix thee = Matrix_create (my xmin, my xmax, my nx, my dx, my x1, 1, 1, 1, 1, 1); for (long i = 1; i <= my nx; i ++) { double value = my frame [i]. candidate [1]. frequency; thy z [1] [i] = value > 0.0 && value < my ceiling ? my frame [i]. candidate [1]. frequency : 0.0; } return thee.transfer(); } catch (MelderError) { Melder_throw (me, ": not converted to Matrix."); } }
autoMatrix PointProcess_to_Matrix (PointProcess me) { try { if (my nt == 0) Melder_throw (U"No times in PointProcess."); autoMatrix thee = Matrix_create (1, my nt, my nt, 1, 1, 1, 1, 1, 1, 1); for (long i = 1; i <= my nt; i ++) thy z [1] [i] = my t [i]; return thee; } catch (MelderError) { Melder_throw (me, U": not converted to Matrix."); } }
Matrix Formant_to_Matrix_bandwidths (Formant me, int iformant) { try { autoMatrix thee = Matrix_create (my xmin, my xmax, my nx, my dx, my x1, 1.0, 1.0, 1, 1.0, 1.0); for (long iframe = 1; iframe <= my nx; iframe ++) { Formant_Frame frame = & my d_frames [iframe]; thy z [1] [iframe] = iformant <= frame -> nFormants ? frame -> formant [iformant]. bandwidth : 0.0; } return thee.transfer(); } catch (MelderError) { Melder_throw (me, U": bandwidths of formant ", iformant, U" not converted to Matrix."); } }
Matrix *Matrix_product(Matrix *m1, Matrix *m2){ int i,j,y; Matrix *c=Matrix_create(m1->rows,m1->cols); for(i =0;i<m1->rows; i++){ for(j=0;j<m2->cols; j++){ for(y=0;y<m1->cols; y++){ Matrix_set(c,i,j,Matrix_get(c,i,j) + Matrix_get(m1,i,y) * Matrix_get(m2,y,j)); } } } return(c); }
/* Paul Fournel */ Matrix *Matrix_create_random(int rows){ Matrix *m=Matrix_create(rows,rows); int i,j,d1=m->rows, d2=m->cols; double *p=m->data; srand(time(NULL)); for (i=0;i<d1;i++){ for (j=0;j<d2;j++){ *p =rand()%4-2; p++; } } return(m); }
Matrix *Matrix_sub(Matrix *m1, Matrix *m2){ Matrix* sum=Matrix_create(m1->rows, m1->cols); int total=m1->rows*m1->cols; int i; double *p1=m1->data; double *p2=m2->data; double *s1=sum->data; for (i=0;i<total;i++){ *s1=*p1 - *p2; s1++;p1++;p2++; } return(sum); }
autoMatrix Matrix_transpose (Matrix me) { try { autoMatrix thee = Matrix_create (my ymin, my ymax, my ny, my dy, my y1, my xmin, my xmax, my nx, my dx, my x1); for (long i = 1; i <= my ny; i++) { for (long j = 1; j <= my nx; j++) { thy z[j][i] = my z[i][j]; } } return thee; } catch (MelderError) { Melder_throw (me, U": not transposed."); } }
autoMatrix LineSpectralFrequencies_downto_Matrix (LineSpectralFrequencies me) { try { autoMatrix thee = Matrix_create (my xmin, my xmax, my nx, my dx, my x1, 0.5, 0.5 + my maximumNumberOfFrequencies, my maximumNumberOfFrequencies, 1.0, 1.0); for (long j = 1; j <= my nx; j++) { LineSpectralFrequencies_Frame lsf = & my d_frames[j]; for (long i = 1; i <= lsf -> numberOfFrequencies; i++) { thy z [i][j] = lsf -> frequencies [i]; } } return thee; } catch (MelderError) { Melder_throw (me, U": no Matrix with linear prediction coefficients created."); } }
Matrix BandFilterSpectrogram_to_Matrix (BandFilterSpectrogram me, int to_dB) { try { int units = to_dB ? 1 : 0; autoMatrix thee = Matrix_create (my xmin, my xmax, my nx, my dx, my x1, my ymin, my ymax, my ny, my dy, my y1); for (long i = 1; i <= my ny; i++) { for (long j = 1; j <= my nx; j++) { thy z[i][j] = my v_getValueAtSample (j, i, units); } } return thee.transfer(); } catch (MelderError) { Melder_throw (me, U": not converted to Matrix."); } }
Matrix LPC_downto_Matrix_lpc (LPC me) { try { autoMatrix thee = Matrix_create (my xmin, my xmax, my nx, my dx, my x1, 0.5, 0.5 + my maxnCoefficients, my maxnCoefficients, 1, 1); for (long j = 1; j <= my nx; j++) { LPC_Frame lpc = & my d_frames[j]; for (long i = 1; i <= lpc -> nCoefficients; i++) { thy z[i][j] = lpc -> a[i]; } } return thee.transfer(); } catch (MelderError) { Melder_throw (me, ": no Matrix with linear prediction coefficients created."); } }