testMatrix.cpp

#include <stdio.h>
#include <iostream>
#include "matrix.h"
#include "asserts.h"

using namespace std;

#define ELEMENTS(x) (sizeof(x)/sizeof(x[0]))


#define MATRIX_TEST1_ROWS       2
#define MATRIX_TEST1_COLUMNS    3
#define MATRIX_TEST_SCALAR      -10
void testMatrix1(void)
{
const MATRIX_VALUE values[MATRIX_TEST1_ROWS*MATRIX_TEST1_COLUMNS] = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0};
MATRIX_VALUE row[MATRIX_TEST1_COLUMNS+10];
MATRIX_VALUE column[MATRIX_TEST1_ROWS+10];
size_t rows, columns;
size_t i, j;

    /*
        test new, setter and getter
    */
    MATRIX A = matrixNew(MATRIX_TEST1_ROWS, MATRIX_TEST1_COLUMNS);
    assert(A != NULL);
    matrixSet(A, values, ELEMENTS(values));

    assert(matrixGetDimension(NULL, &rows, &columns) == false);
    assert(matrixGetDimension(A, NULL, NULL));
    rows = 0;
    assert(matrixGetDimension(A, &rows, NULL));
    assert(rows == MATRIX_TEST1_ROWS);

    columns = 0;
    assert(matrixGetDimension(A, NULL, &columns));
    assert(columns == MATRIX_TEST1_COLUMNS);

    rows = 0;
    columns = 0;
    assert(matrixGetDimension(A, &rows, &columns));
    assert(rows == MATRIX_TEST1_ROWS);
    assert(columns == MATRIX_TEST1_COLUMNS);

    for(i = 0; i < MATRIX_TEST1_ROWS; i++){
        for(j = 0; j < MATRIX_TEST1_COLUMNS; j++){
            MATRIX_VALUE v;
            matrixGetElement(A, i, j, &v);
            /*if(v != values[i*MATRIX_TEST1_COLUMNS+j]){
                cout << i << " " << j << " " << v << " " << values[i*MATRIX_TEST1_COLUMNS+j] << endl;
            }*/
            assert(v == values[i*MATRIX_TEST1_COLUMNS+j]);
        }
    }

    for(i = 0; i < MATRIX_TEST1_ROWS; i++){
        size_t valueCount = ELEMENTS(row);
        assert(matrixGetRow(A, i, row, &valueCount));
        assert(valueCount == MATRIX_TEST1_COLUMNS);

        for(j = 0; j < MATRIX_TEST1_COLUMNS; j++){
            assert(row[j] == values[i*MATRIX_TEST1_COLUMNS+j]);
        }
    }

    for(j = 0; j < MATRIX_TEST1_COLUMNS; j++){
        size_t valueCount = ELEMENTS(column);
        assert(matrixGetColumn(A, j, column, &valueCount));
        assert(valueCount == MATRIX_TEST1_ROWS);
        for(i = 0; i < MATRIX_TEST1_ROWS; i++){
            assert(column[i] == values[i*MATRIX_TEST1_COLUMNS+j]);
        }
    }

    /*
        test transpostition
    */
    MATRIX C = matrixTransposition(A);
    assert(C != NULL);

    assert(matrixGetDimension(C, &rows, &columns));
    assert(rows == MATRIX_TEST1_COLUMNS);
    assert(columns == MATRIX_TEST1_ROWS);

    for(i = 0; i < MATRIX_TEST1_COLUMNS; i++){
        size_t valueCount = ELEMENTS(row);
        assert(matrixGetRow(C, i, row, &valueCount));
        assert(valueCount == MATRIX_TEST1_ROWS);

        for(j = 0; j < MATRIX_TEST1_ROWS; j++){
            //cout << i << " " << j << " " << row[j] << " " << values[i+j*MATRIX_TEST1_COLUMNS] << endl;
            assert(row[j] == values[i+j*MATRIX_TEST1_COLUMNS]);
        }
    }

    for(j = 0; j < MATRIX_TEST1_ROWS; j++){
        size_t valueCount = ELEMENTS(column);
        assert(matrixGetColumn(C, j, column, &valueCount));
        assert(valueCount == MATRIX_TEST1_COLUMNS);
        for(i = 0; i < MATRIX_TEST1_COLUMNS; i++){
            assert(column[i] == values[i+j*MATRIX_TEST1_COLUMNS]);
        }
    }

    assertFalse(matrixEquals(A, C));
    MATRIX D = matrixTransposition(C);
    assert(D != NULL);
    matrixDelete(&C);
    assert(C == NULL);

    assert(matrixEquals(A, D));

    size_t valueCount = ELEMENTS(row);
    assert(matrixGetRow(D, 1, row, &valueCount));
    row[0] = row[2];
    assertFalse(matrixSetRow(D, 1, row, valueCount-1));
    assert(matrixEquals(A, D));

    assert(matrixSetRow(D, 1, row, valueCount));
    assert(matrixEquals(A, D) == false);

    matrixDelete(&D);
    assert(D == NULL);

    /*
        test scalar multiplication
    */
    MATRIX_VALUE determinant;
    assertFalse(matrixDeterminant(A, &determinant));

    D = matrixMultiplicationScalar(A, MATRIX_TEST_SCALAR);
    assert(D != NULL);
    for(i = 0; i < MATRIX_TEST1_ROWS; i++){
        for(j = 0; j < MATRIX_TEST1_COLUMNS; j++){
            MATRIX_VALUE v;
            matrixGetElement(D, i, j, &v);
            assert(v == values[i*MATRIX_TEST1_COLUMNS+j] * MATRIX_TEST_SCALAR);
        }
    }
    matrixDelete(&D);
    assert(D == NULL);

    /*
        test addition and substraction
    */
    D = matrixAddition(A, A);
    for(i = 0; i < MATRIX_TEST1_ROWS; i++){
        for(j = 0; j < MATRIX_TEST1_COLUMNS; j++){
            MATRIX_VALUE v;
            matrixGetElement(D, i, j, &v);
            assert(v == values[i*MATRIX_TEST1_COLUMNS+j] * 2);
        }
    }
    matrixDelete(&D);
    assert(D == NULL);

    D = matrixSubstraction(A, A);
    assert(D != NULL);
    for(i = 0; i < MATRIX_TEST1_ROWS; i++){
        for(j = 0; j < MATRIX_TEST1_COLUMNS; j++){
            MATRIX_VALUE v;
            matrixGetElement(D, i, j, &v);
            assert(v == 0);
        }
    }
    matrixDelete(&D);
    assert(D == NULL);

    matrixDelete(&A);
    assert(A == NULL);
}

