コード例 #1
0
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;
    }
コード例 #2
0
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;
}
コード例 #3
0
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;
}
コード例 #4
0
/**
 * @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;
}
コード例 #5
0
ファイル: math_util.c プロジェクト: adrivazo/RobopuffAtmel
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;
}
コード例 #6
0
ファイル: Matrix.cpp プロジェクト: DsRQuicke/praat
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);
	}
}
コード例 #7
0
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.");
	}
}
コード例 #8
0
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;
}
コード例 #9
0
ファイル: Activation.c プロジェクト: alekstorm/tala
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;
}
コード例 #10
0
ファイル: matrix.c プロジェクト: KitSprout/KDWM1000
/*====================================================================================================*/
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;
}
コード例 #11
0
ファイル: matrix.c プロジェクト: KitSprout/KDWM1000
/*====================================================================================================*/
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;
}
コード例 #12
0
ファイル: matrix.c プロジェクト: KitSprout/KDWM1000
/*====================================================================================================*/
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;
}
コード例 #13
0
ファイル: Activation.cpp プロジェクト: DsRQuicke/praat
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.");
	}
}
コード例 #14
0
ファイル: VocalTract.cpp プロジェクト: rlaboiss/praat
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.");
    }
}
コード例 #15
0
ファイル: Spectrogram.cpp プロジェクト: psibre/praat
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.");
	}
}
コード例 #16
0
ファイル: Matrix_and_Polygon.cpp プロジェクト: psibre/praat
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.");
	}
}
コード例 #17
0
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);
}
コード例 #18
0
ファイル: FilterBank.cpp プロジェクト: psibre/praat
/*
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.");
	}
}
コード例 #19
0
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);
}
コード例 #20
0
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);
}
コード例 #21
0
ファイル: Matrix_and_Pitch.cpp プロジェクト: Crisil/praat
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.");
	}
}
コード例 #22
0
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.");
	}
}
コード例 #23
0
ファイル: Formant.cpp プロジェクト: psibre/praat
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.");
	}
}
コード例 #24
0
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);
}
コード例 #25
0
/* 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);
}
コード例 #26
0
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);
}
コード例 #27
0
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.");
	}
}
コード例 #28
0
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.");
	}
}
コード例 #29
0
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.");
	}
}
コード例 #30
0
ファイル: LPC.cpp プロジェクト: Crisil/praat
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.");
	}
}