test_fq_matrix.c

/**
This file contains basic test cases for the functions in fq_matrix.c.
For details on how to execute/add test cases, please refer to the README
**/

#include "../include/fq_matrix.h"
#include "CuTest.h"
#include "stdio.h"
#include "stdlib.h"

void test_create_base(CuTest *tc) {
  for (Vi i = 0; i < 5; i++) {
    for (Vi j = 0; j < 5; j++) {
      Matrix *mat = create(i, j, 0.0);
      if (i * j <= 0) {
        CuAssertPtrEquals(tc, NULL, mat);
      } else {
        CuAssertIntEquals(tc, i, mat->row);
        CuAssertIntEquals(tc, j, mat->col);
        for (Vi k = 0; k < i * j; k++) {
          CuAssertDblEquals(tc, 0.0, mat->data[k], EPSILON);
        }
        destroy(mat);
      }
    }
  }
}

void test_destroy_base(CuTest *tc) {
  Matrix *mat = create(2, 2, 0.0);
  CuAssertIntEquals(tc, 0, destroy(mat));
}

void test_find_base(CuTest *tc) {
  for (Vi i = 0; i < 5; i++) {
    for (Vi j = 0; j < 5; j++) {
      Vi length = i * j;
      Vf *data = (Vf *)malloc(length * sizeof(Vf));

      for (Vi k = 0; k < length; k++) {
        data[k] = (Vf)rand() / RAND_MAX;
      }

      Matrix *mat = create(i, j, 0.0);
      fill(mat, data, length);
      for (Vi k = 0; k < i; k++) {
        for (Vi l = 0; l < j; l++) {
          CuAssertDblEquals(tc, data[k * j + l], find(mat, k, l), EPSILON);
        }
      }
      destroy(mat);
      free(data);
    }
  }
}

void test_identity_base(CuTest *tc) {
  for (Vi i = 0; i < 5; i++) {
    for (Vi j = 0; j < 5; j++) {
      Matrix *mat = create(i, j, 0.0);
      identity(mat);
      if (i * j <= 0) {
        CuAssertPtrEquals(tc, NULL, mat);
      } else if (i != j) {
        for (Vi k = 0; k < i * j; k++) {
          CuAssertDblEquals(tc, 0.0, mat->data[k], EPSILON);
        }
      } else {
        for (Vi k = 0; k < i * j; k++) {
          if (k % (i + 1) == 0) {
            CuAssertDblEquals(tc, 1.0, mat->data[k], EPSILON);
          } else {
            CuAssertDblEquals(tc, 0.0, mat->data[k], EPSILON);
          }
        }
      }
      destroy(mat);
    }
  }
}

void test_clone_base(CuTest *tc) {
  for (Vi i = 0; i < 5; i++) {
    for (Vi j = 0; j < 5; j++) {
      Vi random = i * j;
      Matrix *mat = create(i, j, random);
      Matrix *out = clone(mat);
      if (i * j <= 0) {
        CuAssertPtrEquals(tc, NULL, out);
      } else {
        CuAssertIntEquals(tc, i, out->row);
        CuAssertIntEquals(tc, j, out->col);
        for (Vi k = 0; k < i * j; k++) {
          CuAssertDblEquals(tc, random, out->data[k], EPSILON);
        }
        destroy(out);
        destroy(mat);
      }
    }
  }
}

void test_copy_base(CuTest *tc) {
  for (Vi i = 0; i < 5; i++) {
    for (Vi j = 0; j < 5; j++) {
      Vi random = i * j;
      Matrix *mat = create(i, j, random);
      Matrix *out = create(i, j, 0.0);
      copy(out, mat);
      if (i * j <= 0) {
        CuAssertPtrEquals(tc, NULL, out);
      } else {
        CuAssertIntEquals(tc, i, out->row);
        CuAssertIntEquals(tc, j, out->col);
        for (Vi k = 0; k < i * j; k++) {
          CuAssertDblEquals(tc, random, out->data[k], EPSILON);
        }
      }
      destroy(out);
      destroy(mat);
    }
  }
}

