double do_work(void) {
double **a, /* matrix A to be multiplied */
**b, /* matrix B to be multiplied */
**c; /* result matrix C */
a = allocateMatrix(NRA, NCA);
b = allocateMatrix(NCA, NCB);
c = allocateMatrix(NRA, NCB);
/*** Spawn a parallel region explicitly scoping all variables ***/
initialize(a, NRA, NCA);
initialize(b, NCA, NCB);
initialize(c, NRA, NCB);
compute(a, b, c, NRA, NCA, NCB);
compute_interchange(a, b, c, NRA, NCA, NCB);
double result = c[0][1];
freeMatrix(a, NRA, NCA);
freeMatrix(b, NCA, NCB);
freeMatrix(c, NCA, NCB);
return result;
}
void matrixSquareRoot(Matrix* A, Matrix* S)
{
//Approach is to do an SVD of A, then set S to V * sqrt(Sigma) * Vtransposed
int i, j;
Matrix* U = allocateMatrix(A->rows, A->columns);
Matrix* Vtransposed = allocateMatrix(A->rows, A->columns);
Matrix* Sigma = allocateMatrix(A->rows, A->columns);
//First do an SVD
singularValueDecomposition(A, U, Vtransposed, Sigma);
//Now calculate sqrt(Sigma) * Vtransposed and stick it in U
for(i = 0; i < Sigma->rows; i++)
{
for(j = 0; j < Sigma->columns; j++)
{
U->pointer[i + j * U->rows] = Vtransposed->pointer[i + j * Vtransposed->rows] * sqrt(Sigma->pointer[i + i * Sigma->rows]);
}
}
multiplyMatrices(Vtransposed, U, S, 1, 0);
freeMatrix(U);
freeMatrix(Vtransposed);
freeMatrix(Sigma);
}
void levelSet3Dfast(MATRIXD im, MATRIX init_mask, int max_its, double E, double T, double alpha,
MATRIX *seg0, MATRIX *tmap, MATRIXD *phi, long **ls_vols, int offset){
long dx = im.dx, dy = im.dy, dz = im.dz;
int *px, *py, *pz, *qx, *qy, *qz, k, tmap_it = 1;
MATRIX intTmp;
MATRIX intTmp2 = allocateMatrix(dx,dy,dz); // add a new temporary matrix
MATRIXD dblTmp = allocateMatrixD(dx,dy,dz);
MATRIXD gradPhi = allocateMatrixD(dx,dy,dz);
int minx, maxx, miny, maxy, minz, maxz;
*phi = allocateMatrixD(dx,dy,dz);
*seg0 = allocateMatrix(dx,dy,dz);
*tmap = allocateMatrix(dx,dy,dz);
*ls_vols = (long *)calloc(max_its,sizeof(long)); // initialized with 0
initializeMatrix(tmap,0);
initializeMatrix(seg0,0); // initialized with 0
initializeMatrix(&intTmp2,0); // initialized with 0
initializeGlobals4bwdist(dx,dy,dz,&px,&py,&pz,&qx,&qy,&qz,&intTmp);
createSignedDistanceMap(init_mask,phi,px,py,pz,qx,qy,qz,intTmp,dblTmp); // temps: intTmp, dblTmp
findLimits(init_mask,offset,&minx,&maxx,&miny,&maxy,&minz,&maxz);
for (k = 1; k <= max_its; k++){
calculateCurvature(*phi,&dblTmp,minx,maxx,miny,maxy,minz,maxz); // dblTmp keeps the curvatures
calculateF(im,dblTmp,&dblTmp,E,T,alpha,minx,maxx,miny,maxy,minz,maxz); // first dblTmp (input): curvatures, second dblTmp (output): F values
calculateGradPhi(*phi,dblTmp,&gradPhi,minx,maxx,miny,maxy,minz,maxz);
evolveCurve(phi,dblTmp,gradPhi,minx,maxx,miny,maxy,minz,maxz);
if (k % 50 == 0)
reinitializeDistanceFunction(phi,init_mask,px,py,pz,qx,qy,qz,intTmp,dblTmp); // temps: init_mask, intTmp, dblTmp
(*ls_vols)[k-1] = selectNonpositive(*phi,&intTmp2,minx,maxx,miny,maxy,minz,maxz); // use the second temporarymatrix
if (k == 1){
selectNonpositive(*phi,seg0,minx,maxx,miny,maxy,minz,maxz);
copyMatrixWithLimits(tmap,*seg0,minx,maxx,miny,maxy,minz,maxz);
findLimits(*tmap,offset,&minx,&maxx,&miny,&maxy,&minz,&maxz);
}
else if (k % 10 == 0){
selectNonpositive(*phi,&intTmp2,minx,maxx,miny,maxy,minz,maxz); // use the second temporarymatrix
updateMaps(tmap,intTmp2,*seg0,tmap_it,minx,maxx,miny,maxy,minz,maxz); // use the second temporarymatrix
copyMatrixWithLimits(seg0,intTmp2,minx,maxx,miny,maxy,minz,maxz); // use the second temporarymatrix
tmap_it++;
findLimits(*tmap,offset,&minx,&maxx,&miny,&maxy,&minz,&maxz);
}
}
selectNonpositive(*phi,seg0,0,dx-1,0,dy-1,0,dz-1);
//selectNonpositive(*phi,seg0,minx,maxx,miny,maxy,minz,maxz); ???? (consider this modification if there are more problems)
freeMatrixD(gradPhi);
freeMatrixD(dblTmp);
freeMatrix(intTmp2);
freeGlobals4bwdist(px,py,pz,qx,qy,qz,intTmp);
}
/*---------------------------------------------------------------------------
*
* Compute matrix product using recursive tiling.
*
* Input
* int argc - length of argv[] array
* char* argv[] - pointer to command line parameter array
* int verbosity - program verification: verbosity > 0 gives more output
* char* order - string indicating loop order, e.g., "ijk" or "jki"
*
* Output
* double - elapsed time for product computation
*/
double multiply_by_recursive_blocks( int argc, char* argv[], int verbosity,
char* order )
{
int rows, cols, mids, block_size;
double **a, **b, **c;
double t1, t2;
double sec;
double gflop_count;
/*
* process command line arguments
*/
rows = atoi( argv[0] );
mids = atoi( argv[1] );
cols = atoi( argv[2] );
block_size = atoi( argv[3] );
gflop_count = 2.0 * rows * mids * cols / 1.0e9;
if ( verbosity > 0 )
{
printf( "Recursive blocks(%3s): rows = %d, mids = %d, columns = %d\n",
order, rows, mids, cols );
printf( "block size = %d\n", block_size );
}
/*
* allocate and initialize matrices
*/
a = (double**) allocateMatrix( rows, mids );
b = (double**) allocateMatrix( mids, cols );
c = (double**) allocateMatrix( rows, cols );
initialize_matrices( a, b, c, rows, cols, mids, verbosity );
/*
* compute product
*/
t1 = wtime();
mm_rec( c, a, b, 0, 0, 0, 0, 0, 0, rows, mids, cols, cols, block_size );
t2 = wtime();
sec = t2 - t1;
if ( verbosity > 1 )
printf( "checksum = %f\n", checksum( c, rows, cols ) );
printf( "blocks(%3s): %6.3f secs %6.3f gflops ",
order, sec, gflop_count / sec );
printf( "( %5d x %5d x %5d ) ( %6d )\n", rows, mids, cols, block_size );
/*
* clean up
*/
deallocateMatrix( a );
deallocateMatrix( b );
deallocateMatrix( c );
return t2 - t1;
}
void levelSet3D(MATRIXD im, MATRIX init_mask, int max_its, double E, double T, double alpha,
MATRIX *seg0, MATRIX *tmap, MATRIXD *phi, long **ls_vols){
// some of these variables will be used as the local variables for other functions
// they are defined outside (like global variables) because we want to decrease the overhead
// corresponding to allocation and deallocation (since we have multiple calls for the same function
long dx = im.dx, dy = im.dy, dz = im.dz;
int *px, *py, *pz, *qx, *qy, *qz, k, tmap_it = 1;
MATRIX intTmp;
MATRIXD dblTmp = allocateMatrixD(dx,dy,dz);
MATRIXD gradPhi = allocateMatrixD(dx,dy,dz);
*phi = allocateMatrixD(dx,dy,dz);
*seg0 = allocateMatrix(dx,dy,dz);
*tmap = allocateMatrix(dx,dy,dz);
*ls_vols = (long *)calloc(max_its,sizeof(long)); // initialized with 0
initializeMatrix(tmap,0);
initializeGlobals4bwdist(dx,dy,dz,&px,&py,&pz,&qx,&qy,&qz,&intTmp);
createSignedDistanceMap(init_mask,phi,px,py,pz,qx,qy,qz,intTmp,dblTmp); // temps: intTmp, dblTmp
for (k = 1; k <= max_its; k++){
calculateCurvature(*phi,&dblTmp,0,dx-1,0,dy-1,0,dz-1); // dblTmp keeps the curvatures
calculateF(im,dblTmp,&dblTmp,E,T,alpha,0,dx-1,0,dy-1,0,dz-1); // first dblTmp (input): curvatures, second dblTmp (output): F values
calculateGradPhi(*phi,dblTmp,&gradPhi,0,dx-1,0,dy-1,0,dz-1);
evolveCurve(phi,dblTmp,gradPhi,0,dx-1,0,dy-1,0,dz-1);
if (k % 50 == 0)
reinitializeDistanceFunction(phi,init_mask,px,py,pz,qx,qy,qz,intTmp,dblTmp); // temps: init_mask, intTmp, dblTmp
(*ls_vols)[k-1] = selectNonpositive(*phi,&intTmp,0,dx-1,0,dy-1,0,dz-1);
if (k == 1){
selectNonpositive(*phi,seg0,0,dx-1,0,dy-1,0,dz-1);
copyMatrix(tmap,*seg0);
}
else if (k % 10 == 0){
selectNonpositive(*phi,&intTmp,0,dx-1,0,dy-1,0,dz-1);
updateMaps(tmap,intTmp,*seg0,tmap_it,0,dx-1,0,dy-1,0,dz-1);
copyMatrix(seg0,intTmp);
tmap_it++;
}
}
selectNonpositive(*phi,seg0,0,dx-1,0,dy-1,0,dz-1);
freeMatrixD(gradPhi);
freeMatrixD(dblTmp);
freeGlobals4bwdist(px,py,pz,qx,qy,qz,intTmp);
}
void imfillSobelPrimitives(MATRIX *sb, int minx, int maxx, int miny, int maxy){
MATRIX res = allocateMatrix(sb->row,sb->column);
int maxNo, *reached, i, j;
maxNo = connectedComponentsWithMask(*sb,0,minx,maxx,miny,maxy,0,FOUR,&res);
reached = (int *)calloc(maxNo+1,sizeof(int));
for (i = minx; i <= maxx; i++){
if (res.data[i][miny] >= 0)
reached[ res.data[i][miny] ] = 1;
if (res.data[i][maxy] >= 0)
reached[ res.data[i][maxy] ] = 1;
}
for (i = miny; i <= maxy; i++){
if (res.data[minx][i] >= 0)
reached[ res.data[minx][i] ] = 1;
if (res.data[maxx][i] >= 0)
reached[ res.data[maxx][i] ] = 1;
}
for (i = minx; i <= maxx; i++)
for (j = miny; j <= maxy; j++)
if ((sb->data[i][j] == 0) && (reached[ res.data[i][j] ] == 0))
sb->data[i][j] = 1;
free(reached);
freeMatrix(res);
}
void eliminateVerticalSmallPrimitives(MATRIX *sb, int minx, int maxx, int miny, int maxy, int wthr){ // sb --> 0 or 1
MATRIX res = allocateMatrix(sb->row,sb->column);
int maxNo = connectedComponentsWithMask(*sb,1,minx,maxx,miny,maxy,0,FOUR,&res);
int *topX = (int *)calloc(maxNo,sizeof(int));
int *bottomX = (int *)calloc(maxNo,sizeof(int));
int i, j;
for (i = 0; i < maxNo; i++){
topX[i] = maxx + 1;
bottomX[i] = minx - 1;
}
for (i = minx; i <= maxx; i++)
for (j = miny; j <= maxy; j++)
if (res.data[i][j] >= 0){
if (topX[ res.data[i][j] ] > i)
topX[ res.data[i][j] ] = i;
if (bottomX[ res.data[i][j] ] < i)
bottomX[ res.data[i][j] ] = i;
}
for (i = 0; i < maxNo; i++){
if (bottomX[i] - topX[i] <= wthr)
bottomX[i] = -1;
}
for (i = minx; i <= maxx; i++)
for (j = miny; j <= maxy; j++)
if ((res.data[i][j] >= 0) && (bottomX[ res.data[i][j] ] == -1))
sb->data[i][j] = 0;
free(topX);
free(bottomX);
freeMatrix(res);
}
void eliminateHorizontalSmallPrimitives(MATRIX *sb, int minx, int maxx, int miny, int maxy, int wthr){ // sb --> 0 or 1
MATRIX res = allocateMatrix(sb->row,sb->column);
int maxNo = connectedComponentsWithMask(*sb,1,minx,maxx,miny,maxy,0,FOUR,&res);
int *leftY = (int *)calloc(maxNo,sizeof(int));
int *rightY = (int *)calloc(maxNo,sizeof(int));
int i, j;
for (i = 0; i < maxNo; i++){
leftY[i] = maxy + 1;
rightY[i] = miny - 1;
}
for (i = minx; i <= maxx; i++)
for (j = miny; j <= maxy; j++)
if (res.data[i][j] >= 0){
if (leftY[ res.data[i][j] ] > j)
leftY[ res.data[i][j] ] = j;
if (rightY[ res.data[i][j] ] < j)
rightY[ res.data[i][j] ] = j;
}
for (i = 0; i < maxNo; i++){
if (rightY[i] - leftY[i] <= wthr)
rightY[i] = -1;
}
for (i = minx; i <= maxx; i++)
for (j = miny; j <= maxy; j++)
if ((res.data[i][j] >= 0) && (rightY[ res.data[i][j] ] == -1))
sb->data[i][j] = 0;
free(leftY);
free(rightY);
freeMatrix(res);
}
Matrix::Matrix(const std::vector<int>& topNumbers, const std::vector<int>& leftNumbers)
{
length = static_cast<int>(topNumbers.size()); // FIXME cast to int silences warning
width = static_cast<int>(leftNumbers.size());
allocateMatrix();
initialize(topNumbers, leftNumbers);
}
int multiplyMatrix(MatrixOfInt *matR, MatrixOfInt *matA, MatrixOfInt *matB){
int i;
int j;
if(matA->col != matB->row){
return FALSE;
}
matR->row = matA->row;
matR->col = matB->col;
if(!allocateMatrix(matR)){
return FALSE;
}
for(i = 0; i < matR->row; i++){
for(j = 0; j < matR->col; j++){
//definindo cada um dos elementos
//A linha atual tem a soma dos elementos de A
//Vezes a soma dos elementos da coluna atual de B.
*(*(matR->ptr + i) + j) = retornaMultiplicacaoDeLinhaComColunaDaOutra(matA, matB, i, j);
//printf("Elemento [%d][%d] = %d * %d ",i, j, retornaSomaDeLinha(matA, i), retornaSomaDeColuna(matB, j));
}
}
return TRUE;
}
FLMSettings::FLMSettings()
{
allocateMatrix();
allocateSplines();
mCorrMatrixLoaded = false;
activeConfig = 0;
}
int main(int argc, char *argv[]) {
int i, j;
int *p;
pthread_t *threads;
if (argc != 3) {
printf("Usage: %s <size> <n>, where size is dimension of square matrix, and n is number of threads\n", argv[0]);
exit(1);
}
matrixSize = atoi(argv[1]);
numThreads = atoi(argv[2]);
a = allocateMatrix();
b = allocateMatrix();
c = allocateMatrix();
for (i = 0; i < matrixSize; i++)
for (j = 0; j < matrixSize; j++) {
a[i][j] = i + j;
b[i][j] = i + j;
}
if (matrixSize < 10) {
printMatrix(a);
printMatrix(b);
}
// Allocate thread handles
threads = (pthread_t *) malloc(numThreads * sizeof(pthread_t));
// Create threads
for (i = 0; i < numThreads; i++) {
p = (int *) malloc(sizeof(int)); // yes, memory leak, don't worry for now
*p = i;
pthread_create(&threads[i], NULL, worker, (void *)(p));
}
for (i = 0; i < numThreads; i++) {
pthread_join(threads[i], NULL);
}
if (matrixSize < 10) // print matrix if relatively small
printMatrix(c);
}
MATRIX createMatrixFromData(int **data, int row, int column){
MATRIX res = allocateMatrix(row,column);
int i, j;
for (i = 0; i < row; i++)
for (j = 0; j < column; j++)
res.data[i][j] = data[i][j];
return res;
}
MATRIX matrixTranspose(MATRIX M){
MATRIX T = allocateMatrix(M.column,M.row);
int i, j;
for (i = 0; i < M.row; i++)
for (j = 0; j < M.column; j++)
T.data[j][i] = M.data[i][j];
return T;
}
int main (int argc, char ** argv)
{
if (argc != 3)
{
printf("Use: %s <N> <T>, onde 'N' é a dimensão da matriz unitária e 'T' é o número de threads.\n", argv[0]);
return 1;
}
//Retira valores dos argumentos passados pela linha de comando
matrix_size = atoi(argv[1]);
number_of_threads = atoi(argv[2]);
//Aloca espaço para variáveis e ponteiros para colunas
A = allocateMatrix(matrix_size);
//Gera matrizes A e B
generateMatrix(A, matrix_size);
//Imprime A e B (teste)
if (matrix_size < 20)
printMatrix(A, matrix_size, "A");
//Ponteiro com threads
pthread_t * p_threads;
//Alocação de espaço para threads de acordo com o número de threads
p_threads = (pthread_t *) malloc(number_of_threads * sizeof(pthread_t));
//Inicializa o mutex
pthread_mutex_init(&mut, NULL);
//Captura tempo inicial
clock_gettime(CLOCK_MONOTONIC, &initial_time);
//Criação de threads
createThreads(p_threads, number_of_threads, matrix_size, A);
//Join das threads
joinThreads(p_threads);
//Captura tempo final
clock_gettime(CLOCK_MONOTONIC, &end_time);
//imprime resultado
printf("A soma de todos os termos é: %d\n", sum);
//Calcula tempo final
double elapsed = end_time.tv_sec - initial_time.tv_sec;
elapsed += (end_time.tv_nsec - initial_time.tv_nsec) / 1000000000.0;
printf ("O tempo de processamento foi de: %f segundos\n", elapsed);
//Inicializa o mutex
pthread_mutex_destroy(&mut);
return 0;
}
void reallocateMatrix(MATRIX *M, long row, long column){
int i, j, minrow, mincol;
MATRIX tmp = allocateMatrix(M->row,M->column);
copyMatrix(&tmp,*M);
freeMatrix(*M);
*M = allocateMatrix(row,column);
initializeMatrix(M,0);
if (tmp.row > row) minrow = row;
else minrow = tmp.row;
if (tmp.column > column) mincol = column;
else mincol = tmp.column;
for (i = 0; i < minrow; i++)
for (j = 0; j < mincol; j++)
M->data[i][j] = tmp.data[i][j];
freeMatrix(tmp);
}
void initializeGlobals4bwdist(int dx, int dy, int dz, int **px, int **py, int **pz,
int **qx, int **qy, int **qz, MATRIX *labels){
long cnt = dx * dy * dz;
*px = (int *)calloc(cnt,sizeof(int));
*py = (int *)calloc(cnt,sizeof(int));
*pz = (int *)calloc(cnt,sizeof(int));
*qx = (int *)calloc(cnt,sizeof(int));
*qy = (int *)calloc(cnt,sizeof(int));
*qz = (int *)calloc(cnt,sizeof(int));
*labels = allocateMatrix(dx,dy,dz);
}
int main()
{
srand(time(NULL));
Matrix maze = {NULL, 0, 0};
Matrix fog = {NULL, 0, 0};
int width = 50, height = 40;
Position hero, exit;
allocateMatrix(&maze, width, height);
allocateMatrix(&fog, width, height);
generateMaze(maze, &hero, &exit);
generateFog(fog, hero);
runGame(maze, fog, exit, hero);
freeMatrix(&fog);
freeMatrix(&maze);
return 0;
}
char * mm(void)
{
int i, j, k;
double **a, **b, **c;
char *msg;
msg = (char*)malloc(5*sizeof(char));
a = allocateMatrix(NRA, NCA);
b = allocateMatrix(NCA, NCB);
c = allocateMatrix(NRA, NCB);
initialize(a, NRA, NCA);
initialize(b, NCA, NCB);
initialize(c, NRA, NCB);
for(i = 0; i < NRA; i++) {
for(k = 0; k < NCA; k++) {
for(j = 0; j < NCB; j++) {
c[i][j] = a[i][k]*b[k][j];
}
}
}
printf("C[0:4,0:4]=\n");
for(i = 0; i < 4; i++) {
for(j = 0; j < 4; j++)
printf("%f ", c[i][j]);
printf("\n");
}
freeMatrix(a, NRA, NCA);
freeMatrix(b, NCA, NCB);
freeMatrix(c, NRA, NCB);
msg = "done";
return msg;
}
MATRIX addMatrix(MATRIX A, MATRIX B){
long i, j;
MATRIX M;
if (A.row != B.row || A.column != B.column){
printf("\nError: Matrix dimensions mismatch in add operation\n");
exit(1);
}
M = allocateMatrix(A.row,A.column);
for (i = 0; i < M.row; i++)
for (j = 0; j < M.column; j++)
M.data[i][j] = A.data[i][j] + B.data[i][j];
return M;
}
int main() {
int n = 4;
int **matrix = allocateMatrix(n);
fillInMatrixValues(matrix);
Submatrix submatrix = computeLargestSumSubmatrix(matrix, n);
printf("Largest sum submatrix: \nx1 = %d\ny1 = %d\nx2 = %d\ny2 = %d\n", submatrix.startX, submatrix.startY, submatrix.stopX, submatrix.stopY);
deallocateMatrix(matrix, n);
return 0;
}
double do_work(void) {
double **a, /* matrix A to be multiplied */
**b, /* matrix B to be multiplied */
**c; /* result matrix C */
a = allocateMatrix(NRA, NCA);
b = allocateMatrix(NCA, NCB);
c = allocateMatrix(NRA, NCB);
/*** Spawn a parallel region explicitly scoping all variables ***/
initialize(a, NRA, NCA);
initialize(b, NCA, NCB);
initialize(c, NRA, NCB);
compute(a, b, c, NRA, NCA, NCB);
#if defined(TAU_OPENMP)
//if (omp_get_nested()) {
compute_nested(a, b, c, NRA, NCA, NCB);
//}
#endif
#ifdef TAU_MPI
if (provided == MPI_THREAD_MULTIPLE) {
printf("provided is MPI_THREAD_MULTIPLE\n");
} else if (provided == MPI_THREAD_FUNNELED) {
printf("provided is MPI_THREAD_FUNNELED\n");
}
#endif /* TAU_MPI */
compute_interchange(a, b, c, NRA, NCA, NCB);
double result = c[0][1];
freeMatrix(a, NRA, NCA);
freeMatrix(b, NCA, NCB);
freeMatrix(c, NCA, NCB);
return result;
}
MATRIX form2DMatrix(MATRIX M, int row, int column){
MATRIX newM;
int i, j, c;
if (row * column != M.row){
printf("\nError: dimensions mismatch\n\n");
exit(1);
}
newM = allocateMatrix(row,column);
c = 0;
for (i = 0; i < row; i++)
for (j = 0; j < column; j++)
newM.data[i][j] = M.data[c++][0];
return newM;
}
int* generateMatrix(int row, int column, int noinit)
{
int i, j, *m;
m = allocateMatrix(row, column);
if (!noinit) {
printf("Generating matrix...\n");
for (i=0; i<row; i++) {
for (j=0; j<column; j++) {
// m[i][j] = rand()%10;
// *A(m,column,i,j) = rand()%10;
*A(m,column,i,j) = j%10;
}
}
}
return m;
}
MATRIX readMatrix(char *filename){
MATRIX M;
long r, c, i, j;
FILE *id = fopen(filename,"r");
if (id == NULL){
printf("Error: File %s does not exist...\n",filename);
exit(1);
}
fscanf(id,"%ld%ld",&r,&c);
M = allocateMatrix(r,c);
for (i = 0; i < r; i++)
for (j = 0; j < c; j++)
fscanf(id,"%d",&(M.data[i][j]));
fclose(id);
return M;
}
int isMazeImposible(Matrix maze, Position exit)
{
Matrix mark;
allocateMatrix(&mark, maze.width, maze.height);
fillMatrixWithValue(mark, 0);
dfs(maze, mark, exit.x, exit.y);
for(int i = 0; i < maze.height; ++i)
for(int j = 0; j < maze.width; ++j)
if(maze.matrix[i][j] == 0 && mark.matrix[i][j] == 0)
{
freeMatrix(&mark);
return 1;
}
freeMatrix(&mark);
return 0;
}
int main(int argc, char **argv){
int row = atoi(argv[1]);
int col = atoi(argv[2]);
int sum = 0;
int **array = allocateMatrix(row, col);
initMatrix(array, row, col);
int i;
for (i=0; i<col; i++) {
sum+=array[row-1][i];
}
printf("The sum of the first number on each row is %d", sum);
return 0;
}
int* loadMatrix(char *filename, int row, int column)
{
int i, j, *m;
FILE *fp = fopen(filename, "r");
if (fp==NULL) {
printf("Error opening %s for reading\n", filename);
exit(1);
}
m = allocateMatrix(row, column);
printf("Loading matrix...\n");
for (i=0; i<row; i++) {
for (j=0; j<column; j++) {
// fscanf(fp, "%d", &m[i][j]);
fscanf(fp, "%d", A(m,row,i,j));
}
}
return m;
}
int* generateMatrix(int n, int noinit)
{
int i, j, *m;
m = allocateMatrix(n);
if (!noinit) {
printf("Generating matrix...\n");
for (i=0; i<n; i++) {
for (j=0; j<n; j++) {
// m[i][j] = rand()%10;
// *M(m,n,i,j) = rand()%10;
// Modulo 10 so that each number is only 1 digit -
// easy for displaying larger matrices on screen.
*M(m,n,i,j) = j%10;
// *(m+i*N+j)= rand()%10;
}
}
}
return m;
}
float* loadMatrix(char *filename, int n)
{
int i, j;
float *m;
FILE *fp = fopen(filename, "r");
if (fp==NULL) {
printf("Error opening %s for reading\n", filename);
exit(1);
}
m = allocateMatrix(n);
printf("Loading matrix...\n");
for (i=0; i<n; i++) {
for (j=0; j<n; j++) {
// fscanf(fp, "%d", &m[i][j]);
fscanf(fp, "%f", M(m,n,i,j));
}
}
return m;
}