#define MATRIX_TEST2_ROWS       2
#define MATRIX_TEST2_COLUMNS    2
void testMatrix2(void)
{
const MATRIX_VALUE values[MATRIX_TEST2_ROWS*MATRIX_TEST2_COLUMNS] = {1.0, 4.0, 7.0, 8.0 };

    /*
        test determinant calculation
    */
    MATRIX A = matrixNew(MATRIX_TEST2_ROWS, MATRIX_TEST2_COLUMNS);
    assert(A != NULL);
    matrixSet(A, values, ELEMENTS(values));

    MATRIX_VALUE determinant;
    assert(matrixDeterminant(A, &determinant));
    assert(determinant == -20);

    matrixDelete(&A);
    assert(A == NULL);
}


#define MATRIX_TEST3_ROWS       3
#define MATRIX_TEST3_COLUMNS    3
void testMatrix3(void)
{
const MATRIX_VALUE values[MATRIX_TEST3_ROWS*MATRIX_TEST3_COLUMNS] = {1.0, 2.0, 3.0, 1.0, 4.0, 6.0, 1.0, 1.0, 1.0 };

    /*
        test determinant calculation
    */
    MATRIX A = matrixNew(MATRIX_TEST3_ROWS, MATRIX_TEST3_COLUMNS);
    assert(A != NULL);
    matrixSet(A, values, ELEMENTS(values));

    MATRIX_VALUE determinant;
    assert(matrixDeterminant(A, &determinant));
    assert(determinant == -1);

    matrixDelete(&A);
    assert(A == NULL);
}

#define MATRIX_TEST4_ELEMENTS       3
void testMatrix4(void)
{
const MATRIX_VALUE values[MATRIX_TEST4_ELEMENTS*MATRIX_TEST4_ELEMENTS] = {1.0, 2.0, 1.0, 4.0, 6.0, 1.0, 0.0, 1.0, 2.0 };
register size_t i;

    /*
        test inversion
    */
    MATRIX A = matrixNew(MATRIX_TEST4_ELEMENTS, MATRIX_TEST4_ELEMENTS);
    assert(A != NULL);
    matrixSet(A, values, ELEMENTS(values));

    MATRIX B = matrixInverse(A);
    assert(B != NULL);
    matrixPrint(B);

    MATRIX_VALUE determinant;
    assert(matrixDeterminant(A, &determinant));
    assert(determinant == -1);

    /*
        test multiplication
    */
    MATRIX C = matrixMultiplication(A, B);
    assert(C != NULL);
    matrixPrint(C);

    MATRIX E = matrixNew(MATRIX_TEST4_ELEMENTS, MATRIX_TEST4_ELEMENTS);
    assert(E != NULL);

    for(i = 0; i < MATRIX_TEST4_ELEMENTS; i++){
        matrixSetElement(E, i, i, 1.0);
    }
    assert(matrixEquals(C, E));
    matrixDelete(&C);

    C = matrixNewUnit(MATRIX_TEST4_ELEMENTS);
    assert(matrixEquals(C, E));

    matrixDelete(&E);
    matrixDelete(&C);
    matrixDelete(&B);
    matrixDelete(&A);
}

