LO27/LibMatrix/matrix.h

/*
 * This is a cellular automaton library
 *
 * Copyright (C) 2016-2017 Antoine BARTUCCIO, Jean POREE DE RIDDER
 *
 * Licensed under the MIT License,(the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * hhttps://opensource.org/licenses/MIT
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 *
 */

#ifndef MTRXGAUD_H
#define MTRXGAUD_H

#include <CellElement.h>
#include <list.h>

/**
* Abstract type that describe a boolean matrix
*
* @param colCount is the number of columns of the matrix
* @param rowIndex is the number of rows of the matrix
*
* @param rows is pointer on the first row that contains a true value
* @param cols is pointer on the first col that contains a true value
* 
* @see createMatrix to allocate one
* @see freeMatrix to free one
*/
typedef struct Matrix {

	int colCount;
	int rowCount;

	List *cols;
	List *rows;

}Matrix;


/**
* Abstract type for a matrix of booleans
*
* @param rows number of rows of the matrix
* @param cols numbers of columns of the matrix
* @param data the matrix
*
* @see createBooleanMatrix to create one
*/
typedef struct {
	int rows;
	int cols;

	bool **data;

} BooleanMatrix;

/**
* Function creating an empty boolean matrix
*
* @param cols number of cols
* @param rows number of rows
*
* @return booleanmatrix a new matrix
*/
BooleanMatrix createBooleanMatrix(int cols, int rows);

/**
* Randomize a BooleanMatrix
*
* @param matrix a BooleanMatrix
*
* @return booleanmatrix the processed matrix
*/
BooleanMatrix randomizeBooleanMatrix(BooleanMatrix matrix);

/**
* Free a BooleanMatrix
*
* @param matrix a BooleanMatrix
*/
void freeBooleanMatrix(BooleanMatrix matrix);

/**
* Create a Matrix from its array-based representation
*
* @param bmatrix BooleanMatrix
*
* @return m Matrix
*/
Matrix newMatrix(BooleanMatrix bmatrix);

/*---applyRules---
* A function that allows you to apply some rules n times on the matrix and returns it
*
* @param matrix is a matrix on whitch you would apply the rules
* @param Rules is an integer describing the rules
* @param N is the number of time the rules will be applied
*
* @return Matrix
*/
Matrix applyRules(Matrix matrix,int Rules, int N);

/**
* Create a void Matrix
*
* @return a matrix
*
*/
Matrix createMatrix();

/**
* Find and return the cell in the given matrix
*
* @param matrix the Matrix where we search
* @param ColPos an int indicating the column of the cell
* @param RowPos an int indicating the row of the cell
*
* @return a cellElement
*
*/
cellElement * findMatrixElem(Matrix matrix, int ColPos, int RowPos);

/**
* Create the cell in the given matrix
*
* @param matrix the Matrix 
* @param ColPos an int indicating the column of the cell
* @param RowPos an int indicating the row of the cell
*
* @return a bool (error code)
*
*/
bool createMatrixElem(Matrix matrix, int ColPos, int RowPos);

/**
* Delete the cell in the given matrix
*
* @param matrix the Matrix 
* @param ColPos an int indicating the column of the cell
* @param RowPos an int indicating the row of the cell
*
* @return an error code (int)
*
*/
int deleteMatrixElem(Matrix matrix, int ColPos, int RowPos);

/**
* Delete or create the cell in the given matrix to fit the value
*
* @param matrix the Matrix 
* @param ColPos an int indicating the column of the cell
* @param RowPos an int indicating the row of the cell
*
* @return an error code (bool)
*
*/
bool setCellValue(Matrix matrix, int ColPos, int RowPos, bool value);

/**
* Checks out the value of the cell in the given matrix
*
* @param matrix the Matrix 
* @param ColPos an int indicating the column of the cell
* @param RowPos an int indicating the row of the cell
*
* @return the value (bool)
*
*/
bool getCellValue(Matrix matrix, int ColPos, int RowPos);