void test_fill_base(CuTest *tc) {
  for (Vi i = 0; i < 5; i++) {
    for (Vi j = 0; j < 5; j++) {
      Vi length = i * j;
      Vf *data = (Vf *)malloc(length * sizeof(Vf));

      for (Vi k = 0; k < length; k++) {
        data[k] = (Vf)rand() / RAND_MAX;
      }

      Matrix *mat = create(i, j, 0.0);
      fill(mat, data, length);
      if (i * j <= 0) {
        CuAssertPtrEquals(tc, NULL, mat);
      } else {
        CuAssertIntEquals(tc, i, mat->row);
        CuAssertIntEquals(tc, j, mat->col);
        for (Vi k = 0; k < length; k++) {
          CuAssertDblEquals(tc, data[k], mat->data[k], EPSILON);
        }
      }
      destroy(mat);
      free(data);
    }
  }
}

void test_transpose_base(CuTest *tc) {
  for (Vi i = 0; i < 5; i++) {
    for (Vi j = 0; j < 5; j++) {
      Vi length = i * j;
      Vf *data = (Vf *)malloc(length * sizeof(Vf));

      for (Vi k = 0; k < length; k++) {
        data[k] = (Vf)rand() / RAND_MAX;
      }

      Matrix *mat = create(i, j, 0.0);
      fill(mat, data, length);
      Matrix *out = transpose(mat);

      if (i * j <= 0) {
        CuAssertPtrEquals(tc, NULL, out);
      } else {
        CuAssertIntEquals(tc, j, out->row);
        CuAssertIntEquals(tc, i, out->col);
        for (Vi k = 0; k < i; k++) {
          for (Vi l = 0; l < j; l++) {
            CuAssertDblEquals(tc, find(mat, k, l), find(out, l, k), EPSILON);
          }
        }
      }
      destroy(out);
      destroy(mat);
      free(data);
    }
  }
}

void test_cofactor_base(CuTest *tc) {
  Matrix *mat;
  Matrix *out;
  Vf *data;
  for (Vi i = 0; i < 5; i++) {
    for (Vi j = 0; j < 5; j++) {
      Vi length = i * j;
      data = (Vf *)malloc(length * sizeof(Vf));

      for (Vi k = 0; k < length; k++) {
        data[k] = (Vf)rand() / RAND_MAX;
      }

      mat = create(i, j, 0.0);
      fill(mat, data, length);
      for (Vi k = 0; k < i; k++) {
        for (Vi l = 0; l < j; l++) {
          out = cofactor(mat, k, l);

          if (i * j <= 0 || out == NULL) {
            CuAssertPtrEquals(tc, NULL, out);
          } else {
            CuAssertIntEquals(tc, i - 1, out->row);
            CuAssertIntEquals(tc, j - 1, out->col);
            for (Vi m = 0; m < i; m++) {
              for (Vi n = 0; n < j; n++) {
                if (m == k || n == l) {
                  continue;
                } else {
                  Vi x = m < k ? m : m - 1;
                  Vi y = n < l ? n : n - 1;
                  CuAssertDblEquals(tc, find(mat, m, n), find(out, x, y),
                                    EPSILON);
                }
              }
            }
          }

          destroy(out);
        }
      }
      destroy(mat);
      free(data);
    }
  }
}

void test_determinant_base(CuTest *tc) {
  // Test 2x2 matrix
  Matrix *mat = create(2, 2, 0.0);
  Vf data[4] = {1, 2, 3, 4};
  fill(mat, data, 4);
  CuAssertDblEquals(tc, -2.0, determinant(mat), EPSILON);
  destroy(mat);

  // Test 3x3 matrix
  mat = create(3, 3, 0.0);
  Vf data2[9] = {0, 3, 1, 2, 5, 9, 3, 6, 7};
  fill(mat, data2, 9);
  CuAssertDblEquals(tc, 36, determinant(mat), EPSILON);
  destroy(mat);

  // Test 4x4 matrix
  mat = create(4, 4, 0.0);
  Vf data3[16] = {1, 2, 3, 4, 52, 6, 72, 8, 9, 11, 11, 12, 13, 14, 15, 16};
  fill(mat, data3, 16);
  CuAssertDblEquals(tc, 1776, determinant(mat), EPSILON);
  destroy(mat);
}

