LO27/LibAutomaton/matrix.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; /* should never happend */
		} 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; /* should never happend */
		} 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");
}

bool RecursiveFreeCol(Matrix matrix, cellElement * elem){
	cellElement * tmp = NULL;
	ListElement * Row = NULL;
	
	if (elem == NULL){
		return ERROR;
	}

	if (elem->nextRow != NULL){
		RecursiveFreeCol(matrix,elem->nextRow);
	}
	
	if (elem->nextRow == NULL){
	
		Row = GetElementPos(matrix.rows,elem->rowIndex);
	
		if (Row == NULL || Row->data == NULL ){
			return ERROR; /*should never happend*/
		}

		if (Row->data->colIndex == elem->colIndex){
			Row->data = NULL;
		} else {
			tmp = Row->data;
			while (tmp->nextCol != NULL && tmp->nextCol != elem){
				tmp = tmp->nextCol;
			}
			if (tmp->nextCol == NULL){
				return ERROR; /* should never happend */
			} else {
				tmp->nextCol = elem->nextCol;
			}
			
		}

		FreeCellElement(elem);
		return true;
	}

	return false; /* should never happend */
}



Matrix freeMatrix(Matrix matrix){
	ListElement * current = NULL;

	matrix.colCount = 0;
	matrix.rowCount = 0;
	/*il faut free les cellElements car FreeList ne peut pas le faire*/
	if (matrix.cols != NULL){
		current= matrix.cols->head;
		while (current != NULL){
			RecursiveFreeCol(matrix,current->data);
			current = current->next;
		}
	}
	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
*/