/**
* Set the number of columns and rows of the matrix and returns it
*
* @param matrix the Matrix 
* @param nbCols an int indicating the number of columns
* @param nbRows an int indicating the number of rows
*
* @return the matrix
*
*/
Matrix setMatrixDim(Matrix matrix,int nbCols,int nbRows);

/**
* Basically print the Matrix in the standard output
*
* @param matrix the Matrix
*
*/
void printMatrix(Matrix matrix);

/**
* Allows you to free a Matrix
*
* @param matrix is the Matrix you want to free
*
* @return Matrix non allocated
*/
Matrix freeMatrix(Matrix matrix);

/**
* Given an input matrix with M rows and N columns, computes a matrix with
*  M rows and N-1 columns were each element corresponds to the operator boolean operation
*  between two successive horizontal elements in the input matrix
* 
* @param m a Matrix
* @param operator a function
*
* @return Matrix the copmuted matrix
*/
Matrix colSequenceOnMatrix(Matrix m, bool (operator)(bool, bool));

/**
* Given an input matrix with M rows and N columns, computes a matrix with
*  M-1 rows and N columns were each element corresponds to the operator boolean operation
*  between two succesive vertical elements in the input matrix
*
* @param m a Matrix
* @param operator a function
*
* @return Matrix the copmuted matrix
*/
Matrix rowSequenceOnMatrix(Matrix m, bool (operator)(bool, bool));

/**
* Given an input matrix with M rows and N columns, computes a matrix with
*  M rows and N-1 columns were each element corresponds to the AND boolean operation
*  between two successive horizontal elements in the input matrix
*
* @param m a Matrix
*
* @return Matrix the copmuted matrix
*/
Matrix andColSequenceOnMatrix(Matrix m);

/**
* Given an input matrix with M rows and N columns, computes a matrix with
*  M rows and N-1 columns were each element corresponds to the OR boolean operation
*  between two successive horizontal elements in the input matrix
*
* @param m a Matrix
*
* @return Matrix the copmuted matrix
*/
Matrix orColSequenceOnMatrix(Matrix m);

/**
* Given an input matrix with M rows and N columns, computes a matrix with
*  M-1 rows and N columns were each element corresponds to the AND boolean operation
*  between two succesive vertical elements in the input matrix
*
* @param m a Matrix
*
* @return Matrix the copmuted matrix
*/
Matrix andRowSequenceOnMatrix(Matrix m);

/**
* Given an input matrix with M rows and N columns, computes a matrix with
*  M-1 rows and N columns were each element corresponds to the OR boolean operation
*  between two succesive vertical elements in the input matrix
*
* @param m a Matrix
*
* @return Matrix the copmuted matrix
*/
Matrix orRowSequenceOnMatrix(Matrix m);

/**
* Apply a given set of rules
*
* @param m a matrix
* @param n the number of rules
* @param rules an array of rules
*
* @return Matrix a new modified matrix
*/
Matrix matrixFromRules(Matrix m, int n, int rules[]);

/**
* Apply XOR to a given number of bools
*
* @param n the number of bools
* @param bools an array of bool
*
* @return bool the processed bool
*/
bool MXOR(int n, bool bools[]);

/**
* Get a cell with first rule
*
* @param m a matrix
* @param ColPos collumn pos of the current cell
* @param RowPos row pos of the current cell
*
* @return bool the value of the cell got by the rule
*/
bool firstRule(Matrix m, int ColPos, int RowPos);

/**
* Get a cell with right rule
*
* @param m a matrix
* @param ColPos collumn pos of the current cell
* @param RowPos row pos of the current cell
*
* @return bool the value of the cell got by the rule
*/
bool rightRule(Matrix m, int ColPos, int RowPos);

/**
* Get a cell with left rule
*
* @param m a matrix
* @param ColPos collumn pos of the current cell
* @param RowPos row pos of the current cell
*
* @return bool the value of the cell got by the rule
*/
bool leftRule(Matrix m, int ColPos, int RowPos);