void test_adjoint_base(CuTest *tc) {
  // Test 2x2 matrix
  Matrix *mat = create(2, 2, 0.0);
  Vf data[4] = {1, 2, 3, 4};
  fill(mat, data, 4);
  Matrix *out = adjoint(mat);
  CuAssertIntEquals(tc, 2, out->row);
  CuAssertIntEquals(tc, 2, out->col);
  CuAssertDblEquals(tc, 4, out->data[0], EPSILON);
  CuAssertDblEquals(tc, -2, out->data[1], EPSILON);
  CuAssertDblEquals(tc, -3, out->data[2], EPSILON);
  CuAssertDblEquals(tc, 1, out->data[3], EPSILON);
  destroy(mat);
  destroy(out);

  // Test 3x3 matrix
  mat = create(3, 3, 0.0);
  Vf data2[9] = {0, 1, 1, 2, 2, 1, 0, 0, 1};
  fill(mat, data2, 9);
  out = adjoint(mat);
  CuAssertIntEquals(tc, 3, out->row);
  CuAssertIntEquals(tc, 3, out->col);
  CuAssertDblEquals(tc, 2, out->data[0], EPSILON);
  CuAssertDblEquals(tc, -1, out->data[1], EPSILON);
  CuAssertDblEquals(tc, -1, out->data[2], EPSILON);
  CuAssertDblEquals(tc, -2, out->data[3], EPSILON);
  CuAssertDblEquals(tc, 0, out->data[4], EPSILON);
  CuAssertDblEquals(tc, 2, out->data[5], EPSILON);
  CuAssertDblEquals(tc, 0, out->data[6], EPSILON);
  CuAssertDblEquals(tc, 0, out->data[7], EPSILON);
  CuAssertDblEquals(tc, -2, out->data[8], EPSILON);
  destroy(mat);
  destroy(out);
}

void test_inverse_base(CuTest *tc) {
  // Test 2x2 matrix
  Matrix *mat = create(2, 2, 0.0);
  Vf data[4] = {1, 2, 3, 4};
  fill(mat, data, 4);
  Matrix *out = inverse(mat);
  CuAssertIntEquals(tc, 2, out->row);
  CuAssertIntEquals(tc, 2, out->col);
  CuAssertDblEquals(tc, -2, out->data[0], EPSILON);
  CuAssertDblEquals(tc, 1, out->data[1], EPSILON);
  CuAssertDblEquals(tc, 1.5, out->data[2], EPSILON);
  CuAssertDblEquals(tc, -0.5, out->data[3], EPSILON);
  destroy(mat);
  destroy(out);

  // Test 3x3 matrix
  mat = create(3, 3, 0.0);
  Vf data2[9] = {0, 3, 1, 2, 5, 9, 3, 6, 7};
  fill(mat, data2, 9);
  out = inverse(mat);
  CuAssertIntEquals(tc, 3, out->row);
  CuAssertIntEquals(tc, 3, out->col);
  CuAssertDblEquals(tc, -0.527778, out->data[0], EPSILON);
  CuAssertDblEquals(tc, -0.4166666666666667, out->data[1], EPSILON);
  CuAssertDblEquals(tc, 0.6111111111111112, out->data[2], EPSILON);
  CuAssertDblEquals(tc, 0.3611111111111111, out->data[3], EPSILON);
  CuAssertDblEquals(tc, -0.08333333333333333, out->data[4], EPSILON);
  CuAssertDblEquals(tc, 0.05555555555555555, out->data[5], EPSILON);
  CuAssertDblEquals(tc, -0.08333333333333333, out->data[6], EPSILON);
  CuAssertDblEquals(tc, 0.25, out->data[7], EPSILON);
  CuAssertDblEquals(tc, -0.16666666666666666, out->data[8], EPSILON);
  destroy(mat);
  destroy(out);
}