#define MATRIX_TEST5_ROWS       5
#define MATRIX_TEST5_COLUMNS    5
void testMatrix5(void)
{
const MATRIX_VALUE values[MATRIX_TEST5_ROWS*MATRIX_TEST5_COLUMNS] = { 100.0, 10.0, 50.0, 38.0, 16.0,
                                                                        14.0, 28.0, 87.0, 10.0, 1.0,
                                                                        0.0, 99.0, 23.0, 15.0, 1.0,
                                                                        85.0, 93.0, 48.0, 64.0, 55.0,
                                                                        68.0, 41.0, 3.0, 44.0, 33.0 };

    /*
        test clone
    */
    MATRIX A = matrixNew(MATRIX_TEST5_ROWS, MATRIX_TEST5_COLUMNS);
    assert(A != NULL);
    matrixSet(A, values, ELEMENTS(values));

    MATRIX_VALUE determinant;
    assert(matrixDeterminant(A, &determinant));
    assert(determinant == 100289562);

    MATRIX B = matrixClone(A);
    assert(B != NULL);
    assert(A != B);
    assert(matrixEquals(A, B));
    matrixDelete(&B);

    matrixDelete(&A);
}

#define MATRIX_TEST6_ROWS       3
#define MATRIX_TEST6_COLUMNS    3

void testMatrix6(void)
{
const MATRIX_VALUE values[MATRIX_TEST6_ROWS*MATRIX_TEST6_COLUMNS] = { 3.0, 2.0, -1.0,
                                                                        2.0, -2.0, +4.0,
                                                                        -1.0, 0.5, -1.0};
const MATRIX_VALUE result_y[MATRIX_TEST6_COLUMNS] = { 1.0, -2.0, 0.0};
const MATRIX_VALUE result_a[MATRIX_TEST6_COLUMNS] = { 1.0, -2.0, -2.0};

    /*
        test solution
    */
    MATRIX A = matrixNew(MATRIX_TEST6_ROWS, MATRIX_TEST6_COLUMNS);
    assert(A != NULL);
    assert(matrixSet(A, values, ELEMENTS(values)));

    VECTOR y = vectorNew(MATRIX_TEST6_COLUMNS);
    assert(y != NULL);
    assert(vectorSet(y, result_y, ELEMENTS(result_y)));

    VECTOR expected_a = vectorNew(MATRIX_TEST6_COLUMNS);
    assert(expected_a != NULL);
    assert(vectorSet(expected_a, result_a, ELEMENTS(result_a)));

    VECTOR a = matrixSolve(A, y);
    assert(a != NULL);
    assert(vectorEquals(a, expected_a));

    matrixDelete(&A);
    vectorDelete(&y);
    vectorDelete(&a);
    vectorDelete(&expected_a);
}

