mirror of
https://gitlab.com/klmp200/LO27.git
synced 2024-10-31 23:48:04 +00:00
265 lines
5.1 KiB
C
265 lines
5.1 KiB
C
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <matrix.h>
|
|
|
|
Matrix applyRules (Matrix matrix,int Rules, int N){
|
|
int power = 2;
|
|
int i = 0;
|
|
if (Rules <= 0){
|
|
return matrix;
|
|
} else {
|
|
while (Rules%power == 0 ){
|
|
power*=2;
|
|
}
|
|
for (i=0;i<N;i++){
|
|
printf("Apply rule %d \n",Rules%power);
|
|
/*Replace it by the implementation of the rules*/
|
|
}
|
|
|
|
applyRules(matrix,Rules - Rules%power,N);
|
|
}
|
|
return matrix;
|
|
}
|
|
|
|
Matrix CreateMatrix(){
|
|
Matrix matrix;
|
|
matrix.colCount = 0;
|
|
matrix.rowCount = 0;
|
|
matrix.cols = CreateList();
|
|
matrix.rows = CreateList();
|
|
return matrix;
|
|
}
|
|
|
|
Matrix SetMatrixDim(Matrix matrix,int nbCols,int nbRows){
|
|
matrix.colCount = nbCols;
|
|
matrix.rowCount = nbRows;
|
|
return matrix;
|
|
}
|
|
|
|
bool CreateMatrixElem(Matrix matrix, int ColPos, int RowPos){
|
|
ListElement * Row = NULL;
|
|
ListElement * Col = NULL;
|
|
int error = 0;
|
|
cellElement * elem = NULL;
|
|
cellElement * tmp = NULL;
|
|
|
|
if (matrix.colCount <= ColPos || matrix.rowCount <= RowPos ){
|
|
return ERROR;
|
|
}
|
|
elem = CreateCellElem();
|
|
SetPositionIndex(elem,ColPos,RowPos);
|
|
|
|
Row = GetElementPos(matrix.rows,RowPos);
|
|
if (Row != NULL && Row->data != NULL){
|
|
|
|
if (Row->data->colIndex == ColPos){
|
|
error ++;
|
|
} else if (Row->data->colIndex > ColPos){
|
|
elem->nextCol = Row->data;
|
|
Row->data = elem;
|
|
} else {
|
|
tmp = Row->data;
|
|
while (tmp->nextCol != NULL && tmp->nextCol->colIndex < ColPos){
|
|
tmp=tmp->nextCol;
|
|
}
|
|
if (tmp->nextCol == NULL || tmp->nextCol->colIndex > ColPos){
|
|
elem->nextCol = tmp->nextCol;
|
|
tmp->nextCol = elem;
|
|
}else {
|
|
error ++;
|
|
}
|
|
}
|
|
|
|
}else {
|
|
push(matrix.rows,elem);
|
|
matrix.rows->tail->pos = RowPos;
|
|
}
|
|
|
|
Col = GetElementPos(matrix.cols,ColPos);
|
|
if (Col != NULL && Col->data != NULL){
|
|
|
|
if (Col->data->rowIndex == RowPos){
|
|
error ++;
|
|
} else if (Col->data->rowIndex > RowPos){
|
|
elem->nextRow = Col->data;
|
|
Col->data = elem;
|
|
} else {
|
|
tmp = Col->data;
|
|
while (tmp->nextRow != NULL && tmp->nextRow->rowIndex < RowPos){
|
|
tmp=tmp->nextRow;
|
|
}
|
|
if (tmp->nextRow == NULL || tmp->nextRow->rowIndex > RowPos){
|
|
elem->nextRow = tmp->nextRow;
|
|
tmp->nextRow = elem;
|
|
}else {
|
|
error ++;
|
|
}
|
|
}
|
|
|
|
}else {
|
|
push(matrix.cols,elem);
|
|
matrix.cols->tail->pos = ColPos;
|
|
}
|
|
|
|
|
|
if (error != 0){
|
|
FreeCellElement(elem);
|
|
return true;
|
|
}else{
|
|
return false;
|
|
}
|
|
|
|
}
|
|
|
|
cellElement * FindMatrixElem(Matrix matrix, int ColPos, int RowPos){
|
|
ListElement * Row = NULL;
|
|
cellElement * elem = NULL;
|
|
|
|
Row = GetElementPos(matrix.rows,RowPos);
|
|
if (Row == NULL){
|
|
return NULL;
|
|
}
|
|
elem = Row->data;
|
|
|
|
while (elem != NULL && elem->colIndex != ColPos){
|
|
elem = elem->nextCol;
|
|
}
|
|
|
|
return elem;
|
|
}
|
|
|
|
int SupprMatrixElem(Matrix matrix, int ColPos, int RowPos){
|
|
cellElement * elem = NULL;
|
|
cellElement * tmp = NULL;
|
|
|
|
ListElement * Row = NULL;
|
|
ListElement * Col = NULL;
|
|
|
|
elem = FindMatrixElem(matrix,ColPos,RowPos);
|
|
if (elem == NULL){
|
|
return 0;
|
|
}
|
|
|
|
Row = GetElementPos(matrix.rows,RowPos);
|
|
if (Row == NULL){
|
|
return -1;
|
|
}
|
|
if (Row->data == NULL){
|
|
RemoveElementPos(matrix.rows,RowPos);
|
|
return -1;
|
|
}
|
|
|
|
if (Row->data->colIndex == ColPos){
|
|
Row->data = elem->nextCol;
|
|
} else {
|
|
tmp = Row->data;
|
|
while (tmp->nextCol != NULL && tmp->nextCol != elem){
|
|
tmp = tmp->nextCol;
|
|
}
|
|
if (tmp->nextCol == NULL){
|
|
return -3; /* WTF ?? */
|
|
} else {
|
|
tmp->nextCol = elem->nextCol;
|
|
}
|
|
|
|
}
|
|
if (Row->data == NULL){
|
|
RemoveElementPos(matrix.rows,RowPos);
|
|
}
|
|
|
|
|
|
Col = GetElementPos(matrix.cols,ColPos);
|
|
if (Col == NULL){
|
|
return -2;
|
|
}
|
|
if (Col->data == NULL){
|
|
RemoveElementPos(matrix.cols,ColPos);
|
|
return -1;
|
|
}
|
|
if (Col->data->rowIndex == RowPos){
|
|
Col->data = elem->nextRow;
|
|
} else {
|
|
tmp = Col->data;
|
|
while (tmp->nextRow != NULL && tmp->nextRow != elem){
|
|
tmp = tmp->nextRow;
|
|
}
|
|
if (tmp->nextRow == NULL){
|
|
return -4; /* WTF ?? */
|
|
} else {
|
|
tmp->nextRow = elem->nextRow;
|
|
}
|
|
}
|
|
if (Col->data == NULL){
|
|
RemoveElementPos(matrix.cols,ColPos);
|
|
}
|
|
|
|
FreeCellElement(elem);
|
|
return 1;
|
|
|
|
}
|
|
|
|
bool GetCellValue(Matrix matrix, int ColPos, int RowPos){
|
|
if (matrix.colCount <= ColPos || matrix.rowCount <= RowPos){
|
|
return ERROR;
|
|
}
|
|
|
|
if (FindMatrixElem(matrix,ColPos,RowPos) == NULL){
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool SetCellValue(Matrix matrix, int ColPos, int RowPos,bool value){
|
|
if (value == true){
|
|
return CreateMatrixElem(matrix,ColPos,RowPos);
|
|
}else{
|
|
if ( SupprMatrixElem(matrix,ColPos,RowPos) >= 0 ){
|
|
return true;
|
|
}else{
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
void BasicPrintMatrix(Matrix matrix){
|
|
/* Non optimisé : debug fx */
|
|
int i = 0;
|
|
int j = 0;
|
|
|
|
printf("\n---PRINT MATRIX---\n");
|
|
|
|
for (i=0;i<matrix.colCount;i++){
|
|
printf("| ");
|
|
for (j=0;j<matrix.rowCount;j++){
|
|
|
|
if (GetCellValue(matrix,i,j) == true){
|
|
printf("1 ");
|
|
}else if (GetCellValue(matrix,i,j) == false){
|
|
printf("0 ");
|
|
}else{
|
|
printf("X "); /* error out of bounds, should never happend*/
|
|
}
|
|
|
|
}
|
|
printf("|\n");
|
|
|
|
}
|
|
|
|
printf("---END OF MATRIX---\n\n");
|
|
}
|
|
|
|
Matrix freeMatrix(Matrix matrix){
|
|
matrix.colCount = 0;
|
|
matrix.rowCount = 0;
|
|
/*il faut free les cellElements car FreeList ne peut pas le faire*/
|
|
FreeList(matrix.cols);
|
|
FreeList(matrix.rows);
|
|
return matrix;
|
|
}
|
|
|
|
/* todos :
|
|
*finir le freeMatrix
|
|
*chasser les bugs
|
|
*ecrire doc
|
|
*faire un print + opti pour que sli l'adapte avec sdl
|
|
*/ |