/* ========================================================================== */
/* */
/* */
/* proj3.c */
/* (c) 2001 xmunkf00 Filip Munk */
/* xmunkf00@stud.fit.vutbr.cz */
/* */
/*============================================================================*/
/* */
/* Vypocty s maticemi. */
/* Program dokaze vypocist soucet matice, sedlovy bod */
/* */
/* ========================================================================== */
//////////////////////////////////
//Pripojeni hlavickovych souboru//
//////////////////////////////////
#include <stdio.h>
#include <ctype.h>
#include <stdlib.h>
#include <string.h>
////////////////////////////////
//Konstanty a jine datove cosi//
////////////////////////////////
const char *FILEREAD="r";
/////////////////
//Text napovedy//
/////////////////
const char *HELP= "\nProgram pro vypocet matic (projekt 3).\n"
"Autor: Filip Munk (c) 2008\n\n"
"\t-h\tvytiskne tutu napovedu\n"
"\t-add [soubor1][soubor2]\tscitani dvou matic\n"
"\t-mult [soubor1][soubor2]\tnasobeni dvou matic\n"
"\t-expr [soubor1][soubor2]\tvyraz s dvemi maticemi"
"\t-peaks [soubor] vypise pocet spicek v matici"
;
////////////////////////////////////
//Texty Error hlasek a jejich kody//
////////////////////////////////////
#define TRUE 0
#define FALSE 1
enum errorCodes
{
ERR_NO_ERROR
,ERR_HEAD
,ERR_NO_FILE
,ERR_BAD_MATRIX
,ERR_NO_FILE_NAME
,ERR_EMPTY_FILE
,ERR_MEMORY
,ERR_BAD_MATRIX_SIZE
,ERR_BAD_ARG
,ERR_BAD_SIZE_FOR_MULT
,ERR_BAD_MATRIX_INPUT_SIZE
,ERR_NO_MORE_NUM
};
enum anyTextCodes
{
TXT_TRUE
,TXT_FALSE
};
//------------------------------//
const char * ANY_TEXT[] =
{
"True"
,"False"
,""
};
const char * ERROR_TEXT[] =
{
""
,"\nERROR:\n"
,"Zadany soubor neexistuje."
,"Neplatna velikost matice."
,"Nebyl zadan nazev souboru."
,"Soubor je zrejme prazdny."
,"Chya pri alokaci pametu."
,"Matice musi byt stejne velke."
,"Chyba v argumentech programu."
,"Tyto dve matice neni mozne nasobit kvuli nevhodne velikosti."
,"Neplatne zadani velikosti matice!"
,"V souboru s matici neni spravny pocet clenu pro zadanou velikost"
};
///////////////////////////////////////
//Moznosti pouziti funkci any_print()//
///////////////////////////////////////
#define NN 0
enum anyPrintCodes
{
PRINT_ERROR
,PRINT_TEXT
,PUT_CHAR
,PRINT_HELP
,PRINT_INT
,WRITE_LINE
};
////////////////////////////////////
//Definice vlastnich datovych typu//
////////////////////////////////////
typedef struct mat
{
int rows;
int cols;
int **matrix;
int error_code;
} Tmatrix;
/////////////////////////////////////////
//Fukce pro ruzne druhy tisku na vystup//
/////////////////////////////////////////
void any_print(int how, int what)
{
switch (how)
{
case PRINT_ERROR: //tiskne ERROR na stderr z konstanty ERROR_TEXT
fprintf(stderr,"%s",ERROR_TEXT[ERR_HEAD]);
fprintf(stderr,"%s",ERROR_TEXT[what]);
any_print(WRITE_LINE,NN);
break;
case PUT_CHAR: //tiskne znak zadaneho ASCII kodu
putchar(what);
break;
case PRINT_HELP: //tiskne napovedu
printf("%s",HELP);
break;
case PRINT_INT: //tiskne cislo
printf("%d", what);
break;
case WRITE_LINE: //vlozi dalsi radku
putchar('\n');
break;
case PRINT_TEXT: //tiskne text na stdout z konstanty ANY_TEXT
printf("%s",ANY_TEXT[what]);
any_print(WRITE_LINE,NN);
break;
}
}
int check_error(int error)
{
if (error== ERR_NO_ERROR) return TRUE;
return FALSE;
}
Tmatrix clean_matrix(Tmatrix matrix)
{
int col=0;
int row=0;
while (col<matrix.cols)
{
while (row<matrix.rows)
{
matrix.matrix[row][col]=0;
row++;
}
col++;
row=0;
}
return matrix;
}
Tmatrix alloc_matrix(Tmatrix matrix)
{
matrix.matrix = (int **) malloc(matrix.rows*sizeof(int*));
if (matrix.matrix == NULL)
{
matrix.error_code=ERR_MEMORY;
}
for (int i = 0; i < matrix.rows; i++)
{
matrix.matrix[i] =(int *) malloc(matrix.cols*sizeof(int));
if (matrix.matrix[i] == NULL)
{
i=matrix.rows;
matrix.error_code=ERR_MEMORY;
;}
}
if(check_error(matrix.error_code)==TRUE) matrix=clean_matrix(matrix);
return matrix;
}
void print_matrix(Tmatrix matrix)
{
int col=0;
int row=0;
while (col<matrix.cols)
{
while (row<matrix.rows)
{
any_print(PRINT_INT, matrix.matrix[row][col]);
any_print(PUT_CHAR,'\t');
row++;
}
col++;
row=0;
any_print(WRITE_LINE,NN);
}
}
///////////////////////////////////////////////////////
//Nacteni matice ze souboru. parametr - nazev souboru//
///////////////////////////////////////////////////////
Tmatrix read_matrix(char *fileName)
{
FILE * fofr;
Tmatrix matrix = {.matrix= NULL};
int row=0;
int col=0;
fofr=fopen(fileName, FILEREAD);
if (fofr!=NULL)
{
fscanf(fofr,"%d %d",&matrix.rows, &matrix.cols);
matrix=alloc_matrix(matrix);
while (col<matrix.cols)
{
while (row<matrix.rows)
{
fscanf(fofr,"%d", &matrix.matrix[row][col]);
row++;
}
col++;
row=0;
}
}
else
{
matrix.error_code=ERR_NO_FILE;
}
//free(matrix.matrix);
return matrix;
}
//////////////////
//Nasobeni matic//
//////////////////
Tmatrix mult_matrix(Tmatrix matrixA, Tmatrix matrixB)
{
int rowA=0;
int colA=0;
int rowB=0;
int colB=0;
int rowC=0;
int colC=0;
Tmatrix matrixC={.error_code=0};
if (matrixA.cols==matrixB.rows)
{
matrixC.cols=matrixA.cols;
matrixC.rows=matrixB.rows;
matrixC=alloc_matrix(matrixC);
while (colC<matrixC.cols)
{
while (rowC<matrixC.rows)
{
while (rowA<matrixB.cols)
{
matrixC.matrix[rowC][colC]+=matrixB.matrix[rowB][colB]*matrixA.matrix[rowA][colA];
colB++;
rowA++;
}
colB=0;
rowA=0;
rowB++;
rowC++;
}
rowB=0;
rowC=0;
colC++;
colA++;
}
}
else matrixC.error_code=ERR_BAD_SIZE_FOR_MULT;
return matrixC;
}
/////////////////
//Scitani matic//
/////////////////
Tmatrix add_matrix(Tmatrix matrixA, Tmatrix matrixB)
{
Tmatrix matrixC = {.matrix=NULL};
int col=0;
int row=0;
if (matrixA.rows== matrixB.rows && matrixA.cols==matrixB.cols)
{
matrixC.rows=matrixB.rows;
matrixC.cols=matrixA.cols;
matrixC=alloc_matrix(matrixC);
while (col<matrixC.cols)
{
while (row<matrixC.rows)
{
matrixC.matrix[row][col]=matrixA.matrix[row][col]+matrixB.matrix[row][col];
row++;
}
col++;
row=0;
}
}
else
{
matrixC.error_code=ERR_BAD_MATRIX_SIZE;
matrixC.matrix =NULL;
}
return matrixC;
}
////////////////////
//Dealokace matice//
////////////////////
void dealloc_matrix(Tmatrix matrix)
{
if (matrix.matrix == NULL) matrix.error_code=ERR_MEMORY;
for (int i = 0; i < matrix.rows; i++)
{
free(matrix.matrix[i]);
}
free(matrix.matrix);
}
///////////////
//Sedlovy bod//
///////////////
int saddle_point(Tmatrix matrix)
{
int result=FALSE;
int minrow=0;
int maxcol=0;
int row= 0;
int col=0;
int maxinrow=0;
int maxincol=0;
int mininrow=0;
int minincol=0;
int colc=0;
maxcol=matrix.matrix[row][col];
minrow=matrix.matrix[row][col];
while(colc<matrix.cols)
{
while(row< matrix.cols){
if(minrow>matrix.matrix[row][colc]){
minrow=matrix.matrix[row][colc];
mininrow=row;
minincol=col;
}
row++;
}
row=mininrow;
col=0;
while(col< matrix.cols)
{
if(maxcol<matrix.matrix[row][col]){
maxcol=matrix.matrix[row][col];
maxinrow=row;
maxincol=col;
}
col++;
}
any_print(WRITE_LINE,NN);
any_print(WRITE_LINE,NN);
any_print(PRINT_INT, mininrow);
any_print(PRINT_INT, minincol);
any_print(WRITE_LINE,NN);
any_print(PRINT_INT, maxinrow);
any_print(PRINT_INT, maxincol);
any_print(WRITE_LINE,NN);
any_print(WRITE_LINE,NN);
colc++;
row=0;
col=0;
minrow=matrix.matrix[row][colc];
maxcol=matrix.matrix[row][colc];
maxincol=0;
maxinrow=0;
mininrow=0;
minincol=0;
}
result=maxcol;
return result;
}
///////////////////
//Spicky v matici//
///////////////////
int peaks_matrix(Tmatrix matrixA)
{
int count=0;
int row=0;
int col=0;
Tmatrix matrixB= {.matrix=NULL};
matrixB.rows=matrixA.rows+2;
matrixB.cols=matrixA.cols+2;
matrixB=alloc_matrix(matrixB);
row=matrixB.rows-1;
while (col<matrixB.cols)
{
matrixB.matrix[row][col]=-2147483647;
col++;
}
col=0;
row=0;
while (col<matrixB.cols)
{
matrixB.matrix[row][col]=-2147483647;
col++;
}
///////////////////////////////////////////////
row=0;
col=matrixB.cols-1;
while (row<matrixB.rows)
{
matrixB.matrix[row][col]=-2147483647;
row++;
}
row=0;
col=0;
while (row<matrixB.rows)
{
matrixB.matrix[row][col]=-2147483647;
row++;
}
col=0;
row=0;
while (col<matrixA.cols)
{
while (row<matrixA.rows)
{
matrixB.matrix[row+1][col+1]=matrixA.matrix[row][col];
row++;
}
row=0;
col++;
}
col=0;
row=0;
while (col<matrixA.cols)
{
while (row<matrixA.rows)
{
if (matrixB.matrix[row][col]<matrixB.matrix[row+1][col+1]
&& matrixB.matrix[row][col+1]<matrixB.matrix[row+1][col+1]
&& matrixB.matrix[row+1][col]<matrixB.matrix[row+1][col+1]
&& matrixB.matrix[row+2][col+1]<matrixB.matrix[row+1][col+1]
&& matrixB.matrix[row+1][col+2]<matrixB.matrix[row+1][col+1]
&& matrixB.matrix[row+2][col+2]<matrixB.matrix[row+1][col+1]
&& matrixB.matrix[row][col+2]<matrixB.matrix[row+1][col+1]
&& matrixB.matrix[row+2][col]<matrixB.matrix[row+1][col+1])
{
count++;
}
row++;
}
row=0;
col++;
}
dealloc_matrix(matrixB);
return count;
}
//////////////
//expr_matic//
//////////////
Tmatrix expr_matrix(Tmatrix matrixA, Tmatrix matrixB)
{
Tmatrix matrixC;
matrixC.rows=matrixA.rows;
matrixC.cols=matrixA.cols;
//matrixC=alloc_matrix(matrixC);
matrixC=mult_matrix(matrixA,matrixB);
return add_matrix(matrixC,matrixC);
}
//////////////////////////////////////
//Prepinani podle zadanych argumentu//
//////////////////////////////////////
int main(int argc, char *argv[])
{
Tmatrix matrixA ={.matrix=NULL};
Tmatrix matrixB ={.matrix=NULL};
Tmatrix matrixC ={.matrix=NULL};
int count;
if (argc==4 && (strcmp(argv[1],"-add")==TRUE || strcmp(argv[1],"-mult")==TRUE|| strcmp(argv[1],"-expr")==TRUE))
{
if (strcmp(argv[1],"-add")==TRUE)
{
matrixA=read_matrix(argv[2]);
matrixB=read_matrix(argv[3]);
if (matrixA.matrix!=NULL && matrixB.matrix !=NULL)
{
matrixC=add_matrix(matrixA,matrixB);
if (check_error(matrixC.error_code)==TRUE)
{
print_matrix(matrixC);
}
else
{
any_print(PRINT_ERROR,matrixC.error_code);
}
}
}
if (strcmp(argv[1],"-mult")==TRUE)
{
matrixA=read_matrix(argv[2]);
matrixB=read_matrix(argv[3]);
if (matrixA.matrix!=NULL && matrixB.matrix !=NULL)
{
matrixC=mult_matrix(matrixA, matrixB);
if (check_error(matrixC.error_code)==TRUE)
{
print_matrix(matrixC);
}
else
{
any_print(PRINT_ERROR,matrixC.error_code);
}
}
}
if (strcmp(argv[1],"-expr")==TRUE)
{
matrixA=read_matrix(argv[2]);
matrixB=read_matrix(argv[3]);
if (matrixA.matrix!=NULL && matrixB.matrix !=NULL)
{
matrixC=expr_matrix(matrixA, matrixB);
if (check_error(matrixC.error_code)==TRUE)
{
print_matrix(matrixC);
}
else
{
any_print(PRINT_ERROR,matrixC.error_code);
}
}
}
}
else if (argc==3 && (strcmp(argv[1],"-peaks")==TRUE
|| strcmp(argv[1],"-saddle")==TRUE
))
{
if (strcmp(argv[1], "-peaks")==TRUE)
{
matrixA=read_matrix(argv[2]);
if (matrixA.matrix!=NULL && check_error(matrixA.error_code==TRUE))
count=peaks_matrix(matrixA);
any_print(PRINT_INT,count);
any_print(WRITE_LINE,NN);
}
else
{
any_print(PRINT_ERROR,matrixC.error_code);
}
if (strcmp(argv[1], "-saddle")==TRUE)
{
matrixA=read_matrix(argv[2]);
count=saddle_point(matrixA);
//any_print(PRINT_INT,count);
}
if (strcmp(argv[1], "-drot")==TRUE)
{}
if (strcmp(argv[1], "-plought")==TRUE)
{}
}
else if (argc < 3)
{
if (strcmp(argv[1], "-h")==TRUE)
{
any_print(PRINT_HELP,NN);
}
else
{
any_print(PRINT_ERROR,ERR_BAD_ARG);
}
}
dealloc_matrix(matrixA);
dealloc_matrix(matrixB);
dealloc_matrix(matrixC);
return EXIT_SUCCESS;
}
/////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////
//#############################################################//
//##################!! konec proj3.c !!#######################//
//#############################################################//
/////////////////////////////////////////////////////////////////