void test_add_base(CuTest *tc) {
  // Test 2x2 matrix
  Matrix *mat1 = create(2, 2, 0.0);
  Vf data1[4] = {1, 2, 3, 4};
  fill(mat1, data1, 4);
  Matrix *mat2 = create(2, 2, 0.0);
  Vf data2[4] = {5, 6, 7, 8};
  fill(mat2, data2, 4);
  Matrix *out = add(mat1, mat2);
  CuAssertIntEquals(tc, 2, out->row);
  CuAssertIntEquals(tc, 2, out->col);
  CuAssertDblEquals(tc, 6, out->data[0], EPSILON);
  CuAssertDblEquals(tc, 8, out->data[1], EPSILON);
  CuAssertDblEquals(tc, 10, out->data[2], EPSILON);
  CuAssertDblEquals(tc, 12, out->data[3], EPSILON);
  destroy(mat1);
  destroy(mat2);
  destroy(out);

  // Test 3x3 matrix
  mat1 = create(3, 3, 0.0);
  Vf data3[9] = {0, 3, 1, 2, 5, 9, 3, 6, 7};
  fill(mat1, data3, 9);
  mat2 = create(3, 3, 0.0);
  Vf data4[9] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
  fill(mat2, data4, 9);
  out = add(mat1, mat2);
  CuAssertIntEquals(tc, 3, out->row);
  CuAssertIntEquals(tc, 3, out->col);
  CuAssertDblEquals(tc, 1, out->data[0], EPSILON);
  CuAssertDblEquals(tc, 5, out->data[1], EPSILON);
  CuAssertDblEquals(tc, 4, out->data[2], EPSILON);
  CuAssertDblEquals(tc, 6, out->data[3], EPSILON);
  CuAssertDblEquals(tc, 10, out->data[4], EPSILON);
  CuAssertDblEquals(tc, 15, out->data[5], EPSILON);
  CuAssertDblEquals(tc, 10, out->data[6], EPSILON);
  CuAssertDblEquals(tc, 14, out->data[7], EPSILON);
  CuAssertDblEquals(tc, 16, out->data[8], EPSILON);
  destroy(mat1);
  destroy(mat2);
  destroy(out);
}

void test_subtract_base(CuTest *tc) {
  // Test 2x2 matrix
  Matrix *mat1 = create(2, 2, 0.0);
  Vf data1[4] = {1, 2, 3, 4};
  fill(mat1, data1, 4);
  Matrix *mat2 = create(2, 2, 0.0);
  Vf data2[4] = {5, 6, 7, 8};
  fill(mat2, data2, 4);
  Matrix *out = subtract(mat1, mat2);
  CuAssertIntEquals(tc, 2, out->row);
  CuAssertIntEquals(tc, 2, out->col);
  CuAssertDblEquals(tc, -4, out->data[0], EPSILON);
  CuAssertDblEquals(tc, -4, out->data[1], EPSILON);
  CuAssertDblEquals(tc, -4, out->data[2], EPSILON);
  CuAssertDblEquals(tc, -4, out->data[3], EPSILON);
  destroy(mat1);
  destroy(mat2);
  destroy(out);

  // Test 3x3 matrix
  mat1 = create(3, 3, 0.0);
  Vf data3[9] = {0, 3, 1, 2, 5, 9, 3, 6, 7};
  fill(mat1, data3, 9);
  mat2 = create(3, 3, 0.0);
  Vf data4[9] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
  fill(mat2, data4, 9);
  out = subtract(mat1, mat2);
  CuAssertIntEquals(tc, 3, out->row);
  CuAssertIntEquals(tc, 3, out->col);
  CuAssertDblEquals(tc, -1, out->data[0], EPSILON);
  CuAssertDblEquals(tc, 1, out->data[1], EPSILON);
  CuAssertDblEquals(tc, -2, out->data[2], EPSILON);
  CuAssertDblEquals(tc, -2, out->data[3], EPSILON);
  CuAssertDblEquals(tc, 0, out->data[4], EPSILON);
  CuAssertDblEquals(tc, 3, out->data[5], EPSILON);
  CuAssertDblEquals(tc, -4, out->data[6], EPSILON);
  CuAssertDblEquals(tc, -2, out->data[7], EPSILON);
  CuAssertDblEquals(tc, -2, out->data[8], EPSILON);
  destroy(mat1);
  destroy(mat2);
  destroy(out);
}