/**
* Get a cell with top rule
*
* @param m a matrix
* @param ColPos collumn pos of the current cell
* @param RowPos row pos of the current cell
*
* @return bool the value of the cell got by the rule
*/
bool topRule(Matrix m, int ColPos, int RowPos);

/**
* Get a cell with bottom rule
*
* @param m a matrix
* @param ColPos collumn pos of the current cell
* @param RowPos row pos of the current cell
*
* @return bool the value of the cell got by the rule
*/
bool bottomRule(Matrix m, int ColPos, int RowPos);

/**
* Get a cell with top_left rule
*
* @param m a matrix
* @param ColPos collumn pos of the current cell
* @param RowPos row pos of the current cell
*
* @return bool the value of the cell got by the rule
*/
bool topLeftRule(Matrix m, int ColPos, int RowPos);

/**
* Get a cell with top_right rule
*
* @param m a matrix
* @param ColPos collumn pos of the current cell
* @param RowPos row pos of the current cell
*
* @return bool the value of the cell got by the rule
*/
bool topRightRule(Matrix m, int ColPos, int RowPos);

/**
* Get a cell with bottom_left rule
*
* @param m a matrix
* @param ColPos collumn pos of the current cell
* @param RowPos row pos of the current cell
*
* @return bool the value of the cell got by the rule
*/
bool bottomLeftRule(Matrix m, int ColPos, int RowPos);

/**
* Get a cell with bottom_right rule
*
* @param m a matrix
* @param ColPos collumn pos of the current cell
* @param RowPos row pos of the current cell
*
* @return bool the value of the cell got by the rule
*/
bool bottomRightRule(Matrix m, int ColPos, int RowPos);

/**
* Get a list of bool from a given set of rules
*
* @param m a Matrix
* @param ColPos colon position of the point
* @param RowPos colon position of the point
* @param n number of rules
* @param rules[] an array of rules
*
* @return bool[] an array of bool
*/
bool * getFromRules(Matrix m, int ColPos, int RowPos, int n, int rules[]);

/**
* Allows you to use boolean operators between two matrices
*
* @param matrix1 the first matrix you want to operate on
* @param matrix2 the second matrix you want to operate on
* @param operator the function operator you want to use
*
* @return Matrix 
*/
Matrix opMatrix(Matrix matrix1,Matrix matrix2,bool (operator)(bool, bool));

/**
* Allows you to add two Matrices
*
* @param matrix1 the first matrix you want to add
* @param matrix2 the second matrix you want to add
*
* @return Matrix the sum
*/
Matrix sumMatrix(Matrix matrix1,Matrix matrix2);


/**
* Allows you to multiply two Matrices (with the AND operator)
*
* @param matrix1 the first matrix you want to multiply
* @param matrix2 the second matrix you want to multiply
*
* @return Matrix the product
*/
Matrix mulMatrix(Matrix matrix1,Matrix matrix2);

/**
* Check out if the matrix is Empty
* 
* @param matrix the matrix you want to check
*
* @return bool (true/false)
*/
bool isMatrixEmpty(Matrix matrix);

/**
* Check out if the matrix is square
* 
* @param matrix the matrix you want to check
*
* @return bool (true/false)
*/
bool isMatrixSquare(Matrix matrix);


/**
* Check out if the Matrices are equals
* 
* @param m1 Matrices
* @param m2 Matrices
*
* @return bool (true/false)
*/
bool equalsMatrix(Matrix m1, Matrix m2);


/**
* Check out if the column is empty
* 
* @param matrix the Matrix where the column is in
* @param the number of the column
*
* @return bool (true/false)
*/
bool isColumnEmpty(Matrix matrix,int nb);

/**
* Check out if the row is empty
* 
* @param matrix the Matrix where the row is in
* @param the number of the row
*
* @return bool (true/false)
*/
bool isRowEmpty(Matrix matrix,int nb);

#endif