Matrix/src/test/java/com/mattrixwv/matrix/TestBigIntegerMatrix.java

//Matrix/src/test/java/com/mattrixwv/matrix/TestBigBigBigIntegerMatrix.java
//Mattrixwv
// Created: 02-10-22
//Modified: 08-11-24
package com.mattrixwv.matrix;


import static org.junit.jupiter.api.Assertions.*;

import java.math.BigInteger;
import java.util.Arrays;

import org.junit.jupiter.api.Test;

import com.mattrixwv.matrix.exceptions.InvalidCoordinatesException;
import com.mattrixwv.matrix.exceptions.InvalidGeometryException;
import com.mattrixwv.matrix.exceptions.InvalidRowSizeException;
import com.mattrixwv.matrix.exceptions.InvalidScalarException;
import com.mattrixwv.matrix.exceptions.NullMatrixException;


public class TestBigIntegerMatrix{
	private static final BigInteger[][] negativeGrid2 = new BigInteger[][]{
		{BigInteger.valueOf(-1), BigInteger.valueOf(-2)},
		{BigInteger.valueOf(-3), BigInteger.valueOf(-4)}
	};
	private static final BigInteger[][] negativeGrid10 = new BigInteger[][]{
		{BigInteger.valueOf(-1), BigInteger.valueOf(-2), BigInteger.valueOf(-3), BigInteger.valueOf(-4), BigInteger.valueOf(-5), BigInteger.valueOf(-6), BigInteger.valueOf(-7), BigInteger.valueOf(-8), BigInteger.valueOf(-9), BigInteger.valueOf(-10)},
		{BigInteger.valueOf(-11), BigInteger.valueOf(-12), BigInteger.valueOf(-13), BigInteger.valueOf(-14), BigInteger.valueOf(-15), BigInteger.valueOf(-16), BigInteger.valueOf(-17), BigInteger.valueOf(-18), BigInteger.valueOf(-19), BigInteger.valueOf(-20)},
		{BigInteger.valueOf(-21), BigInteger.valueOf(-22), BigInteger.valueOf(-23), BigInteger.valueOf(-24), BigInteger.valueOf(-25), BigInteger.valueOf(-26), BigInteger.valueOf(-27), BigInteger.valueOf(-28), BigInteger.valueOf(-29), BigInteger.valueOf(-30)},
		{BigInteger.valueOf(-31), BigInteger.valueOf(-32), BigInteger.valueOf(-33), BigInteger.valueOf(-34), BigInteger.valueOf(-35), BigInteger.valueOf(-36), BigInteger.valueOf(-37), BigInteger.valueOf(-38), BigInteger.valueOf(-39), BigInteger.valueOf(-40)},
		{BigInteger.valueOf(-41), BigInteger.valueOf(-42), BigInteger.valueOf(-43), BigInteger.valueOf(-44), BigInteger.valueOf(-45), BigInteger.valueOf(-46), BigInteger.valueOf(-47), BigInteger.valueOf(-48), BigInteger.valueOf(-49), BigInteger.valueOf(-50)},
		{BigInteger.valueOf(-51), BigInteger.valueOf(-52), BigInteger.valueOf(-53), BigInteger.valueOf(-54), BigInteger.valueOf(-55), BigInteger.valueOf(-56), BigInteger.valueOf(-57), BigInteger.valueOf(-58), BigInteger.valueOf(-59), BigInteger.valueOf(-60)},
		{BigInteger.valueOf(-61), BigInteger.valueOf(-62), BigInteger.valueOf(-63), BigInteger.valueOf(-64), BigInteger.valueOf(-65), BigInteger.valueOf(-66), BigInteger.valueOf(-67), BigInteger.valueOf(-68), BigInteger.valueOf(-69), BigInteger.valueOf(-70)},
		{BigInteger.valueOf(-71), BigInteger.valueOf(-72), BigInteger.valueOf(-73), BigInteger.valueOf(-74), BigInteger.valueOf(-75), BigInteger.valueOf(-76), BigInteger.valueOf(-77), BigInteger.valueOf(-78), BigInteger.valueOf(-79), BigInteger.valueOf(-80)},
		{BigInteger.valueOf(-81), BigInteger.valueOf(-82), BigInteger.valueOf(-83), BigInteger.valueOf(-84), BigInteger.valueOf(-85), BigInteger.valueOf(-86), BigInteger.valueOf(-87), BigInteger.valueOf(-88), BigInteger.valueOf(-89), BigInteger.valueOf(-90)},
		{BigInteger.valueOf(-91), BigInteger.valueOf(-92),BigInteger.valueOf( -93), BigInteger.valueOf(-94), BigInteger.valueOf(-95), BigInteger.valueOf(-96), BigInteger.valueOf(-97), BigInteger.valueOf(-98), BigInteger.valueOf(-99), BigInteger.valueOf(-100)}
	};
	private static final BigInteger[][] negativeGrid2x10 = new BigInteger[][]{
		{BigInteger.valueOf(-1), BigInteger.valueOf(-2), BigInteger.valueOf(-3), BigInteger.valueOf(-4), BigInteger.valueOf(-5), BigInteger.valueOf(-6), BigInteger.valueOf(-7), BigInteger.valueOf(-8), BigInteger.valueOf(-9), BigInteger.valueOf(-10)},
		{BigInteger.valueOf(-11), BigInteger.valueOf(-12), BigInteger.valueOf(-13), BigInteger.valueOf(-14), BigInteger.valueOf(-15), BigInteger.valueOf(-16), BigInteger.valueOf(-17), BigInteger.valueOf(-18), BigInteger.valueOf(-19), BigInteger.valueOf(-20)}
	};
	private static final BigInteger[][] negativeGrid10x2 = new BigInteger[][]{
		{BigInteger.valueOf(-1), BigInteger.valueOf(-2)},
		{BigInteger.valueOf(-3), BigInteger.valueOf(-4)},
		{BigInteger.valueOf(-5), BigInteger.valueOf(-6)},
		{BigInteger.valueOf(-7), BigInteger.valueOf(-8)},
		{BigInteger.valueOf(-9), BigInteger.valueOf(-10)},
		{BigInteger.valueOf(-11), BigInteger.valueOf(-12)},
		{BigInteger.valueOf(-13), BigInteger.valueOf(-14)},
		{BigInteger.valueOf(-15), BigInteger.valueOf(-16)},
		{BigInteger.valueOf(-17), BigInteger.valueOf(-18)},
		{BigInteger.valueOf(-19), BigInteger.valueOf(-20)}
	};

	//! Constructor
	@Test
	public void testConstructor_default(){
		BigIntegerMatrix matrix = new BigIntegerMatrix();

		assertEquals(0, matrix.getNumRows());
		assertEquals(0, matrix.getNumCols());
	}

	@Test
	public void testConstructor_fill0Rows(){
		assertThrows(InvalidGeometryException.class, () -> {
			new BigIntegerMatrix(0, 1, BigInteger.ZERO);
		});
	}

	@Test
	public void testConstructor_fill0Cols(){
		assertThrows(InvalidGeometryException.class, () -> {
			new BigIntegerMatrix(1, 0, BigInteger.ZERO);
		});
	}

	@Test
	public void testConstructor_fillSize2(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(2, 2, BigInteger.valueOf(-1));

		assertEquals(2, matrix.getNumRows());
		assertEquals(2, matrix.getNumCols());
		assertEquals(BigInteger.valueOf(-1), matrix.get(0, 0));
		assertEquals(BigInteger.valueOf(-1), matrix.get(0, 1));
		assertEquals(BigInteger.valueOf(-1), matrix.get(1, 0));
		assertEquals(BigInteger.valueOf(-1), matrix.get(1, 1));
	}

	@Test
	public void testConstructor_fillSize10(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(10, 10, BigInteger.valueOf(-1));

		assertEquals(10, matrix.getNumRows());
		assertEquals(10, matrix.getNumCols());
		for(BigInteger[] row : matrix.copyGrid()){
			for(BigInteger num : row){
				assertEquals(BigInteger.valueOf(-1), num);
			}
		}
	}

	@Test
	public void testConstructor_arraySize0(){
		BigInteger[][] grid = new BigInteger[0][0];
		BigIntegerMatrix matrix = new BigIntegerMatrix(grid);

		assertEquals(0, matrix.getNumRows());
		assertEquals(0, matrix.getNumCols());
	}

	@Test
	public void testConstructor_arraySize2(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertEquals(2, matrix.getNumRows());
		assertEquals(2, matrix.getNumCols());
		assertArrayEquals(negativeGrid2, matrix.copyGrid());
	}

	@Test
	public void testConstructor_arraySize10(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid10);