void test_multiply_base(CuTest *tc) {
  // Test 2x2 matrix
  Matrix *mat1 = create(2, 2, 0.0);
  Vf data1[4] = {1, 2, 3, 4};
  fill(mat1, data1, 4);
  Matrix *mat2 = create(2, 2, 0.0);
  Vf data2[4] = {5, 6, 7, 8};
  fill(mat2, data2, 4);
  Matrix *out = multiply(mat1, mat2);
  CuAssertIntEquals(tc, 2, out->row);
  CuAssertIntEquals(tc, 2, out->col);
  CuAssertDblEquals(tc, 19, out->data[0], EPSILON);
  CuAssertDblEquals(tc, 22, out->data[1], EPSILON);
  CuAssertDblEquals(tc, 43, out->data[2], EPSILON);
  CuAssertDblEquals(tc, 50, out->data[3], EPSILON);
  destroy(mat1);
  destroy(mat2);
  destroy(out);

  // Test 3x3 matrix
  mat1 = create(3, 3, 0.0);
  Vf data3[9] = {0, 3, 1, 2, 5, 9, 3, 6, 7};
  fill(mat1, data3, 9);
  mat2 = create(3, 3, 0.0);
  Vf data4[9] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
  fill(mat2, data4, 9);
  out = multiply(mat1, mat2);
  CuAssertIntEquals(tc, 3, out->row);
  CuAssertIntEquals(tc, 3, out->col);
  CuAssertDblEquals(tc, 19, out->data[0], EPSILON);
  CuAssertDblEquals(tc, 23, out->data[1], EPSILON);
  CuAssertDblEquals(tc, 27, out->data[2], EPSILON);
  CuAssertDblEquals(tc, 85, out->data[3], EPSILON);
  CuAssertDblEquals(tc, 101, out->data[4], EPSILON);
  CuAssertDblEquals(tc, 117, out->data[5], EPSILON);
  CuAssertDblEquals(tc, 76, out->data[6], EPSILON);
  CuAssertDblEquals(tc, 92, out->data[7], EPSILON);
  CuAssertDblEquals(tc, 108, out->data[8], EPSILON);
  destroy(mat1);
  destroy(mat2);
  destroy(out);
}

void test_scalar_base(CuTest *tc) {
  // Test 2x2 matrix
  Matrix *mat = create(2, 2, 0.0);
  Vf data[4] = {1, 2, 3, 4};
  fill(mat, data, 4);
  Matrix *out = scalar(mat, 2);
  CuAssertIntEquals(tc, 2, out->row);
  CuAssertIntEquals(tc, 2, out->col);
  CuAssertDblEquals(tc, 2, out->data[0], EPSILON);
  CuAssertDblEquals(tc, 4, out->data[1], EPSILON);
  CuAssertDblEquals(tc, 6, out->data[2], EPSILON);
  CuAssertDblEquals(tc, 8, out->data[3], EPSILON);
  destroy(mat);
  destroy(out);

  // Test 3x3 matrix
  mat = create(3, 3, 0.0);
  Vf data2[9] = {0, 3, 1, 2, 5, 9, 3, 6, 7};
  fill(mat, data2, 9);
  out = scalar(mat, 3);
  CuAssertIntEquals(tc, 3, out->row);
  CuAssertIntEquals(tc, 3, out->col);
  CuAssertDblEquals(tc, 0, out->data[0], EPSILON);
  CuAssertDblEquals(tc, 9, out->data[1], EPSILON);
  CuAssertDblEquals(tc, 3, out->data[2], EPSILON);
  CuAssertDblEquals(tc, 6, out->data[3], EPSILON);
  CuAssertDblEquals(tc, 15, out->data[4], EPSILON);
  CuAssertDblEquals(tc, 27, out->data[5], EPSILON);
  CuAssertDblEquals(tc, 9, out->data[6], EPSILON);
  CuAssertDblEquals(tc, 18, out->data[7], EPSILON);
  CuAssertDblEquals(tc, 21, out->data[8], EPSILON);
  destroy(mat);
  destroy(out);
}

CuSuite *FqMatrixGetSuite() {
  CuSuite *suite = CuSuiteNew();
  SUITE_ADD_TEST(suite, test_create_base);
  SUITE_ADD_TEST(suite, test_destroy_base);
  SUITE_ADD_TEST(suite, test_find_base);
  SUITE_ADD_TEST(suite, test_identity_base);
  SUITE_ADD_TEST(suite, test_clone_base);
  SUITE_ADD_TEST(suite, test_copy_base);
  SUITE_ADD_TEST(suite, test_fill_base);
  SUITE_ADD_TEST(suite, test_transpose_base);
  SUITE_ADD_TEST(suite, test_cofactor_base);
  SUITE_ADD_TEST(suite, test_determinant_base);
  SUITE_ADD_TEST(suite, test_adjoint_base);
  SUITE_ADD_TEST(suite, test_inverse_base);
  SUITE_ADD_TEST(suite, test_add_base);
  SUITE_ADD_TEST(suite, test_subtract_base);
  SUITE_ADD_TEST(suite, test_multiply_base);
  SUITE_ADD_TEST(suite, test_scalar_base);
  return suite;
}