void testVector1(void)
{
register size_t i, j;
const MATRIX_VALUE values[VECTOR_STANDARD_DIMENSION] = { 3, -4, 8 };
MATRIX_VALUE scalar;

    VECTOR a = vectorNew(VECTOR_STANDARD_DIMENSION);

    size_t dimension;
    assert(vectorGetDimension(a, &dimension));
    assert(dimension == VECTOR_STANDARD_DIMENSION);

    assert(a != NULL);
    assertFalse(vectorSet(a, values, ELEMENTS(values)-1));
    assertTrue(vectorSet(a, values, ELEMENTS(values)));

    for(i = 0; i < VECTOR_STANDARD_DIMENSION; i++){
        MATRIX_VALUE v;
        assert(vectorGetElement(a, i, &v));
        assert(v == values[i]);
    }

    {
        MATRIX_VALUE v[VECTOR_STANDARD_DIMENSION + 1];
        size_t vCount = VECTOR_STANDARD_DIMENSION -1;
        assertFalse(vectorGet(a, v, &vCount));

        vCount = VECTOR_STANDARD_DIMENSION + 1;
        assertTrue(vectorGet(a, v, &vCount));
        assert(vCount == VECTOR_STANDARD_DIMENSION);

        vCount = VECTOR_STANDARD_DIMENSION;
        assertTrue(vectorGet(a, v, &vCount));
        assertMemory(values, v, sizeof(values));
    }

    assert(vectorLength(a, &scalar));
    assertDouble(scalar, sqrt(values[0] * values[0] + values[1] * values[1] + values[2] * values[2]));


    VECTOR b = vectorNew(VECTOR_STANDARD_DIMENSION);
    assert(b != NULL);
    assert(vectorSet(b, values, ELEMENTS(values)));

    assert(vectorEquals(a, b));
    for(i = 0; i < VECTOR_STANDARD_DIMENSION; i++){
        assert(vectorSetElement(b, i, values[(VECTOR_STANDARD_DIMENSION-1) - i]));
    }
    for(i = 0; i < VECTOR_STANDARD_DIMENSION; i++){
        MATRIX_VALUE v;
        assert(vectorGetElement(b, i, &v));
        assert(v == values[(VECTOR_STANDARD_DIMENSION-1) - i]);
    }

    assertFalse(vectorEquals(a, b));

    VECTOR c = vectorAddition(a, b);
    assert(c != NULL);

    for(i = 0; i < VECTOR_STANDARD_DIMENSION; i++){
        MATRIX_VALUE v;
        assert(vectorGetElement(c, i, &v));
        assert(v == (values[(VECTOR_STANDARD_DIMENSION-1) - i] + values[i]));
    }
    vectorDelete(&c);
    assert(c == NULL);

    c = vectorSubstraction(a, b);
    assert(c != NULL);

    for(i = 0; i < VECTOR_STANDARD_DIMENSION; i++){
        MATRIX_VALUE v;
        assert(vectorGetElement(c, i, &v));
        assert(v == (values[i] - values[(VECTOR_STANDARD_DIMENSION-1) - i]));
    }
    vectorDelete(&c);
    assert(c == NULL);

    assert(vectorDotProduct(a, b, &scalar));
    assert(scalar == values[0] * values[2] + values[1] * values[1] + values[2] * values[0]);

    c = vectorCrossProduct(a, b);
    assert(c != NULL);

    {
        MATRIX_VALUE v;
        assert(vectorGetElement(c, 0, &v));
        assert(v == (values[1] * values[(VECTOR_STANDARD_DIMENSION-1) - 2] - values[2] * values[(VECTOR_STANDARD_DIMENSION-1) - 1]));
        assert(vectorGetElement(c, 1, &v));
        assert(v == (values[2] * values[(VECTOR_STANDARD_DIMENSION-1) - 0] - values[0] * values[(VECTOR_STANDARD_DIMENSION-1) - 2]));
        assert(vectorGetElement(c, 2, &v));
        assert(v == (values[0] * values[(VECTOR_STANDARD_DIMENSION-1) - 1] - values[1] * values[(VECTOR_STANDARD_DIMENSION-1) - 0]));
    }
    vectorDelete(&c);
    assert(c == NULL);

    MATRIX M = vectorOuterProduct(a, b);
    //matrixPrint(M);
    size_t rows, columns;
    assert(matrixGetDimension(M, &rows, &columns));
    assert(rows == VECTOR_STANDARD_DIMENSION);
    assert(columns == VECTOR_STANDARD_DIMENSION);

    for(i = 0; i < VECTOR_STANDARD_DIMENSION; i++){
        for(j = 0; j < VECTOR_STANDARD_DIMENSION; j++){
            MATRIX_VALUE v;
            matrixGetElement(M, i, j, &v);
            assert(v == values[i] * values[(VECTOR_STANDARD_DIMENSION-1)-j]);
        }
    }

    vectorDelete(&a);
    assert(a == NULL);
    vectorDelete(&b);
    assert(b == NULL);

    a = vectorNew(VECTOR_STANDARD_DIMENSION);
    vectorSetElement(a, 0, 2);
    b = vectorNew(VECTOR_STANDARD_DIMENSION);
    vectorSetElement(b, 1, 2);
    c = vectorNew(VECTOR_STANDARD_DIMENSION);
    vectorSetElement(c, 2, 2);

    assert(vectorScalarTripleProduct(a, b, c, &scalar));
    assert(scalar == 2*2*2);

    vectorDelete(&a);
    assert(a == NULL);
    vectorDelete(&b);
    assert(b == NULL);
    vectorDelete(&c);
    assert(c == NULL);
}

int main()
{
    testMatrix1();
    testMatrix2();
    testMatrix3();
    testMatrix4();
    testMatrix5();
    testMatrix6();
    testVector1();
    return 0;
}