		assertEquals(10, matrix.getNumRows());
		assertEquals(10, matrix.getNumCols());
		assertArrayEquals(negativeGrid10, matrix.copyGrid());
	}

	@Test
	public void testConstructor_arraySize2x10(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2x10);

		assertEquals(2, matrix.getNumRows());
		assertEquals(10, matrix.getNumCols());
		assertArrayEquals(negativeGrid2x10, matrix.copyGrid());
	}

	@Test
	public void testConstructor_arraySize10x2(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid10x2);

		assertEquals(10, matrix.getNumRows());
		assertEquals(2, matrix.getNumCols());
		assertArrayEquals(negativeGrid10x2, matrix.copyGrid());
	}

	@Test
	public void testConstructor_arrayUnevenRows(){
		BigInteger[][] grid = new BigInteger[][]{
			{BigInteger.valueOf(-1), BigInteger.valueOf(-2), BigInteger.valueOf(-3)},
			{BigInteger.valueOf(-4), BigInteger.valueOf(-5)},
			{BigInteger.valueOf(-6), BigInteger.valueOf(-7), BigInteger.valueOf(-8), BigInteger.valueOf(-9)},
			{BigInteger.valueOf(-10), BigInteger.valueOf(-11), BigInteger.valueOf(-12)}
		};

		assertThrows(InvalidRowSizeException.class, () -> {
			new BigIntegerMatrix(grid);
		});
	}

	@Test
	public void testConstructor_matrixSize0(){
		BigIntegerMatrix originalMatrix = new BigIntegerMatrix();
		BigIntegerMatrix matrix = new BigIntegerMatrix(originalMatrix);

		assertEquals(0, matrix.getNumRows());
		assertEquals(0, matrix.getNumCols());
	}

	@Test
	public void testConstructor_matrixSize2(){
		BigIntegerMatrix originalMatrix = new BigIntegerMatrix(2, 2, BigInteger.valueOf(-1));
		BigIntegerMatrix matrix = new BigIntegerMatrix(originalMatrix);

		assertEquals(2, matrix.getNumRows());
		assertEquals(2, matrix.getNumCols());
		for(BigInteger[] row : matrix.copyGrid()){
			for(BigInteger num : row){
				assertEquals(BigInteger.valueOf(-1), num);
			}
		}
	}

	@Test
	public void testConstructor_matrixSize10(){
		BigIntegerMatrix originalMatrix = new BigIntegerMatrix(10, 10, BigInteger.valueOf(-1));
		BigIntegerMatrix matrix = new BigIntegerMatrix(originalMatrix);

		assertEquals(10, matrix.getNumRows());
		assertEquals(10, matrix.getNumCols());
		for(BigInteger[] row : matrix.copyGrid()){
			for(BigInteger num : row){
				assertEquals(BigInteger.valueOf(-1), num);
			}
		}
	}

	@Test
	public void testConstructor_matrixSize2x10(){
		BigIntegerMatrix originalMatrix = new BigIntegerMatrix(2, 10, BigInteger.valueOf(-1));
		BigIntegerMatrix matrix = new BigIntegerMatrix(originalMatrix);

		assertEquals(2, matrix.getNumRows());
		assertEquals(10, matrix.getNumCols());
		for(BigInteger[] row : matrix.copyGrid()){
			for(BigInteger num : row){
				assertEquals(BigInteger.valueOf(-1), num);
			}
		}
	}

	@Test
	public void testConstructor_matrixSize10x2(){
		BigIntegerMatrix originalMatrix = new BigIntegerMatrix(10, 2, BigInteger.valueOf(-1));
		BigIntegerMatrix matrix = new BigIntegerMatrix(originalMatrix);

		assertEquals(10, matrix.getNumRows());
		assertEquals(2, matrix.getNumCols());
		for(BigInteger[] row : matrix.copyGrid()){
			for(BigInteger num : row){
				assertEquals(BigInteger.valueOf(-1), num);
			}
		}
	}

	//! setGrid()
	@Test
	public void testSetGrid_size0(){
		BigInteger[][] grid = new BigInteger[0][0];
		BigIntegerMatrix matrix = new BigIntegerMatrix();
		matrix.setGrid(grid);

		assertEquals(0, matrix.getNumRows());
		assertEquals(0, matrix.getNumCols());
	}

	@Test
	public void testSetGrid_size2x0(){
		BigInteger[][] grid = new BigInteger[2][0];
		BigIntegerMatrix matrix = new BigIntegerMatrix();
		matrix.setGrid(grid);

		assertEquals(2, matrix.getNumRows());
		assertEquals(0, matrix.getNumCols());
	}

	@Test
	public void testSetGrid_size2(){
		BigIntegerMatrix matrix = new BigIntegerMatrix();
		matrix.setGrid(negativeGrid2);

		assertEquals(2, matrix.getNumRows());
		assertEquals(2, matrix.getNumCols());
		assertArrayEquals(negativeGrid2, matrix.copyGrid());
	}

	@Test
	public void testSetGrid_size10(){
		BigIntegerMatrix matrix = new BigIntegerMatrix();
		matrix.setGrid(negativeGrid10);

		assertEquals(10, matrix.getNumRows());
		assertEquals(10, matrix.getNumCols());
		assertArrayEquals(negativeGrid10, matrix.copyGrid());
	}

	@Test
	public void testSetGrid_size2x10(){
		BigIntegerMatrix matrix = new BigIntegerMatrix();
		matrix.setGrid(negativeGrid2x10);

		assertEquals(2, matrix.getNumRows());
		assertEquals(10, matrix.getNumCols());
		assertArrayEquals(negativeGrid2x10, matrix.copyGrid());
	}

	@Test
	public void testSetGrid_size10x2(){
		BigIntegerMatrix matrix = new BigIntegerMatrix();
		matrix.setGrid(negativeGrid10x2);

		assertEquals(10, matrix.getNumRows());
		assertEquals(2, matrix.getNumCols());
		assertArrayEquals(negativeGrid10x2, matrix.copyGrid());
	}

	@Test
	public void testCopyGrid_size0(){
		BigInteger[][] grid = new BigInteger[0][0];
		BigIntegerMatrix matrix = new BigIntegerMatrix(grid);

		assertArrayEquals(grid, matrix.copyGrid());
	}

	@Test
	public void testCopyGrid_size0x2(){
		BigInteger[][] grid = new BigInteger[0][2];
		BigIntegerMatrix matrix = new BigIntegerMatrix(grid);

		assertArrayEquals(grid, matrix.copyGrid());
	}

	@Test
	public void testCopyGrid_size2x0(){
		BigInteger[][] grid = new BigInteger[2][0];
		BigIntegerMatrix matrix = new BigIntegerMatrix(grid);

		assertArrayEquals(grid, matrix.copyGrid());
	}

	@Test
	public void testCopyGrid_size2(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertArrayEquals(negativeGrid2, matrix.copyGrid());
	}

	@Test
	public void testCopyGrid_size10(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid10);

		assertArrayEquals(negativeGrid10, matrix.copyGrid());
	}

	@Test
	public void testCopyGrid_size10x2(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid10x2);

		assertArrayEquals(negativeGrid10x2, matrix.copyGrid());
	}

	@Test
	public void testCopyGrid_size2x10(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2x10);

		assertArrayEquals(negativeGrid2x10, matrix.copyGrid());
	}

	//! isSquare()
	@Test
	public void testIsSquare_size0(){
		BigInteger[][] grid = new BigInteger[0][0];
		BigIntegerMatrix matrix = new BigIntegerMatrix(grid);

		assertFalse(matrix.isSquare());
	}

	@Test
	public void testIsSquare_size0x2(){
		BigInteger[][] grid = new BigInteger[0][2];
		BigIntegerMatrix matrix = new BigIntegerMatrix(grid);

		assertFalse(matrix.isSquare());
	}

	@Test
	public void testIsSquare_size2x0(){
		BigInteger[][] grid = new BigInteger[2][0];
		BigIntegerMatrix matrix = new BigIntegerMatrix(grid);

		assertFalse(matrix.isSquare());
	}

	@Test
	public void testIsSquare_size2(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertTrue(matrix.isSquare());
	}

	@Test
	public void testIsSquare_size10(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid10);

		assertTrue(matrix.isSquare());
	}

	@Test
	public void testIsSquare_size2x10(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2x10);

		assertFalse(matrix.isSquare());
	}

	@Test
	public void testIsSquare_size10x2(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid10x2);

		assertFalse(matrix.isSquare());
	}

	//! laplaceExpansionHelper()
	@Test
	public void testLaplaceExpansionHelper_size0(){
		BigInteger[][] grid = new BigInteger[0][0];
		BigIntegerMatrix matrix = new BigIntegerMatrix(grid);

		assertThrows(InvalidGeometryException.class, () -> {
			matrix.laplaceExpansionHelper(0, 0);
		});
	}

	@Test
	public void testLaplaceExpansionHelper_size0x2(){
		BigInteger[][] grid = new BigInteger[0][2];
		BigIntegerMatrix matrix = new BigIntegerMatrix(grid);

		assertThrows(InvalidGeometryException.class, () -> {
			matrix.laplaceExpansionHelper(0, 0);
		});
	}

	@Test
	public void testLaplaceExpansionHelper_size2x0(){
		BigInteger[][] grid = new BigInteger[2][0];
		BigIntegerMatrix matrix = new BigIntegerMatrix(grid);

		assertThrows(InvalidGeometryException.class, () -> {
			matrix.laplaceExpansionHelper(0, 0);
		});
	}

	@Test
	public void testLaplaceExpansionHelper_size2(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);
		BigIntegerMatrix result = matrix.laplaceExpansionHelper(0, 0);

		assertArrayEquals(new BigInteger[][]{{BigInteger.valueOf(-4)}}, result.copyGrid());
	}

	@Test
	public void testLaplaceExpansionHelper_size2_negativeRow(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertThrows(InvalidCoordinatesException.class, () -> {
			matrix.laplaceExpansionHelper(-1, 0);
		});
	}

	@Test
	public void testLaplaceExpansionHelper_size2_largeRow(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertThrows(InvalidCoordinatesException.class, () -> {
			matrix.laplaceExpansionHelper(2, 0);
		});
	}

	@Test
	public void testLaplaceExpansionHelper_size2_negativeCol(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertThrows(InvalidCoordinatesException.class, () -> {
			matrix.laplaceExpansionHelper(0, -1);
		});
	}

	@Test
	public void testLaplaceExpansionHelper_size2_largeCol(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertThrows(InvalidCoordinatesException.class, () -> {
			matrix.laplaceExpansionHelper(0, 2);
		});
	}

	@Test
	public void testLaplaceExpansionHelper_size10_loc0x0(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid10);
		BigIntegerMatrix result = matrix.laplaceExpansionHelper(0, 0);

		BigInteger[][] expectedGrid = new BigInteger[][]{
			{BigInteger.valueOf(-12), BigInteger.valueOf(-13), BigInteger.valueOf(-14), BigInteger.valueOf(-15), BigInteger.valueOf(-16), BigInteger.valueOf(-17), BigInteger.valueOf(-18), BigInteger.valueOf(-19), BigInteger.valueOf(-20)},
			{BigInteger.valueOf(-22), BigInteger.valueOf(-23), BigInteger.valueOf(-24), BigInteger.valueOf(-25), BigInteger.valueOf(-26), BigInteger.valueOf(-27), BigInteger.valueOf(-28), BigInteger.valueOf(-29), BigInteger.valueOf(-30)},
			{BigInteger.valueOf(-32), BigInteger.valueOf(-33), BigInteger.valueOf(-34), BigInteger.valueOf(-35), BigInteger.valueOf(-36), BigInteger.valueOf(-37), BigInteger.valueOf(-38), BigInteger.valueOf(-39), BigInteger.valueOf(-40)},
			{BigInteger.valueOf(-42), BigInteger.valueOf(-43), BigInteger.valueOf(-44), BigInteger.valueOf(-45), BigInteger.valueOf(-46), BigInteger.valueOf(-47), BigInteger.valueOf(-48), BigInteger.valueOf(-49), BigInteger.valueOf(-50)},
			{BigInteger.valueOf(-52), BigInteger.valueOf(-53), BigInteger.valueOf(-54), BigInteger.valueOf(-55), BigInteger.valueOf(-56), BigInteger.valueOf(-57), BigInteger.valueOf(-58), BigInteger.valueOf(-59), BigInteger.valueOf(-60)},
			{BigInteger.valueOf(-62), BigInteger.valueOf(-63), BigInteger.valueOf(-64), BigInteger.valueOf(-65), BigInteger.valueOf(-66), BigInteger.valueOf(-67), BigInteger.valueOf(-68), BigInteger.valueOf(-69), BigInteger.valueOf(-70)},
			{BigInteger.valueOf(-72), BigInteger.valueOf(-73), BigInteger.valueOf(-74), BigInteger.valueOf(-75), BigInteger.valueOf(-76), BigInteger.valueOf(-77), BigInteger.valueOf(-78), BigInteger.valueOf(-79), BigInteger.valueOf(-80)},
			{BigInteger.valueOf(-82), BigInteger.valueOf(-83), BigInteger.valueOf(-84), BigInteger.valueOf(-85), BigInteger.valueOf(-86), BigInteger.valueOf(-87), BigInteger.valueOf(-88), BigInteger.valueOf(-89), BigInteger.valueOf(-90)},
			{BigInteger.valueOf(-92), BigInteger.valueOf(-93), BigInteger.valueOf(-94), BigInteger.valueOf(-95), BigInteger.valueOf(-96), BigInteger.valueOf(-97), BigInteger.valueOf(-98), BigInteger.valueOf(-99), BigInteger.valueOf(-100)}
		};
		assertArrayEquals(expectedGrid, result.copyGrid());
	}

	@Test
	public void testLaplaceExpansionHelper_size10_loc4x4(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid10);
		BigIntegerMatrix result = matrix.laplaceExpansionHelper(4, 4);

		BigInteger[][] expectedGrid = new BigInteger[][]{
			{ BigInteger.valueOf(-1),  BigInteger.valueOf(-2),  BigInteger.valueOf(-3),  BigInteger.valueOf(-4),  BigInteger.valueOf(-6),  BigInteger.valueOf(-7),  BigInteger.valueOf(-8),  BigInteger.valueOf(-9), BigInteger.valueOf(-10)},
			{BigInteger.valueOf(-11), BigInteger.valueOf(-12), BigInteger.valueOf(-13), BigInteger.valueOf(-14), BigInteger.valueOf(-16), BigInteger.valueOf(-17), BigInteger.valueOf(-18), BigInteger.valueOf(-19), BigInteger.valueOf(-20)},
			{BigInteger.valueOf(-21), BigInteger.valueOf(-22), BigInteger.valueOf(-23), BigInteger.valueOf(-24), BigInteger.valueOf(-26), BigInteger.valueOf(-27), BigInteger.valueOf(-28), BigInteger.valueOf(-29), BigInteger.valueOf(-30)},
			{BigInteger.valueOf(-31), BigInteger.valueOf(-32), BigInteger.valueOf(-33), BigInteger.valueOf(-34), BigInteger.valueOf(-36), BigInteger.valueOf(-37), BigInteger.valueOf(-38), BigInteger.valueOf(-39), BigInteger.valueOf(-40)},
			{BigInteger.valueOf(-51), BigInteger.valueOf(-52), BigInteger.valueOf(-53), BigInteger.valueOf(-54), BigInteger.valueOf(-56), BigInteger.valueOf(-57), BigInteger.valueOf(-58), BigInteger.valueOf(-59), BigInteger.valueOf(-60)},
			{BigInteger.valueOf(-61), BigInteger.valueOf(-62), BigInteger.valueOf(-63), BigInteger.valueOf(-64), BigInteger.valueOf(-66), BigInteger.valueOf(-67), BigInteger.valueOf(-68), BigInteger.valueOf(-69), BigInteger.valueOf(-70)},
			{BigInteger.valueOf(-71), BigInteger.valueOf(-72), BigInteger.valueOf(-73), BigInteger.valueOf(-74), BigInteger.valueOf(-76), BigInteger.valueOf(-77), BigInteger.valueOf(-78), BigInteger.valueOf(-79), BigInteger.valueOf(-80)},
			{BigInteger.valueOf(-81), BigInteger.valueOf(-82), BigInteger.valueOf(-83), BigInteger.valueOf(-84), BigInteger.valueOf(-86), BigInteger.valueOf(-87), BigInteger.valueOf(-88), BigInteger.valueOf(-89), BigInteger.valueOf(-90)},
			{BigInteger.valueOf(-91), BigInteger.valueOf(-92), BigInteger.valueOf(-93), BigInteger.valueOf(-94), BigInteger.valueOf(-96), BigInteger.valueOf(-97), BigInteger.valueOf(-98), BigInteger.valueOf(-99), BigInteger.valueOf(-100)}
		};
		assertArrayEquals(expectedGrid, result.copyGrid());
	}

	@Test
	public void testLaplaceExpansionHelper_size2x10(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2x10);

		assertThrows(InvalidGeometryException.class, () -> {
			matrix.laplaceExpansionHelper(0, 0);
		});
	}

	@Test
	public void testLaplaceExpansionHelper_size10x2(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid10x2);

		assertThrows(InvalidGeometryException.class, () -> {
			matrix.laplaceExpansionHelper(0, 0);
		});
	}

	//! get()
	@Test
	public void testGet_largeRow(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertThrows(InvalidCoordinatesException.class, () -> {
			matrix.get(2, 0);
		});
	}

	@Test
	public void testGet_negativeRow(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertThrows(InvalidCoordinatesException.class, () -> {
			matrix.get(-1, 0);
		});
	}

	@Test
	public void testGet_largeCol(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertThrows(InvalidCoordinatesException.class, () -> {
			matrix.get(0, 2);
		});
	}

	@Test
	public void testGet_negativeCol(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertThrows(InvalidCoordinatesException.class, () -> {
			matrix.get(0, -1);
		});
	}

	@Test
	public void testGet(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertEquals(BigInteger.valueOf(-1), matrix.get(0, 0));
		assertEquals(BigInteger.valueOf(-2), matrix.get(0, 1));
		assertEquals(BigInteger.valueOf(-3), matrix.get(1, 0));
		assertEquals(BigInteger.valueOf(-4), matrix.get(1, 1));
	}

	//! getRow()
	@Test
	public void testGetRow_largeRow(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertThrows(InvalidCoordinatesException.class, () -> {
			matrix.getRow(2);
		});
	}

	@Test
	public void testGetRow_negativeRow(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertThrows(InvalidCoordinatesException.class, () -> {
			matrix.getRow(-1);
		});
	}

	@Test
	public void testGetRow(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertArrayEquals(new BigInteger[][]{{BigInteger.valueOf(-1), BigInteger.valueOf(-2)}}, matrix.getRow(0).copyGrid());
		assertArrayEquals(new BigInteger[][]{{BigInteger.valueOf(-3), BigInteger.valueOf(-4)}}, matrix.getRow(1).copyGrid());
	}

	//! getColumn()
	@Test
	public void testGetCol_0Rows(){
		BigInteger[][] grid = new BigInteger[0][2];
		BigIntegerMatrix matrix = new BigIntegerMatrix(grid);

		assertThrows(InvalidCoordinatesException.class, () -> {
			matrix.getCol(0);
		});
	}

	@Test
	public void testGetCol_largeCol(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertThrows(InvalidCoordinatesException.class, () -> {
			matrix.getCol(2);
		});
	}

	@Test
	public void testGetCol_negativeCol(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertThrows(InvalidCoordinatesException.class, () -> {
			matrix.getCol(-1);
		});
	}

	@Test
	public void testGetCol(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertArrayEquals(new BigInteger[][]{{BigInteger.valueOf(-1)}, {BigInteger.valueOf(-3)}}, matrix.getCol(0).copyGrid());
		assertArrayEquals(new BigInteger[][]{{BigInteger.valueOf(-2)}, {BigInteger.valueOf(-4)}}, matrix.getCol(1).copyGrid());
	}

	//! getNumRows()
	@Test
	public void testGetNumRows_size0(){
		BigInteger[][] grid = new BigInteger[0][0];
		BigIntegerMatrix matrix = new BigIntegerMatrix(grid);

		assertEquals(0, matrix.getNumRows());
	}

	@Test
	public void testGetNumRows_size0x2(){
		BigInteger[][] grid = new BigInteger[0][2];
		BigIntegerMatrix matrix = new BigIntegerMatrix(grid);

		assertEquals(0, matrix.getNumRows());
	}

	@Test
	public void testGetNumRows_size2x0(){
		BigInteger[][] grid = new BigInteger[2][0];
		BigIntegerMatrix matrix = new BigIntegerMatrix(grid);

		assertEquals(2, matrix.getNumRows());
	}

	@Test
	public void testGetNumRows_size2(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertEquals(2, matrix.getNumRows());
	}

	@Test
	public void testGetNumRows_size10(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid10);

		assertEquals(10, matrix.getNumRows());
	}

	@Test
	public void testGetNumRows_size2x10(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2x10);

		assertEquals(2, matrix.getNumRows());
	}

	@Test
	public void testGetNumRows_size10x2(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid10x2);

		assertEquals(10, matrix.getNumRows());
	}

	//! getNumCols()
	@Test
	public void testGetNumCols_size0(){
		BigInteger[][] grid = new BigInteger[0][0];
		BigIntegerMatrix matrix = new BigIntegerMatrix(grid);

		assertEquals(0, matrix.getNumCols());
	}

	@Test
	public void testGetNumCols_size0x2(){
		BigInteger[][] grid = new BigInteger[0][2];
		BigIntegerMatrix matrix = new BigIntegerMatrix(grid);

		assertEquals(0, matrix.getNumCols());
	}

	@Test
	public void testGetNumCols_size2x0(){
		BigInteger[][] grid = new BigInteger[2][0];
		BigIntegerMatrix matrix = new BigIntegerMatrix(grid);

		assertEquals(0, matrix.getNumCols());
	}

	@Test
	public void testGetNumCols_size2(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertEquals(2, matrix.getNumCols());
	}

	@Test
	public void testGetNumCols_size10(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid10);

		assertEquals(10, matrix.getNumCols());
	}

	@Test
	public void testGetNumCols_size2x10(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2x10);

		assertEquals(10, matrix.getNumCols());
	}

	@Test
	public void testGetNumCols_size10x2(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid10x2);

		assertEquals(2, matrix.getNumCols());
	}

	//! set()
	@Test
	public void testSet_negativeRow(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertThrows(InvalidCoordinatesException.class, () -> {
			matrix.set(-1, 0, BigInteger.ZERO);
		});
	}

	@Test
	public void testSet_largeRow(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertThrows(InvalidCoordinatesException.class, () -> {
			matrix.set(2, 0, BigInteger.ZERO);
		});
	}

	@Test
	public void testSet_negativeCol(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertThrows(InvalidCoordinatesException.class, () -> {
			matrix.set(0, -1, BigInteger.ZERO);
		});
	}

	@Test
	public void testSet_largeCol(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertThrows(InvalidCoordinatesException.class, () -> {
			matrix.set(0, 2, BigInteger.ZERO);
		});
	}

	@Test
	public void testSet(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		matrix.set(0, 0, BigInteger.valueOf(-5));
		matrix.set(0, 1, BigInteger.valueOf(-6));
		matrix.set(1, 0, BigInteger.valueOf(-7));
		matrix.set(1, 1, BigInteger.valueOf(-8));
		assertEquals(BigInteger.valueOf(-5), matrix.get(0, 0));
		assertEquals(BigInteger.valueOf(-6), matrix.get(0, 1));
		assertEquals(BigInteger.valueOf(-7), matrix.get(1, 0));
		assertEquals(BigInteger.valueOf(-8), matrix.get(1, 1));
	}

	//! setRow()
	@Test
	public void testSetRow_array_negativeRow(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertThrows(InvalidCoordinatesException.class, () -> {
			matrix.setRow(-1, new BigInteger[]{BigInteger.ZERO});
		});
	}

	@Test
	public void testSetRow_array_largeRow(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertThrows(InvalidCoordinatesException.class, () -> {
			matrix.setRow(2, new BigInteger[]{BigInteger.ZERO});
		});
	}

	@Test
	public void testSetRow_array_nullArray(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertThrows(InvalidGeometryException.class, () -> {
			matrix.setRow(0, (BigInteger[])null);
		});
	}

	@Test
	public void testSetRow_array_arrayLength0(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertThrows(InvalidGeometryException.class, () -> {
			matrix.setRow(0, new BigInteger[0]);
		});
	}

	@Test
	public void testSetRow_array_invalidArrayLength(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertThrows(InvalidGeometryException.class, () -> {
			matrix.setRow(0, new BigInteger[]{BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO});
		});
	}

	@Test
	public void testSetRow_array(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		matrix.setRow(0, new BigInteger[]{BigInteger.valueOf(-5), BigInteger.valueOf(-6)});
		matrix.setRow(1, new BigInteger[]{BigInteger.valueOf(-7), BigInteger.valueOf(-8)});
		assertArrayEquals(new BigInteger[][]{{BigInteger.valueOf(-5), BigInteger.valueOf(-6)}, {BigInteger.valueOf(-7), BigInteger.valueOf(-8)}}, matrix.copyGrid());
	}

	@Test
	public void testSetRow_matrix_nullMatrix(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertThrows(NullMatrixException.class, () -> {
			matrix.setRow(0, (BigIntegerMatrix)null);
		});
	}

	@Test
	public void testSetRow_matrix_multipleRows(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertThrows(InvalidGeometryException.class, () -> {
			matrix.setRow(0, new BigIntegerMatrix(new BigInteger[][]{{BigInteger.ZERO, BigInteger.ZERO}, {BigInteger.ZERO, BigInteger.ZERO}}));
		});
	}

	@Test
	public void testSetRow_matrix_negativeRow(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertThrows(InvalidCoordinatesException.class, () -> {
			matrix.setRow(-1, new BigIntegerMatrix(new BigInteger[][]{{BigInteger.ZERO}}));
		});
	}

	@Test
	public void testSetRow_matrix_largeRow(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertThrows(InvalidCoordinatesException.class, () -> {
			matrix.setRow(2, new BigIntegerMatrix(new BigInteger[][]{{BigInteger.ZERO}}));
		});
	}

	@Test
	public void testSetRow_matrix_length0(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertThrows(InvalidGeometryException.class, () -> {
			matrix.setRow(0, new BigIntegerMatrix(new BigInteger[][]{{}}));
		});
	}

	@Test
	public void testSetRow_matrix_invalidLength(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertThrows(InvalidGeometryException.class, () -> {
			matrix.setRow(0, new BigIntegerMatrix(new BigInteger[][]{{BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO}}));
		});
	}

	@Test
	public void testSetRow_matrix(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		matrix.setRow(0, new BigIntegerMatrix(new BigInteger[][]{{BigInteger.valueOf(-5), BigInteger.valueOf(-6)}}));
		matrix.setRow(1, new BigIntegerMatrix(new BigInteger[][]{{BigInteger.valueOf(-7), BigInteger.valueOf(-8)}}));
		assertArrayEquals(new BigInteger[][]{{BigInteger.valueOf(-5), BigInteger.valueOf(-6)}, {BigInteger.valueOf(-7), BigInteger.valueOf(-8)}}, matrix.copyGrid());
	}

	//! setCol()
	@Test
	public void testSetCol_array_negativeCol(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertThrows(InvalidCoordinatesException.class, () -> {
			matrix.setCol(-1, new BigInteger[]{BigInteger.ZERO});
		});
	}

	@Test
	public void testSetCol_array_largeCol(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertThrows(InvalidCoordinatesException.class, () -> {
			matrix.setCol(2, new BigInteger[]{BigInteger.ZERO});
		});
	}

	@Test
	public void testSetCol_array_nullArray(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertThrows(InvalidGeometryException.class, () -> {
			matrix.setCol(0, (BigInteger[])null);
		});
	}

	@Test
	public void testSetCol_array_length0(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertThrows(InvalidGeometryException.class, () -> {
			matrix.setCol(0, new BigInteger[0]);
		});
	}

	@Test
	public void testSetCol_array_invalidArrayLength(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertThrows(InvalidGeometryException.class, () -> {
			matrix.setCol(0, new BigInteger[]{BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO});
		});
	}

	@Test
	public void testSetCol_array(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		matrix.setCol(0, new BigInteger[]{BigInteger.valueOf(-5), BigInteger.valueOf(-7)});
		matrix.setCol(1, new BigInteger[]{BigInteger.valueOf(-6), BigInteger.valueOf(-8)});
		assertArrayEquals(new BigInteger[][]{{BigInteger.valueOf(-5), BigInteger.valueOf(-6)}, {BigInteger.valueOf(-7), BigInteger.valueOf(-8)}}, matrix.copyGrid());
	}

	@Test
	public void testSetCol_matrix_nullMatrix(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertThrows(NullMatrixException.class, () -> {
			matrix.setCol(0, (BigIntegerMatrix)null);
		});
	}

	@Test
	public void testSetCol_matrix_multipleCols(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertThrows(InvalidGeometryException.class, () -> {
			matrix.setCol(0, new BigIntegerMatrix(new BigInteger[][]{{BigInteger.ZERO, BigInteger.ZERO}}));
		});
	}

	@Test
	public void testSetCol_matrix_negativeCol(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertThrows(InvalidCoordinatesException.class, () -> {
			matrix.setCol(-1, new BigIntegerMatrix(new BigInteger[][]{{BigInteger.ZERO}}));
		});
	}

	@Test
	public void testSetCol_matrix_largeCol(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertThrows(InvalidCoordinatesException.class, () -> {
			matrix.setCol(2, new BigIntegerMatrix(new BigInteger[][]{{BigInteger.ZERO}}));
		});
	}

	@Test
	public void testSetCol_matrix_length0(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertThrows(InvalidGeometryException.class, () -> {
			matrix.setCol(0, new BigIntegerMatrix(new BigInteger[][]{{}}));
		});
	}

	@Test
	public void testSetCol_matrix_invalidLength(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertThrows(InvalidGeometryException.class, () -> {
			matrix.setCol(0, new BigIntegerMatrix(new BigInteger[][]{{BigInteger.valueOf(0), BigInteger.valueOf(0), BigInteger.valueOf(0)}}));
		});
	}

	@Test
	public void testSetCol_matrix(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		matrix.setCol(0, new BigIntegerMatrix(new BigInteger[][]{{BigInteger.valueOf(-5)}, {BigInteger.valueOf(-7)}}));
		matrix.setCol(1, new BigIntegerMatrix(new BigInteger[][]{{BigInteger.valueOf(-6)}, {BigInteger.valueOf(-8)}}));
		assertArrayEquals(new BigInteger[][]{{BigInteger.valueOf(-5), BigInteger.valueOf(-6)}, {BigInteger.valueOf(-7), BigInteger.valueOf(-8)}}, matrix.copyGrid());
	}

	//! addRow()
	@Test
	public void testAddRow_array_nullArray(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertThrows(NullMatrixException.class, () -> {
			matrix.addRow((BigInteger[])null);
		});
	}

	@Test
	public void testAddRow_array_length0(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertThrows(InvalidGeometryException.class, () -> {
			matrix.addRow(new BigInteger[0]);
		});
	}

	@Test
	public void testAddRow_array_invalidArrayLength(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertThrows(InvalidGeometryException.class, () -> {
			matrix.addRow(new BigInteger[]{BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO});
		});
	}

	@Test
	public void testAddRow_array(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);
		matrix.addRow(new BigInteger[]{BigInteger.valueOf(-5), BigInteger.valueOf(-6)});

		assertArrayEquals(new BigInteger[][]{{BigInteger.valueOf(-1), BigInteger.valueOf(-2)}, {BigInteger.valueOf(-3), BigInteger.valueOf(-4)}, {BigInteger.valueOf(-5), BigInteger.valueOf(-6)}}, matrix.copyGrid());
	}

	@Test
	public void testAddRow_matrix_nullMatrix(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertThrows(NullMatrixException.class, () -> {
			matrix.addRow((BigIntegerMatrix)null);
		});
	}

	@Test
	public void testAddRow_matrix_multipleRows(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertThrows(InvalidGeometryException.class, () -> {
			matrix.addRow(new BigIntegerMatrix(new BigInteger[][]{{BigInteger.ZERO, BigInteger.ZERO}, {BigInteger.ZERO, BigInteger.ZERO}}));
		});
	}

	@Test
	public void testAddRow_matrix_noRows(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertThrows(InvalidGeometryException.class, () -> {
			matrix.addRow(new BigIntegerMatrix(new BigInteger[0][0]));
		});
	}

	@Test
	public void testAddRow_matrix_invalidLength(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertThrows(InvalidGeometryException.class, () -> {
			matrix.addRow(new BigIntegerMatrix(new BigInteger[][]{{BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO}}));
		});
	}

	@Test
	public void testAddRow_matrix(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);
		matrix.addRow(new BigIntegerMatrix(new BigInteger[][]{{BigInteger.valueOf(-5), BigInteger.valueOf(-6)}}));

		assertArrayEquals(new BigInteger[][]{{BigInteger.valueOf(-1), BigInteger.valueOf(-2)}, {BigInteger.valueOf(-3), BigInteger.valueOf(-4)}, {BigInteger.valueOf(-5), BigInteger.valueOf(-6)}}, matrix.copyGrid());
	}

	//! addCol()
	@Test
	public void testAddCol_array_nullArray(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertThrows(NullMatrixException.class, () -> {
			matrix.addCol((BigInteger[])null);
		});
	}

	@Test
	public void testAddCol_array_length0(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertThrows(InvalidGeometryException.class, () -> {
			matrix.addCol(new BigInteger[0]);
		});
	}

	@Test
	public void testAddCol_array_invalidArrayLength(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertThrows(InvalidGeometryException.class, () -> {
			matrix.addCol(new BigInteger[]{BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO});
		});
	}

	@Test
	public void testAddCol_array(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);
		matrix.addCol(new BigInteger[]{BigInteger.valueOf(-5), BigInteger.valueOf(-6)});

		assertArrayEquals(new BigInteger[][]{{BigInteger.valueOf(-1), BigInteger.valueOf(-2), BigInteger.valueOf(-5)}, {BigInteger.valueOf(-3), BigInteger.valueOf(-4), BigInteger.valueOf(-6)}}, matrix.copyGrid());
	}

	@Test
	public void testAddCol_matrix_nullMatrix(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertThrows(NullMatrixException.class, () -> {
			matrix.addCol((BigIntegerMatrix)null);
		});
	}

	@Test
	public void testAddCol_matrix_multipleCols(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertThrows(InvalidGeometryException.class, () -> {
			matrix.addCol(new BigIntegerMatrix(new BigInteger[][]{{BigInteger.ZERO, BigInteger.ZERO}}));
		});
	}

	@Test
	public void testAddCol_matrix_length0(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertThrows(InvalidGeometryException.class, () -> {
			matrix.addCol(new BigIntegerMatrix(new BigInteger[][]{{}}));
		});
	}

	@Test
	public void testAddCol_matrix_invalidLength(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertThrows(InvalidGeometryException.class, () -> {
			matrix.addCol(new BigIntegerMatrix(new BigInteger[][]{{BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO}}));
		});
	}

	@Test
	public void testAddCol_matrix(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);
		matrix.addCol(new BigIntegerMatrix(new BigInteger[][]{{BigInteger.valueOf(-5)}, {BigInteger.valueOf(-6)}}));

		assertArrayEquals(new BigInteger[][]{{BigInteger.valueOf(-1), BigInteger.valueOf(-2), BigInteger.valueOf(-5)}, {BigInteger.valueOf(-3), BigInteger.valueOf(-4), BigInteger.valueOf(-6)}}, matrix.copyGrid());
	}

	//! appendRight()
	@Test
	public void testAppendRight_nullMatrix(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertThrows(NullMatrixException.class, () -> {
			matrix.appendRight((BigIntegerMatrix)null);
		});
	}

	@Test
	public void testAppendRight_length0(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertThrows(InvalidGeometryException.class, () -> {
			matrix.appendRight(new BigIntegerMatrix(new BigInteger[0][0]));
		});
	}

	@Test
	public void testAppendRight_invalidLength(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertThrows(InvalidGeometryException.class, () -> {
			matrix.appendRight(new BigIntegerMatrix(new BigInteger[][]{{BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO}}));
		});
	}

	@Test
	public void testAppendRight(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);
		matrix = matrix.appendRight(matrix);

		assertArrayEquals(new BigInteger[][]{{BigInteger.valueOf(-1), BigInteger.valueOf(-2), BigInteger.valueOf(-1), BigInteger.valueOf(-2)}, {BigInteger.valueOf(-3), BigInteger.valueOf(-4), BigInteger.valueOf(-3), BigInteger.valueOf(-4)}}, matrix.copyGrid());
	}

	//! appendBottom()
	@Test
	public void testAppendBottom_nullMatrix(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertThrows(NullMatrixException.class, () -> {
			matrix.appendBottom((BigIntegerMatrix)null);
		});
	}

	@Test
	public void testAppendBottom_length0(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertThrows(InvalidGeometryException.class, () -> {
			matrix.appendBottom(new BigIntegerMatrix(new BigInteger[0][0]));
		});
	}

	@Test
	public void testAppendBottom_invalidLength(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertThrows(InvalidGeometryException.class, () -> {
			matrix.appendBottom(new BigIntegerMatrix(new BigInteger[][]{{BigInteger.ZERO}, {BigInteger.ZERO}, {BigInteger.ZERO}}));
		});
	}

	@Test
	public void testAppendBottom(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);
		matrix = matrix.appendBottom(matrix);

		assertArrayEquals(new BigInteger[][]{{BigInteger.valueOf(-1), BigInteger.valueOf(-2)}, {BigInteger.valueOf(-3), BigInteger.valueOf(-4)}, {BigInteger.valueOf(-1), BigInteger.valueOf(-2)}, {BigInteger.valueOf(-3), BigInteger.valueOf(-4)}}, matrix.copyGrid());
	}

	//! add()
	@Test
	public void testAdd_matrix_nullMatrix(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertThrows(NullMatrixException.class, () -> {
			matrix.add((BigIntegerMatrix)null);
		});
	}

	@Test
	public void testAdd_matrix_fewRows(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertThrows(InvalidGeometryException.class, () -> {
			matrix.add(new BigIntegerMatrix(new BigInteger[][]{{BigInteger.ZERO, BigInteger.ZERO}}));
		});
	}

	@Test
	public void testAdd_matrix_manyRows(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertThrows(InvalidGeometryException.class, () -> {
			matrix.add(new BigIntegerMatrix(new BigInteger[][]{{BigInteger.ZERO}, {BigInteger.ZERO}}));
		});
	}

	@Test
	public void testAdd_matrix_fewCols(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertThrows(InvalidGeometryException.class, () -> {
			matrix.add(new BigIntegerMatrix(new BigInteger[][]{{BigInteger.ZERO}}));
		});
	}

	@Test
	public void testAdd_matrix_manyCols(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertThrows(InvalidGeometryException.class, () -> {
			matrix.add(new BigIntegerMatrix(new BigInteger[][]{{BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO}, {BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO}}));
		});
	}

	@Test
	public void testAdd_matrix_size2(){
		BigIntegerMatrix addMatrix = new BigIntegerMatrix(new BigInteger[][]{{BigInteger.valueOf(-4), BigInteger.valueOf(-3)}, {BigInteger.valueOf(-2), BigInteger.valueOf(-1)}});
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);
		matrix = matrix.add(addMatrix);

		assertArrayEquals(new BigInteger[][]{{BigInteger.valueOf(-5), BigInteger.valueOf(-5)}, {BigInteger.valueOf(-5), BigInteger.valueOf(-5)}}, matrix.copyGrid());
	}

	@Test
	public void testAdd_matrix_size10(){
		BigIntegerMatrix addMatrix = new BigIntegerMatrix(new BigInteger[][]{
			{BigInteger.valueOf(-100), BigInteger.valueOf(-99), BigInteger.valueOf(-98), BigInteger.valueOf(-97), BigInteger.valueOf(-96), BigInteger.valueOf(-95), BigInteger.valueOf(-94), BigInteger.valueOf(-93), BigInteger.valueOf(-92), BigInteger.valueOf(-91)},
			{ BigInteger.valueOf(-90), BigInteger.valueOf(-89), BigInteger.valueOf(-88), BigInteger.valueOf(-87), BigInteger.valueOf(-86), BigInteger.valueOf(-85), BigInteger.valueOf(-84), BigInteger.valueOf(-83), BigInteger.valueOf(-82), BigInteger.valueOf(-81)},
			{ BigInteger.valueOf(-80), BigInteger.valueOf(-79), BigInteger.valueOf(-78), BigInteger.valueOf(-77), BigInteger.valueOf(-76), BigInteger.valueOf(-75), BigInteger.valueOf(-74), BigInteger.valueOf(-73), BigInteger.valueOf(-72), BigInteger.valueOf(-71)},
			{ BigInteger.valueOf(-70), BigInteger.valueOf(-69), BigInteger.valueOf(-68), BigInteger.valueOf(-67), BigInteger.valueOf(-66), BigInteger.valueOf(-65), BigInteger.valueOf(-64), BigInteger.valueOf(-63), BigInteger.valueOf(-62), BigInteger.valueOf(-61)},
			{ BigInteger.valueOf(-60), BigInteger.valueOf(-59), BigInteger.valueOf(-58), BigInteger.valueOf(-57), BigInteger.valueOf(-56), BigInteger.valueOf(-55), BigInteger.valueOf(-54), BigInteger.valueOf(-53), BigInteger.valueOf(-52), BigInteger.valueOf(-51)},
			{ BigInteger.valueOf(-50), BigInteger.valueOf(-49), BigInteger.valueOf(-48), BigInteger.valueOf(-47), BigInteger.valueOf(-46), BigInteger.valueOf(-45), BigInteger.valueOf(-44), BigInteger.valueOf(-43), BigInteger.valueOf(-42), BigInteger.valueOf(-41)},
			{ BigInteger.valueOf(-40), BigInteger.valueOf(-39), BigInteger.valueOf(-38), BigInteger.valueOf(-37), BigInteger.valueOf(-36), BigInteger.valueOf(-35), BigInteger.valueOf(-34), BigInteger.valueOf(-33), BigInteger.valueOf(-32), BigInteger.valueOf(-31)},
			{ BigInteger.valueOf(-30), BigInteger.valueOf(-29), BigInteger.valueOf(-28), BigInteger.valueOf(-27), BigInteger.valueOf(-26), BigInteger.valueOf(-25), BigInteger.valueOf(-24), BigInteger.valueOf(-23), BigInteger.valueOf(-22), BigInteger.valueOf(-21)},
			{ BigInteger.valueOf(-20), BigInteger.valueOf(-19), BigInteger.valueOf(-18), BigInteger.valueOf(-17), BigInteger.valueOf(-16), BigInteger.valueOf(-15), BigInteger.valueOf(-14), BigInteger.valueOf(-13), BigInteger.valueOf(-12), BigInteger.valueOf(-11)},
			{ BigInteger.valueOf(-10),  BigInteger.valueOf(-9),  BigInteger.valueOf(-8),  BigInteger.valueOf(-7),  BigInteger.valueOf(-6),  BigInteger.valueOf(-5),  BigInteger.valueOf(-4),  BigInteger.valueOf(-3),  BigInteger.valueOf(-2),  BigInteger.valueOf(-1)}
		});
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid10);
		matrix = matrix.add(addMatrix);

		assertArrayEquals(new BigInteger[][]{
			{BigInteger.valueOf(-101), BigInteger.valueOf(-101), BigInteger.valueOf(-101), BigInteger.valueOf(-101), BigInteger.valueOf(-101), BigInteger.valueOf(-101), BigInteger.valueOf(-101), BigInteger.valueOf(-101), BigInteger.valueOf(-101), BigInteger.valueOf(-101)},
			{BigInteger.valueOf(-101), BigInteger.valueOf(-101), BigInteger.valueOf(-101), BigInteger.valueOf(-101), BigInteger.valueOf(-101), BigInteger.valueOf(-101), BigInteger.valueOf(-101), BigInteger.valueOf(-101), BigInteger.valueOf(-101), BigInteger.valueOf(-101)},
			{BigInteger.valueOf(-101), BigInteger.valueOf(-101), BigInteger.valueOf(-101), BigInteger.valueOf(-101), BigInteger.valueOf(-101), BigInteger.valueOf(-101), BigInteger.valueOf(-101), BigInteger.valueOf(-101), BigInteger.valueOf(-101), BigInteger.valueOf(-101)},
			{BigInteger.valueOf(-101), BigInteger.valueOf(-101), BigInteger.valueOf(-101), BigInteger.valueOf(-101), BigInteger.valueOf(-101), BigInteger.valueOf(-101), BigInteger.valueOf(-101), BigInteger.valueOf(-101), BigInteger.valueOf(-101), BigInteger.valueOf(-101)},
			{BigInteger.valueOf(-101), BigInteger.valueOf(-101), BigInteger.valueOf(-101), BigInteger.valueOf(-101), BigInteger.valueOf(-101), BigInteger.valueOf(-101), BigInteger.valueOf(-101), BigInteger.valueOf(-101), BigInteger.valueOf(-101), BigInteger.valueOf(-101)},
			{BigInteger.valueOf(-101), BigInteger.valueOf(-101), BigInteger.valueOf(-101), BigInteger.valueOf(-101), BigInteger.valueOf(-101), BigInteger.valueOf(-101), BigInteger.valueOf(-101), BigInteger.valueOf(-101), BigInteger.valueOf(-101), BigInteger.valueOf(-101)},
			{BigInteger.valueOf(-101), BigInteger.valueOf(-101), BigInteger.valueOf(-101), BigInteger.valueOf(-101), BigInteger.valueOf(-101), BigInteger.valueOf(-101), BigInteger.valueOf(-101), BigInteger.valueOf(-101), BigInteger.valueOf(-101), BigInteger.valueOf(-101)},
			{BigInteger.valueOf(-101), BigInteger.valueOf(-101), BigInteger.valueOf(-101), BigInteger.valueOf(-101), BigInteger.valueOf(-101), BigInteger.valueOf(-101), BigInteger.valueOf(-101), BigInteger.valueOf(-101), BigInteger.valueOf(-101), BigInteger.valueOf(-101)},
			{BigInteger.valueOf(-101), BigInteger.valueOf(-101), BigInteger.valueOf(-101), BigInteger.valueOf(-101), BigInteger.valueOf(-101), BigInteger.valueOf(-101), BigInteger.valueOf(-101), BigInteger.valueOf(-101), BigInteger.valueOf(-101), BigInteger.valueOf(-101)},
			{BigInteger.valueOf(-101), BigInteger.valueOf(-101), BigInteger.valueOf(-101), BigInteger.valueOf(-101), BigInteger.valueOf(-101), BigInteger.valueOf(-101), BigInteger.valueOf(-101), BigInteger.valueOf(-101), BigInteger.valueOf(-101), BigInteger.valueOf(-101)}
		}, matrix.copyGrid());
	}

	@Test
	public void testAdd_scalar(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);
		matrix = matrix.add(BigInteger.ONE);

		assertArrayEquals(new BigInteger[][]{{BigInteger.ZERO, BigInteger.valueOf(-1)}, {BigInteger.valueOf(-2), BigInteger.valueOf(-3)}}, matrix.copyGrid());
	}

	//! subtract()
	@Test
	public void testSubtract_matrix_nullMatrix(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertThrows(NullMatrixException.class, () -> {
			matrix.subtract((BigIntegerMatrix)null);
		});
	}

	@Test
	public void testSubtract_matrix_fewRows(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertThrows(InvalidGeometryException.class, () -> {
			matrix.subtract(new BigIntegerMatrix(new BigInteger[][]{{BigInteger.ZERO, BigInteger.ZERO}}));
		});
	}

	@Test
	public void testSubtract_matrix_manyRows(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertThrows(InvalidGeometryException.class, () -> {
			matrix.subtract(new BigIntegerMatrix(new BigInteger[][]{{BigInteger.ZERO, BigInteger.ZERO}, {BigInteger.ZERO, BigInteger.ZERO}, {BigInteger.ZERO, BigInteger.ZERO}}));
		});
	}

	@Test
	public void testSubtract_matrix_fewCols(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertThrows(InvalidGeometryException.class, () -> {
			matrix.subtract(new BigIntegerMatrix(new BigInteger[][]{{BigInteger.ZERO}, {BigInteger.ZERO}}));
		});
	}

	@Test
	public void testSubtract_matrix_manyCols(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertThrows(InvalidGeometryException.class, () -> {
			matrix.subtract(new BigIntegerMatrix(new BigInteger[][]{{BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO}, {BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO}}));
		});
	}

	@Test
	public void testSubtract_matrix_size2(){
		BigIntegerMatrix subMatrix = new BigIntegerMatrix(new BigInteger[][]{{BigInteger.valueOf(-4), BigInteger.valueOf(-3)}, {BigInteger.valueOf(-2), BigInteger.valueOf(-1)}});
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);
		matrix = matrix.subtract(subMatrix);

		assertArrayEquals(new BigInteger[][]{{BigInteger.valueOf(3), BigInteger.valueOf(1)}, {BigInteger.valueOf(-1), BigInteger.valueOf(-3)}}, matrix.copyGrid());
	}

	@Test
	public void testSubtract_matrix_size10(){
		BigIntegerMatrix subMatrix = new BigIntegerMatrix(new BigInteger[][]{
			{BigInteger.valueOf(-100), BigInteger.valueOf(-99), BigInteger.valueOf(-98), BigInteger.valueOf(-97), BigInteger.valueOf(-96), BigInteger.valueOf(-95), BigInteger.valueOf(-94), BigInteger.valueOf(-93), BigInteger.valueOf(-92), BigInteger.valueOf(-91)},
			{ BigInteger.valueOf(-90), BigInteger.valueOf(-89), BigInteger.valueOf(-88), BigInteger.valueOf(-87), BigInteger.valueOf(-86), BigInteger.valueOf(-85), BigInteger.valueOf(-84), BigInteger.valueOf(-83), BigInteger.valueOf(-82), BigInteger.valueOf(-81)},
			{ BigInteger.valueOf(-80), BigInteger.valueOf(-79), BigInteger.valueOf(-78), BigInteger.valueOf(-77), BigInteger.valueOf(-76), BigInteger.valueOf(-75), BigInteger.valueOf(-74), BigInteger.valueOf(-73), BigInteger.valueOf(-72), BigInteger.valueOf(-71)},
			{ BigInteger.valueOf(-70), BigInteger.valueOf(-69), BigInteger.valueOf(-68), BigInteger.valueOf(-67), BigInteger.valueOf(-66), BigInteger.valueOf(-65), BigInteger.valueOf(-64), BigInteger.valueOf(-63), BigInteger.valueOf(-62), BigInteger.valueOf(-61)},
			{ BigInteger.valueOf(-60), BigInteger.valueOf(-59), BigInteger.valueOf(-58), BigInteger.valueOf(-57), BigInteger.valueOf(-56), BigInteger.valueOf(-55), BigInteger.valueOf(-54), BigInteger.valueOf(-53), BigInteger.valueOf(-52), BigInteger.valueOf(-51)},
			{ BigInteger.valueOf(-50), BigInteger.valueOf(-49), BigInteger.valueOf(-48), BigInteger.valueOf(-47), BigInteger.valueOf(-46), BigInteger.valueOf(-45), BigInteger.valueOf(-44), BigInteger.valueOf(-43), BigInteger.valueOf(-42), BigInteger.valueOf(-41)},
			{ BigInteger.valueOf(-40), BigInteger.valueOf(-39), BigInteger.valueOf(-38), BigInteger.valueOf(-37), BigInteger.valueOf(-36), BigInteger.valueOf(-35), BigInteger.valueOf(-34), BigInteger.valueOf(-33), BigInteger.valueOf(-32), BigInteger.valueOf(-31)},
			{ BigInteger.valueOf(-30), BigInteger.valueOf(-29), BigInteger.valueOf(-28), BigInteger.valueOf(-27), BigInteger.valueOf(-26), BigInteger.valueOf(-25), BigInteger.valueOf(-24), BigInteger.valueOf(-23), BigInteger.valueOf(-22), BigInteger.valueOf(-21)},
			{ BigInteger.valueOf(-20), BigInteger.valueOf(-19), BigInteger.valueOf(-18), BigInteger.valueOf(-17), BigInteger.valueOf(-16), BigInteger.valueOf(-15), BigInteger.valueOf(-14), BigInteger.valueOf(-13), BigInteger.valueOf(-12), BigInteger.valueOf(-11)},
			{ BigInteger.valueOf(-10),  BigInteger.valueOf(-9),  BigInteger.valueOf(-8),  BigInteger.valueOf(-7),  BigInteger.valueOf(-6),  BigInteger.valueOf(-5),  BigInteger.valueOf(-4),  BigInteger.valueOf(-3),  BigInteger.valueOf(-2),  BigInteger.valueOf(-1)}
		});
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid10);
		matrix = matrix.subtract(subMatrix);

		assertArrayEquals(new BigInteger[][]{
			{ BigInteger.valueOf(99),  BigInteger.valueOf(97),  BigInteger.valueOf(95),  BigInteger.valueOf(93),  BigInteger.valueOf(91),  BigInteger.valueOf(89),  BigInteger.valueOf(87),  BigInteger.valueOf(85),  BigInteger.valueOf(83),  BigInteger.valueOf(81)},
			{ BigInteger.valueOf(79),  BigInteger.valueOf(77),  BigInteger.valueOf(75),  BigInteger.valueOf(73),  BigInteger.valueOf(71),  BigInteger.valueOf(69),  BigInteger.valueOf(67),  BigInteger.valueOf(65),  BigInteger.valueOf(63),  BigInteger.valueOf(61)},
			{ BigInteger.valueOf(59),  BigInteger.valueOf(57),  BigInteger.valueOf(55),  BigInteger.valueOf(53),  BigInteger.valueOf(51),  BigInteger.valueOf(49),  BigInteger.valueOf(47),  BigInteger.valueOf(45),  BigInteger.valueOf(43),  BigInteger.valueOf(41)},
			{ BigInteger.valueOf(39),  BigInteger.valueOf(37),  BigInteger.valueOf(35),  BigInteger.valueOf(33),  BigInteger.valueOf(31),  BigInteger.valueOf(29),  BigInteger.valueOf(27),  BigInteger.valueOf(25),  BigInteger.valueOf(23),  BigInteger.valueOf(21)},
			{ BigInteger.valueOf(19),  BigInteger.valueOf(17),  BigInteger.valueOf(15),  BigInteger.valueOf(13),  BigInteger.valueOf(11),   BigInteger.valueOf(9),   BigInteger.valueOf(7),   BigInteger.valueOf(5),   BigInteger.valueOf(3),  BigInteger.valueOf(1)},
			{ BigInteger.valueOf(-1),  BigInteger.valueOf(-3),  BigInteger.valueOf(-5),  BigInteger.valueOf(-7),  BigInteger.valueOf(-9), BigInteger.valueOf(-11), BigInteger.valueOf(-13), BigInteger.valueOf(-15), BigInteger.valueOf(-17), BigInteger.valueOf(-19)},
			{BigInteger.valueOf(-21), BigInteger.valueOf(-23), BigInteger.valueOf(-25), BigInteger.valueOf(-27), BigInteger.valueOf(-29), BigInteger.valueOf(-31), BigInteger.valueOf(-33), BigInteger.valueOf(-35), BigInteger.valueOf(-37), BigInteger.valueOf(-39)},
			{BigInteger.valueOf(-41), BigInteger.valueOf(-43), BigInteger.valueOf(-45), BigInteger.valueOf(-47), BigInteger.valueOf(-49), BigInteger.valueOf(-51), BigInteger.valueOf(-53), BigInteger.valueOf(-55), BigInteger.valueOf(-57), BigInteger.valueOf(-59)},
			{BigInteger.valueOf(-61), BigInteger.valueOf(-63), BigInteger.valueOf(-65), BigInteger.valueOf(-67), BigInteger.valueOf(-69), BigInteger.valueOf(-71), BigInteger.valueOf(-73), BigInteger.valueOf(-75), BigInteger.valueOf(-77), BigInteger.valueOf(-79)},
			{BigInteger.valueOf(-81), BigInteger.valueOf(-83), BigInteger.valueOf(-85), BigInteger.valueOf(-87), BigInteger.valueOf(-89), BigInteger.valueOf(-91), BigInteger.valueOf(-93), BigInteger.valueOf(-95), BigInteger.valueOf(-97), BigInteger.valueOf(-99)}
		}, matrix.copyGrid());
	}

	@Test
	public void testSubtract_scalar(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);
		matrix = matrix.subtract(BigInteger.ONE);

		assertArrayEquals(new BigInteger[][]{{BigInteger.valueOf(-2), BigInteger.valueOf(-3)}, {BigInteger.valueOf(-4), BigInteger.valueOf(-5)}}, matrix.copyGrid());
	}

	//! multiply()
	@Test
	public void testMultiply_matrix_nullMatrix(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertThrows(NullMatrixException.class, () -> {
			matrix.multiply((BigIntegerMatrix)null);
		});
	}

	@Test
	public void testMultiply_matrix_manyRows(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertThrows(InvalidGeometryException.class, () -> {
			matrix.multiply(new BigIntegerMatrix(new BigInteger[][]{{BigInteger.ZERO, BigInteger.ZERO}, {BigInteger.ZERO, BigInteger.ZERO}, {BigInteger.ZERO, BigInteger.ZERO}}));
		});
	}

	@Test
	public void testMultiply_matrix_fewRows(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertThrows(InvalidGeometryException.class, () -> {
			matrix.multiply(new BigIntegerMatrix(new BigInteger[][]{{BigInteger.ZERO, BigInteger.ZERO}}));
		});
	}

	@Test
	public void testMultiply_matrix_square(){
		BigIntegerMatrix mulMatrix = new BigIntegerMatrix(new BigInteger[][]{{BigInteger.valueOf(1), BigInteger.valueOf(2)}, {BigInteger.valueOf(3), BigInteger.valueOf(4)}});
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);
		matrix = matrix.multiply(mulMatrix);

		assertArrayEquals(new BigInteger[][]{{BigInteger.valueOf(-7), BigInteger.valueOf(-10)}, {BigInteger.valueOf(-15), BigInteger.valueOf(-22)}}, matrix.copyGrid());
	}

	@Test
	public void testMultiply_matrix_rectangle(){
		BigIntegerMatrix mulMatrix = new BigIntegerMatrix(new BigInteger[][]{{BigInteger.valueOf(1), BigInteger.valueOf(2), BigInteger.valueOf(3)}, {BigInteger.valueOf(4), BigInteger.valueOf(5), BigInteger.valueOf(6)}});
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);
		matrix = matrix.multiply(mulMatrix);

		assertArrayEquals(new BigInteger[][]{{BigInteger.valueOf(-9), BigInteger.valueOf(-12), BigInteger.valueOf(-15)}, {BigInteger.valueOf(-19), BigInteger.valueOf(-26), BigInteger.valueOf(-33)}}, matrix.copyGrid());
	}

	@Test
	public void testMultiply_scalar(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);
		matrix = matrix.multiply(BigInteger.valueOf(2));

		assertArrayEquals(new BigInteger[][]{{BigInteger.valueOf(-2), BigInteger.valueOf(-4)}, {BigInteger.valueOf(-6), BigInteger.valueOf(-8)}}, matrix.copyGrid());
	}

	//! pow
	@Test
	public void testPow_rectangle(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(new BigInteger[][]{{BigInteger.valueOf(1), BigInteger.valueOf(2), BigInteger.valueOf(3)}, {BigInteger.valueOf(4), BigInteger.valueOf(5), BigInteger.valueOf(6)}});

		assertThrows(InvalidGeometryException.class, () -> {
			matrix.pow(2);
		});
	}

	@Test
	public void testPow_negative(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertThrows(InvalidScalarException.class, () -> {
			matrix.pow(-1);
		});
	}

	@Test
	public void testPow_0(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		BigIntegerMatrix result = matrix.pow(0);

		assertEquals(new BigIntegerMatrix(2, 2, BigInteger.valueOf(1)), result);
	}

	@Test
	public void testPow_2(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		BigIntegerMatrix result = matrix.pow(2);

		assertEquals(new BigIntegerMatrix(new BigInteger[][]{{BigInteger.valueOf(7), BigInteger.valueOf(10)}, {BigInteger.valueOf(15), BigInteger.valueOf(22)}}), result);
	}

	@Test
	public void testPow_3(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		BigIntegerMatrix result = matrix.pow(3);

		assertEquals(new BigIntegerMatrix(new BigInteger[][]{{BigInteger.valueOf(-37), BigInteger.valueOf(-54)}, {BigInteger.valueOf(-81), BigInteger.valueOf(-118)}}), result);
	}
	
	//! dotProduct()
	@Test
	public void testDotProduct_nullMatrix(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertThrows(NullMatrixException.class, () -> {
			matrix.dotProduct((BigIntegerMatrix)null);
		});
	}

	@Test
	public void testDotProduct_fewRows(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertThrows(InvalidGeometryException.class, () -> {
			matrix.dotProduct(new BigIntegerMatrix(new BigInteger[][]{{BigInteger.ZERO, BigInteger.ZERO}}));
		});
	}

	@Test
	public void testDotProduct_manyRows(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertThrows(InvalidGeometryException.class, () -> {
			matrix.dotProduct(new BigIntegerMatrix(new BigInteger[][]{{BigInteger.ZERO, BigInteger.ZERO}, {BigInteger.ZERO, BigInteger.ZERO}, {BigInteger.ZERO, BigInteger.ZERO}}));
		});
	}

	@Test
	public void testDotProduct_size2(){
		BigIntegerMatrix dotMatrix = new BigIntegerMatrix(new BigInteger[][]{{BigInteger.valueOf(1), BigInteger.valueOf(2)}, {BigInteger.valueOf(3), BigInteger.valueOf(4)}});
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);
		BigInteger result = matrix.dotProduct(dotMatrix);

		assertEquals(BigInteger.valueOf(-54), result);
	}

	@Test
	public void testDotProduct_size10(){
		BigIntegerMatrix dotMatrix = new BigIntegerMatrix(new BigInteger[][]{
			{ BigInteger.valueOf(1),  BigInteger.valueOf(2),  BigInteger.valueOf(3),  BigInteger.valueOf(4),  BigInteger.valueOf(5),  BigInteger.valueOf(6),  BigInteger.valueOf(7),  BigInteger.valueOf(8),  BigInteger.valueOf(9), BigInteger.valueOf(10)},
			{BigInteger.valueOf(11), BigInteger.valueOf(12), BigInteger.valueOf(13), BigInteger.valueOf(14), BigInteger.valueOf(15), BigInteger.valueOf(16), BigInteger.valueOf(17), BigInteger.valueOf(18), BigInteger.valueOf(19), BigInteger.valueOf(20)},
			{BigInteger.valueOf(21), BigInteger.valueOf(22), BigInteger.valueOf(23), BigInteger.valueOf(24), BigInteger.valueOf(25), BigInteger.valueOf(26), BigInteger.valueOf(27), BigInteger.valueOf(28), BigInteger.valueOf(29), BigInteger.valueOf(30)},
			{BigInteger.valueOf(31), BigInteger.valueOf(32), BigInteger.valueOf(33), BigInteger.valueOf(34), BigInteger.valueOf(35), BigInteger.valueOf(36), BigInteger.valueOf(37), BigInteger.valueOf(38), BigInteger.valueOf(39), BigInteger.valueOf(40)},
			{BigInteger.valueOf(41), BigInteger.valueOf(42), BigInteger.valueOf(43), BigInteger.valueOf(44), BigInteger.valueOf(45), BigInteger.valueOf(46), BigInteger.valueOf(47), BigInteger.valueOf(48), BigInteger.valueOf(49), BigInteger.valueOf(50)},
			{BigInteger.valueOf(51), BigInteger.valueOf(52), BigInteger.valueOf(53), BigInteger.valueOf(54), BigInteger.valueOf(55), BigInteger.valueOf(56), BigInteger.valueOf(57), BigInteger.valueOf(58), BigInteger.valueOf(59), BigInteger.valueOf(60)},
			{BigInteger.valueOf(61), BigInteger.valueOf(62), BigInteger.valueOf(63), BigInteger.valueOf(64), BigInteger.valueOf(65), BigInteger.valueOf(66), BigInteger.valueOf(67), BigInteger.valueOf(68), BigInteger.valueOf(69), BigInteger.valueOf(70)},
			{BigInteger.valueOf(71), BigInteger.valueOf(72), BigInteger.valueOf(73), BigInteger.valueOf(74), BigInteger.valueOf(75), BigInteger.valueOf(76), BigInteger.valueOf(77), BigInteger.valueOf(78), BigInteger.valueOf(79), BigInteger.valueOf(80)},
			{BigInteger.valueOf(81), BigInteger.valueOf(82), BigInteger.valueOf(83), BigInteger.valueOf(84), BigInteger.valueOf(85), BigInteger.valueOf(86), BigInteger.valueOf(87), BigInteger.valueOf(88), BigInteger.valueOf(89), BigInteger.valueOf(90)},
			{BigInteger.valueOf(91), BigInteger.valueOf(92), BigInteger.valueOf(93), BigInteger.valueOf(94), BigInteger.valueOf(95), BigInteger.valueOf(96), BigInteger.valueOf(97), BigInteger.valueOf(98), BigInteger.valueOf(99), BigInteger.valueOf(100)}
		});
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid10);
		BigInteger result = matrix.dotProduct(dotMatrix);

		assertEquals(BigInteger.valueOf(-2632750), result);
	}

	//! hadamardProduct()
	@Test
	public void testHadamardProduct_nullMatrix(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertThrows(NullMatrixException.class, () -> {
			matrix.hadamardProduct((BigIntegerMatrix)null);
		});
	}

	@Test
	public void testHadamardProduct_fewRows(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertThrows(InvalidGeometryException.class, () -> {
			matrix.hadamardProduct(new BigIntegerMatrix(new BigInteger[][]{{BigInteger.ZERO, BigInteger.ZERO}}));
		});
	}

	@Test
	public void testHadamardProduct_manyRows(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertThrows(InvalidGeometryException.class, () -> {
			matrix.hadamardProduct(new BigIntegerMatrix(new BigInteger[][]{{BigInteger.ZERO, BigInteger.ZERO}, {BigInteger.ZERO, BigInteger.ZERO}, {BigInteger.ZERO, BigInteger.ZERO}}));
		});
	}

	@Test
	public void testHadamardProduct_fewCols(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertThrows(InvalidGeometryException.class, () -> {
			matrix.hadamardProduct(new BigIntegerMatrix(new BigInteger[][]{{BigInteger.ZERO}, {BigInteger.ZERO}}));
		});
	}

	@Test
	public void testHadamardProduct_manyCols(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertThrows(InvalidGeometryException.class, () -> {
			matrix.hadamardProduct(new BigIntegerMatrix(new BigInteger[][]{{BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO}, {BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO}}));
		});
	}

	@Test
	public void testHadamardProduct_size2(){
		BigIntegerMatrix hadMatrix = new BigIntegerMatrix(new BigInteger[][]{{BigInteger.valueOf(1), BigInteger.valueOf(2)}, {BigInteger.valueOf(3), BigInteger.valueOf(4)}});
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);
		BigIntegerMatrix result = matrix.hadamardProduct(hadMatrix);

		assertArrayEquals(new BigInteger[][]{{BigInteger.valueOf(-1), BigInteger.valueOf(-4)}, {BigInteger.valueOf(-9), BigInteger.valueOf(-16)}}, result.copyGrid());
	}

	@Test
	public void testHadamardProduct_size10(){
		BigIntegerMatrix hadMatrix = new BigIntegerMatrix(new BigInteger[][]{
			{ BigInteger.valueOf(1),  BigInteger.valueOf(2),  BigInteger.valueOf(3),  BigInteger.valueOf(4),  BigInteger.valueOf(5),  BigInteger.valueOf(6),  BigInteger.valueOf(7),  BigInteger.valueOf(8),  BigInteger.valueOf(9), BigInteger.valueOf(10)},
			{BigInteger.valueOf(11), BigInteger.valueOf(12), BigInteger.valueOf(13), BigInteger.valueOf(14), BigInteger.valueOf(15), BigInteger.valueOf(16), BigInteger.valueOf(17), BigInteger.valueOf(18), BigInteger.valueOf(19), BigInteger.valueOf(20)},
			{BigInteger.valueOf(21), BigInteger.valueOf(22), BigInteger.valueOf(23), BigInteger.valueOf(24), BigInteger.valueOf(25), BigInteger.valueOf(26), BigInteger.valueOf(27), BigInteger.valueOf(28), BigInteger.valueOf(29), BigInteger.valueOf(30)},
			{BigInteger.valueOf(31), BigInteger.valueOf(32), BigInteger.valueOf(33), BigInteger.valueOf(34), BigInteger.valueOf(35), BigInteger.valueOf(36), BigInteger.valueOf(37), BigInteger.valueOf(38), BigInteger.valueOf(39), BigInteger.valueOf(40)},
			{BigInteger.valueOf(41), BigInteger.valueOf(42), BigInteger.valueOf(43), BigInteger.valueOf(44), BigInteger.valueOf(45), BigInteger.valueOf(46), BigInteger.valueOf(47), BigInteger.valueOf(48), BigInteger.valueOf(49), BigInteger.valueOf(50)},
			{BigInteger.valueOf(51), BigInteger.valueOf(52), BigInteger.valueOf(53), BigInteger.valueOf(54), BigInteger.valueOf(55), BigInteger.valueOf(56), BigInteger.valueOf(57), BigInteger.valueOf(58), BigInteger.valueOf(59), BigInteger.valueOf(60)},
			{BigInteger.valueOf(61), BigInteger.valueOf(62), BigInteger.valueOf(63), BigInteger.valueOf(64), BigInteger.valueOf(65), BigInteger.valueOf(66), BigInteger.valueOf(67), BigInteger.valueOf(68), BigInteger.valueOf(69), BigInteger.valueOf(70)},
			{BigInteger.valueOf(71), BigInteger.valueOf(72), BigInteger.valueOf(73), BigInteger.valueOf(74), BigInteger.valueOf(75), BigInteger.valueOf(76), BigInteger.valueOf(77), BigInteger.valueOf(78), BigInteger.valueOf(79), BigInteger.valueOf(80)},
			{BigInteger.valueOf(81), BigInteger.valueOf(82), BigInteger.valueOf(83), BigInteger.valueOf(84), BigInteger.valueOf(85), BigInteger.valueOf(86), BigInteger.valueOf(87), BigInteger.valueOf(88), BigInteger.valueOf(89), BigInteger.valueOf(90)},
			{BigInteger.valueOf(91), BigInteger.valueOf(92), BigInteger.valueOf(93), BigInteger.valueOf(94), BigInteger.valueOf(95), BigInteger.valueOf(96), BigInteger.valueOf(97), BigInteger.valueOf(98), BigInteger.valueOf(99), BigInteger.valueOf(100)}
		});
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid10);
		BigIntegerMatrix result = matrix.hadamardProduct(hadMatrix);

		assertArrayEquals(new BigInteger[][]{
			{   BigInteger.valueOf(-1),    BigInteger.valueOf(-4),    BigInteger.valueOf(-9),   BigInteger.valueOf(-16),   BigInteger.valueOf(-25),   BigInteger.valueOf(-36),   BigInteger.valueOf(-49),   BigInteger.valueOf(-64),   BigInteger.valueOf(-81),  BigInteger.valueOf(-100)},
			{ BigInteger.valueOf(-121),  BigInteger.valueOf(-144),  BigInteger.valueOf(-169),  BigInteger.valueOf(-196),  BigInteger.valueOf(-225),  BigInteger.valueOf(-256),  BigInteger.valueOf(-289),  BigInteger.valueOf(-324),  BigInteger.valueOf(-361),  BigInteger.valueOf(-400)},
			{ BigInteger.valueOf(-441),  BigInteger.valueOf(-484),  BigInteger.valueOf(-529),  BigInteger.valueOf(-576),  BigInteger.valueOf(-625),  BigInteger.valueOf(-676),  BigInteger.valueOf(-729),  BigInteger.valueOf(-784),  BigInteger.valueOf(-841),  BigInteger.valueOf(-900)},
			{ BigInteger.valueOf(-961), BigInteger.valueOf(-1024), BigInteger.valueOf(-1089), BigInteger.valueOf(-1156), BigInteger.valueOf(-1225), BigInteger.valueOf(-1296), BigInteger.valueOf(-1369), BigInteger.valueOf(-1444), BigInteger.valueOf(-1521), BigInteger.valueOf(-1600)},
			{BigInteger.valueOf(-1681), BigInteger.valueOf(-1764), BigInteger.valueOf(-1849), BigInteger.valueOf(-1936), BigInteger.valueOf(-2025), BigInteger.valueOf(-2116), BigInteger.valueOf(-2209), BigInteger.valueOf(-2304), BigInteger.valueOf(-2401), BigInteger.valueOf(-2500)},
			{BigInteger.valueOf(-2601), BigInteger.valueOf(-2704), BigInteger.valueOf(-2809), BigInteger.valueOf(-2916), BigInteger.valueOf(-3025), BigInteger.valueOf(-3136), BigInteger.valueOf(-3249), BigInteger.valueOf(-3364), BigInteger.valueOf(-3481), BigInteger.valueOf(-3600)},
			{BigInteger.valueOf(-3721), BigInteger.valueOf(-3844), BigInteger.valueOf(-3969), BigInteger.valueOf(-4096), BigInteger.valueOf(-4225), BigInteger.valueOf(-4356), BigInteger.valueOf(-4489), BigInteger.valueOf(-4624), BigInteger.valueOf(-4761), BigInteger.valueOf(-4900)},
			{BigInteger.valueOf(-5041), BigInteger.valueOf(-5184), BigInteger.valueOf(-5329), BigInteger.valueOf(-5476), BigInteger.valueOf(-5625), BigInteger.valueOf(-5776), BigInteger.valueOf(-5929), BigInteger.valueOf(-6084), BigInteger.valueOf(-6241), BigInteger.valueOf(-6400)},
			{BigInteger.valueOf(-6561), BigInteger.valueOf(-6724), BigInteger.valueOf(-6889), BigInteger.valueOf(-7056), BigInteger.valueOf(-7225), BigInteger.valueOf(-7396), BigInteger.valueOf(-7569), BigInteger.valueOf(-7744), BigInteger.valueOf(-7921), BigInteger.valueOf(-8100)},
			{BigInteger.valueOf(-8281), BigInteger.valueOf(-8464), BigInteger.valueOf(-8649), BigInteger.valueOf(-8836), BigInteger.valueOf(-9025), BigInteger.valueOf(-9216), BigInteger.valueOf(-9409), BigInteger.valueOf(-9604), BigInteger.valueOf(-9801), BigInteger.valueOf(-10000)}
		}, result.copyGrid());
	}

	//! transpose()
	@Test
	public void testTranspose_size0(){
		BigIntegerMatrix matrix = new BigIntegerMatrix();

		BigIntegerMatrix result = matrix.transpose();

		assertEquals(new BigIntegerMatrix(), result);
	}

	@Test
	public void testTranspose_size0x2(){
		BigInteger[][] grid = new BigInteger[0][2];
		BigIntegerMatrix matrix = new BigIntegerMatrix(grid);

		assertArrayEquals(new BigInteger[0][0], matrix.transpose().copyGrid());
	}

	@Test
	public void testTranspose_size2x0(){
		BigInteger[][] grid = new BigInteger[2][0];
		BigIntegerMatrix matrix = new BigIntegerMatrix(grid);

		assertArrayEquals(new BigInteger[0][0], matrix.transpose().copyGrid());
	}

	@Test
	public void testTranspose_size2(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertArrayEquals(new BigInteger[][]{{BigInteger.valueOf(-1), BigInteger.valueOf(-3)}, {BigInteger.valueOf(-2), BigInteger.valueOf(-4)}}, matrix.transpose().copyGrid());
	}

	@Test
	public void testTranspose_size10(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid10);

		assertArrayEquals(new BigInteger[][]{
			{ BigInteger.valueOf(-1), BigInteger.valueOf(-11), BigInteger.valueOf(-21), BigInteger.valueOf(-31), BigInteger.valueOf(-41), BigInteger.valueOf(-51), BigInteger.valueOf(-61), BigInteger.valueOf(-71), BigInteger.valueOf(-81), BigInteger.valueOf(-91)},
			{ BigInteger.valueOf(-2), BigInteger.valueOf(-12), BigInteger.valueOf(-22), BigInteger.valueOf(-32), BigInteger.valueOf(-42), BigInteger.valueOf(-52), BigInteger.valueOf(-62), BigInteger.valueOf(-72), BigInteger.valueOf(-82), BigInteger.valueOf(-92)},
			{ BigInteger.valueOf(-3), BigInteger.valueOf(-13), BigInteger.valueOf(-23), BigInteger.valueOf(-33), BigInteger.valueOf(-43), BigInteger.valueOf(-53), BigInteger.valueOf(-63), BigInteger.valueOf(-73), BigInteger.valueOf(-83), BigInteger.valueOf(-93)},
			{ BigInteger.valueOf(-4), BigInteger.valueOf(-14), BigInteger.valueOf(-24), BigInteger.valueOf(-34), BigInteger.valueOf(-44), BigInteger.valueOf(-54), BigInteger.valueOf(-64), BigInteger.valueOf(-74), BigInteger.valueOf(-84), BigInteger.valueOf(-94)},
			{ BigInteger.valueOf(-5), BigInteger.valueOf(-15), BigInteger.valueOf(-25), BigInteger.valueOf(-35), BigInteger.valueOf(-45), BigInteger.valueOf(-55), BigInteger.valueOf(-65), BigInteger.valueOf(-75), BigInteger.valueOf(-85), BigInteger.valueOf(-95)},
			{ BigInteger.valueOf(-6), BigInteger.valueOf(-16), BigInteger.valueOf(-26), BigInteger.valueOf(-36), BigInteger.valueOf(-46), BigInteger.valueOf(-56), BigInteger.valueOf(-66), BigInteger.valueOf(-76), BigInteger.valueOf(-86), BigInteger.valueOf(-96)},
			{ BigInteger.valueOf(-7), BigInteger.valueOf(-17), BigInteger.valueOf(-27), BigInteger.valueOf(-37), BigInteger.valueOf(-47), BigInteger.valueOf(-57), BigInteger.valueOf(-67), BigInteger.valueOf(-77), BigInteger.valueOf(-87), BigInteger.valueOf(-97)},
			{ BigInteger.valueOf(-8), BigInteger.valueOf(-18), BigInteger.valueOf(-28), BigInteger.valueOf(-38), BigInteger.valueOf(-48), BigInteger.valueOf(-58), BigInteger.valueOf(-68), BigInteger.valueOf(-78), BigInteger.valueOf(-88), BigInteger.valueOf(-98)},
			{ BigInteger.valueOf(-9), BigInteger.valueOf(-19), BigInteger.valueOf(-29), BigInteger.valueOf(-39), BigInteger.valueOf(-49), BigInteger.valueOf(-59), BigInteger.valueOf(-69), BigInteger.valueOf(-79), BigInteger.valueOf(-89), BigInteger.valueOf(-99)},
			{BigInteger.valueOf(-10), BigInteger.valueOf(-20), BigInteger.valueOf(-30), BigInteger.valueOf(-40), BigInteger.valueOf(-50), BigInteger.valueOf(-60), BigInteger.valueOf(-70), BigInteger.valueOf(-80), BigInteger.valueOf(-90), BigInteger.valueOf(-100)}
		}, matrix.transpose().copyGrid());
	}

	@Test
	public void testTranspose_size2x10(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2x10);

		assertArrayEquals(new BigInteger[][]{
			{BigInteger.valueOf(-1), BigInteger.valueOf(-11)},
			{BigInteger.valueOf(-2), BigInteger.valueOf(-12)},
			{BigInteger.valueOf(-3), BigInteger.valueOf(-13)},
			{BigInteger.valueOf(-4), BigInteger.valueOf(-14)},
			{BigInteger.valueOf(-5), BigInteger.valueOf(-15)},
			{BigInteger.valueOf(-6), BigInteger.valueOf(-16)},
			{BigInteger.valueOf(-7), BigInteger.valueOf(-17)},
			{BigInteger.valueOf(-8), BigInteger.valueOf(-18)},
			{BigInteger.valueOf(-9), BigInteger.valueOf(-19)},
			{BigInteger.valueOf(-10), BigInteger.valueOf(-20)}
		}, matrix.transpose().copyGrid());
	}

	@Test
	public void testTranspose_size10x2(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid10x2);

		assertArrayEquals(new BigInteger[][]{
			{BigInteger.valueOf(-1), BigInteger.valueOf(-3), BigInteger.valueOf(-5), BigInteger.valueOf(-7),  BigInteger.valueOf(-9), BigInteger.valueOf(-11), BigInteger.valueOf(-13), BigInteger.valueOf(-15), BigInteger.valueOf(-17), BigInteger.valueOf(-19)},
			{BigInteger.valueOf(-2), BigInteger.valueOf(-4), BigInteger.valueOf(-6), BigInteger.valueOf(-8), BigInteger.valueOf(-10), BigInteger.valueOf(-12), BigInteger.valueOf(-14), BigInteger.valueOf(-16), BigInteger.valueOf(-18), BigInteger.valueOf(-20)}
		}, matrix.transpose().copyGrid());
	}

	//! determinant() / det()
	@Test
	public void testDeterminant_size0(){
		BigIntegerMatrix matrix = new BigIntegerMatrix();

		assertThrows(InvalidGeometryException.class, () -> {
			matrix.determinant();
		});
		assertThrows(InvalidGeometryException.class, () -> {
			matrix.det();
		});
	}

	@Test
	public void testDeterminant_size1(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(new BigInteger[][]{{BigInteger.ONE}});

		assertEquals(BigInteger.ONE, matrix.determinant());
		assertEquals(BigInteger.ONE, matrix.det());
	}

	@Test
	public void testDeterminant_size2(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertEquals(BigInteger.valueOf(-2), matrix.determinant());
		assertEquals(BigInteger.valueOf(-2), matrix.det());
	}

	@Test
	public void testDeterminant_size3(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(new BigInteger[][]{{BigInteger.valueOf(-1), BigInteger.valueOf(-2), BigInteger.valueOf(-3)}, {BigInteger.valueOf(-4), BigInteger.valueOf(-5), BigInteger.valueOf(-6)}, {BigInteger.valueOf(-7), BigInteger.valueOf(-8), BigInteger.valueOf(-9)}});

		assertEquals(BigInteger.ZERO, matrix.determinant());
		assertEquals(BigInteger.ZERO, matrix.det());
	}

	@Test
	public void testDeterminant_size10(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid10);

		assertEquals(BigInteger.ZERO, matrix.determinant());
		assertEquals(BigInteger.ZERO, matrix.det());
	}

	@Test
	public void testDeterminant_size2x10(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2x10);

		assertThrows(InvalidGeometryException.class, () -> {
			matrix.determinant();
		});
		assertThrows(InvalidGeometryException.class, () -> {
			matrix.det();
		});
	}

	@Test
	public void testDeterminant_size10x2(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid10x2);

		assertThrows(InvalidGeometryException.class, () -> {
			matrix.determinant();
		});
		assertThrows(InvalidGeometryException.class, () -> {
			matrix.det();
		});
	}

	//! cofactor() / cof()
	@Test
	public void testCofactor_size0(){
		BigIntegerMatrix matrix = new BigIntegerMatrix();

		assertThrows(InvalidGeometryException.class, () -> {
			matrix.cofactor();
		});
		assertThrows(InvalidGeometryException.class, () -> {
			matrix.cof();
		});
	}

	@Test
	public void testCofactor_size1(){
		BigInteger[][] expectedGrid = new BigInteger[][]{{BigInteger.ONE}};
		BigIntegerMatrix matrix = new BigIntegerMatrix(new BigInteger[][]{{BigInteger.valueOf(-1)}});

		assertArrayEquals(expectedGrid, matrix.cofactor().copyGrid());
		assertArrayEquals(expectedGrid, matrix.cof().copyGrid());
	}

	@Test
	public void testCofactor_size2(){
		BigInteger[][] expectedGrid = new BigInteger[][]{{BigInteger.valueOf(-4), BigInteger.valueOf(3)}, {BigInteger.valueOf(2), BigInteger.valueOf(-1)}};
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertArrayEquals(expectedGrid, matrix.cofactor().copyGrid());
		assertArrayEquals(expectedGrid, matrix.cof().copyGrid());
	}

	@Test
	public void testCofactor_size10(){
		BigInteger[][] expectedGrid = new BigInteger[][]{
			{BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO},
			{BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO},
			{BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO},
			{BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO},
			{BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO},
			{BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO},
			{BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO},
			{BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO},
			{BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO},
			{BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO},
		};
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid10);

		assertArrayEquals(expectedGrid, matrix.cofactor().copyGrid());
		assertArrayEquals(expectedGrid, matrix.cof().copyGrid());
	}

	@Test
	public void testCofactor_size2x10(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2x10);

		assertThrows(InvalidGeometryException.class, () -> {
			matrix.cofactor();
		});
		assertThrows(InvalidGeometryException.class, () -> {
			matrix.cof();
		});
	}

	@Test
	public void testCofactor_size10x2(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid10x2);

		assertThrows(InvalidGeometryException.class, () -> {
			matrix.cofactor();
		});
		assertThrows(InvalidGeometryException.class, () -> {
			matrix.cof();
		});
	}

	//! adjoint() / adj()
	@Test
	public void testAdjoint_size0(){
		BigIntegerMatrix matrix = new BigIntegerMatrix();

		assertThrows(InvalidGeometryException.class, () -> {
			matrix.adjoint();
		});
		assertThrows(InvalidGeometryException.class, () -> {
			matrix.adj();
		});
	}

	@Test
	public void testAdjoint_size1(){
		BigInteger[][] expectedGrid = new BigInteger[][]{{BigInteger.ONE}};
		BigIntegerMatrix matrix = new BigIntegerMatrix(new BigInteger[][]{{BigInteger.valueOf(-1)}});

		assertArrayEquals(expectedGrid, matrix.adjoint().copyGrid());
		assertArrayEquals(expectedGrid, matrix.adj().copyGrid());
	}

	@Test
	public void testAdjoint_size2(){
		BigInteger[][] expectedGrid = new BigInteger[][]{{BigInteger.valueOf(-4), BigInteger.valueOf(2)}, {BigInteger.valueOf(3), BigInteger.valueOf(-1)}};
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertArrayEquals(expectedGrid, matrix.adjoint().copyGrid());
		assertArrayEquals(expectedGrid, matrix.adj().copyGrid());
	}

	@Test
	public void testAdjoint_size10(){
		BigInteger[][] expectedGrid = new BigInteger[][]{
			{BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO},
			{BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO},
			{BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO},
			{BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO},
			{BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO},
			{BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO},
			{BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO},
			{BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO},
			{BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO},
			{BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO}
		};
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid10);

		assertArrayEquals(expectedGrid, matrix.adjoint().copyGrid());
		assertArrayEquals(expectedGrid, matrix.adj().copyGrid());
	}

	@Test
	public void testAdjoint_size2x10(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2x10);

		assertThrows(InvalidGeometryException.class, () -> {
			matrix.adjoint();
		});
		assertThrows(InvalidGeometryException.class, () -> {
			matrix.adj();
		});
	}

	@Test
	public void testAdjoint_size10x2(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid10x2);

		assertThrows(InvalidGeometryException.class, () -> {
			matrix.adjoint();
		});
		assertThrows(InvalidGeometryException.class, () -> {
			matrix.adj();
		});
	}

	//! inverse()
	@Test
	public void testInverse_size0(){
		BigIntegerMatrix matrix = new BigIntegerMatrix();

		assertThrows(InvalidGeometryException.class, () -> {
			matrix.inverse();
		});
	}

	@Test
	public void testInverse_size1(){
		BigInteger[][] expectedGrid = new BigInteger[][]{{BigInteger.valueOf(-1)}};
		BigIntegerMatrix matrix = new BigIntegerMatrix(new BigInteger[][]{{BigInteger.valueOf(-1)}});

		assertArrayEquals(expectedGrid, matrix.inverse().copyGrid());
	}

	@Test
	public void testInverse_size2(){
		BigInteger[][] expectedGrid = new BigInteger[][]{{BigInteger.valueOf(-2), BigInteger.valueOf(3)}, {BigInteger.valueOf(3), BigInteger.valueOf(-4)}};
		BigIntegerMatrix matrix = new BigIntegerMatrix(new BigInteger[][]{{BigInteger.valueOf(4), BigInteger.valueOf(3)}, {BigInteger.valueOf(3), BigInteger.valueOf(2)}});

		assertArrayEquals(expectedGrid, matrix.inverse().copyGrid());
	}

	@Test
	public void testInverse_size10(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid10);

		assertThrows(InvalidScalarException.class, () -> {
			matrix.inverse();
		});
	}

	@Test
	public void testInverse_size2x10(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2x10);

		assertThrows(InvalidGeometryException.class, () -> {
			matrix.inverse();
		});
	}

	@Test
	public void testInverse_size10x2(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid10x2);

		assertThrows(InvalidGeometryException.class, () -> {
			matrix.inverse();
		});
	}

	//! equals()
	@Test
	public void testEquals_null(){
		BigIntegerMatrix matrix = new BigIntegerMatrix();

		assertFalse(matrix.equals(null));
	}

	@Test
	public void testEquals_matrixObject(){
		BigIntegerMatrix equalsMatrix = new BigIntegerMatrix(negativeGrid2);
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertTrue(matrix.equals((Object)equalsMatrix));
	}

	@Test
	public void testEquals_array(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertTrue(matrix.equals(negativeGrid2));
	}

	@Test
	public void testEquals_invalidType(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertFalse(matrix.equals(1));
	}

	@Test
	public void testEquals_manyRows(){
		BigIntegerMatrix equalsMatrix = new BigIntegerMatrix(new BigInteger[][]{{BigInteger.valueOf(-1), BigInteger.valueOf(-2)}, {BigInteger.valueOf(-3), BigInteger.valueOf(-4)}, {BigInteger.valueOf(-5), BigInteger.valueOf(-6)}});
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertFalse(matrix.equals(equalsMatrix));
	}

	@Test
	public void testEquals_fewRows(){
		BigIntegerMatrix equalsMatrix = new BigIntegerMatrix(new BigInteger[][]{{BigInteger.valueOf(-1), BigInteger.valueOf(-2)}});
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertFalse(matrix.equals(equalsMatrix));
	}

	@Test
	public void testEquals_manyCols(){
		BigIntegerMatrix equalsMatrix = new BigIntegerMatrix(new BigInteger[][]{{BigInteger.valueOf(-1), BigInteger.valueOf(-2), BigInteger.valueOf(-3)}, {BigInteger.valueOf(-4), BigInteger.valueOf(-5), BigInteger.valueOf(-6)}});
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertFalse(matrix.equals(equalsMatrix));
	}

	@Test
	public void testEquals_fewCols(){
		BigIntegerMatrix equalsMatrix = new BigIntegerMatrix(new BigInteger[][]{{BigInteger.valueOf(-1)}, {BigInteger.valueOf(-2)}});
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertFalse(matrix.equals(equalsMatrix));
	}

	@Test
	public void testEquals_notEquals(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);
		BigIntegerMatrix equalsMatrix = matrix.transpose();

		assertFalse(matrix.equals(equalsMatrix));
	}

	@Test
	public void testEquals_equals(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);
		BigIntegerMatrix equalsMatrix = new BigIntegerMatrix(negativeGrid2);

		assertTrue(matrix.equals(equalsMatrix));
	}

	@Test
	public void testEquals_self(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertTrue(matrix.equals(matrix));
	}

	//! hashCode()
	@Test
	public void testHashCode_size0(){
		BigIntegerMatrix matrix = new BigIntegerMatrix();

		assertEquals(Arrays.hashCode(matrix.grid), matrix.hashCode());
	}

	@Test
	public void testHashCode_size1(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(new BigInteger[][]{{BigInteger.ONE}});

		assertEquals(Arrays.hashCode(matrix.grid), matrix.hashCode());
	}

	@Test
	public void testHashCode_size2(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertEquals(Arrays.hashCode(matrix.grid), matrix.hashCode());
	}

	@Test
	public void testHashCode_size10(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid10);

		assertEquals(Arrays.hashCode(matrix.grid), matrix.hashCode());
	}

	//! toString()
	@Test
	public void testToString_size0(){
		BigIntegerMatrix matrix = new BigIntegerMatrix();

		assertEquals("[]", matrix.toString());
	}

	@Test
	public void testToString_size1(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(new BigInteger[][]{{BigInteger.ONE}});

		assertEquals("[1]", matrix.toString());
	}

	@Test
	public void testToString_size2(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid2);

		assertEquals("[-1, -2]\n[-3, -4]", matrix.toString());
	}

	@Test
	public void testToString_size10(){
		BigIntegerMatrix matrix = new BigIntegerMatrix(negativeGrid10);

		assertEquals(
			"[-1, -2, -3, -4, -5, -6, -7, -8, -9, -10]\n" +
			"[-11, -12, -13, -14, -15, -16, -17, -18, -19, -20]\n" +
			"[-21, -22, -23, -24, -25, -26, -27, -28, -29, -30]\n" +
			"[-31, -32, -33, -34, -35, -36, -37, -38, -39, -40]\n" +
			"[-41, -42, -43, -44, -45, -46, -47, -48, -49, -50]\n" +
			"[-51, -52, -53, -54, -55, -56, -57, -58, -59, -60]\n" +
			"[-61, -62, -63, -64, -65, -66, -67, -68, -69, -70]\n" +
			"[-71, -72, -73, -74, -75, -76, -77, -78, -79, -80]\n" +
			"[-81, -82, -83, -84, -85, -86, -87, -88, -89, -90]\n" +
			"[-91, -92, -93, -94, -95, -96, -97, -98, -99, -100]",
			matrix.toString());
	}

	//! generateIdentity()
	@Test
	public void testGenerateIdentity_size0(){
		assertThrows(InvalidGeometryException.class, () -> {
			BigIntegerMatrix.generateIdentity(0);
		});
	}

	@Test
	public void testGenerateIdentity_negativeSize(){
		assertThrows(InvalidGeometryException.class, () -> {
			BigIntegerMatrix.generateIdentity(-1);
		});
	}

	@Test
	public void testGenerateIdentity_size2(){
		BigIntegerMatrix matrix = BigIntegerMatrix.generateIdentity(2);

		assertArrayEquals(new BigInteger[][]{{BigInteger.ONE, BigInteger.ZERO}, {BigInteger.ZERO, BigInteger.ONE}}, matrix.copyGrid());
	}

	@Test
	public void testGenerateIdentity_size3(){
		BigIntegerMatrix matrix = BigIntegerMatrix.generateIdentity(3);

		assertArrayEquals(new BigInteger[][]{{BigInteger.ONE, BigInteger.ZERO, BigInteger.ZERO}, {BigInteger.ZERO, BigInteger.ONE, BigInteger.ZERO}, {BigInteger.ZERO, BigInteger.ZERO, BigInteger.ONE}}, matrix.copyGrid());
	}

	@Test
	public void testGenerateIdentity_size10(){
		BigIntegerMatrix matrix = BigIntegerMatrix.generateIdentity(10);

		assertArrayEquals(new BigInteger[][]{
			{BigInteger.ONE, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO},
			{BigInteger.ZERO, BigInteger.ONE, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO},
			{BigInteger.ZERO, BigInteger.ZERO, BigInteger.ONE, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO},
			{BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ONE, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO},
			{BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ONE, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO},
			{BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ONE, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO},
			{BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ONE, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO},
			{BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ONE, BigInteger.ZERO, BigInteger.ZERO},
			{BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ONE, BigInteger.ZERO},
			{BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ONE}
		}, matrix.copyGrid());
	}
}