j3ml/tests/LinearAlgebra/Matrix3x3Tests.hpp

#include <jtest/jtest.hpp>
#include <jtest/Unit.hpp>
#include <J3ML/LinearAlgebra/Matrix3x3.hpp>
#include <J3ML/LinearAlgebra/Matrix4x4.hpp>

jtest::Unit Matrix3x3Unit {"Matrix3x3"};
namespace Matrix3x3Tests
{
    inline void Define()
    {
        using namespace jtest;
        using namespace J3ML::LinearAlgebra;

        /*Matrix3x3Unit += Test("AngleTypeRound-TripConversion", [] {
            EulerAngleXYZ expected_result(8, 60, -27);

            Matrix3x3 m(expected_result);
            AxisAngle a(expected_result);
            Quaternion q(a);
            Matrix3x3 m2(q);
            Quaternion q2(m2);
            AxisAngle a2(q2);
            EulerAngleXYZ round_trip(a2);

            jtest::check(Math::EqualAbs(Math::Radians(expected_result.roll), Math::Radians(round_trip.roll), 1e-6f));
            jtest::check(Math::EqualAbs(Math::Radians(expected_result.pitch), Math::Radians(round_trip.pitch), 1e-6f));
            jtest::check(Math::EqualAbs(Math::Radians(expected_result.yaw), Math::Radians(round_trip.yaw), 1e-6f));
        });*/

        /*Matrix3x3Unit += Test("From_EulerAngleXYZ", []{
            Matrix3x3 expected_result(Vector3(0.4455033, 0.2269952, 0.8660254),
                                      Vector3(-0.3421816, 0.9370536,  -0.0695866),
                                      Vector3(-0.8273081, -0.2653369, 0.4951340)
                                      );

            EulerAngleXYZ e(8, 60, -27);
            Matrix3x3 from_euler(e);

            jtest::check(Math::EqualAbs(expected_result.At(0, 0), from_euler.At(0, 0), 1e-6f));
            jtest::check(Math::EqualAbs(expected_result.At(0, 1), from_euler.At(0, 1), 1e-6f));
            jtest::check(Math::EqualAbs(expected_result.At(0, 2), from_euler.At(0, 2), 1e-6f));
            jtest::check(Math::EqualAbs(expected_result.At(1, 0), from_euler.At(1, 0), 1e-6f));
            jtest::check(Math::EqualAbs(expected_result.At(1, 1), from_euler.At(1, 1), 1e-6f));
            jtest::check(Math::EqualAbs(expected_result.At(1, 2), from_euler.At(1, 2), 1e-6f));
            jtest::check(Math::EqualAbs(expected_result.At(2, 0), from_euler.At(2, 0), 1e-6f));
            jtest::check(Math::EqualAbs(expected_result.At(2, 1), from_euler.At(2, 1), 1e-6f));
            jtest::check(Math::EqualAbs(expected_result.At(2, 2), from_euler.At(2, 2), 1e-6f));
        });*/

        Matrix3x3Unit += Test("Add_Unary", []
        {
            Matrix3x3 m(1,2,3, 4,5,6, 7,8,9);
            Matrix3x3 m2 = +m;
            jtest::check(m.Equals(m2));
        });

        Matrix3x3Unit += Test("Solve_Axb", []{
            RNG rng;
            Matrix3x3 A = Matrix3x3::RandomGeneral(rng, -10.f, 10.f);
            bool mayFail = Math::EqualAbs(A.Determinant(), 0.f, 1e-2f);

            Vector3 b = Vector3::RandomBox(rng, Vector3::FromScalar(-10.f), Vector3::FromScalar(10.f));

            Vector3 x;
            bool success = A.SolveAxb(b, x);
            jtest::check(success || mayFail);
            if (success)
            {
                Vector3 b2 = A*x;
                jtest::check(b2.Equals(b, 1e-1f));
            }
        });

        Matrix3x3Unit += Test("Inverse_Case", []
        {
            Matrix3x3 m(-8.75243664f,6.71196938f,-5.95816374f,6.81996822f,-6.85106039f,2.38949537f,-0.856015682f,3.45762491f,3.311584f);

            bool success = m.Inverse();
            jtest::check(success);
        });

        Matrix3x3Unit += Test("Inverse", []
        {
            RNG rng;
            Matrix3x3 A = Matrix3x3::RandomGeneral(rng, -10.f, 10.f);
            bool mayFail = Math::EqualAbs(A.Determinant(), 0.f, 1e-2f);

            Matrix3x3 A2 = A;
            bool success = A2.Inverse();
            jtest::check(success || mayFail);
            if (success)
            {
                Matrix3x3 id = A * A2;
                Matrix3x3 id2 = A2 * A;
                jtest::check(id.Equals(Matrix3x3::Identity, 0.3f));
                jtest::check(id2.Equals(Matrix3x3::Identity, 0.3f));
            }
        });


        Matrix3x3Unit += Test("InverseFast", []
        {
            // TODO: Fix implementation of InverseFast
            /*
            Matrix3x3 A = Matrix3x3::RandomGeneral(rng, -10.f, 10.f);
            bool mayFail = Math::EqualAbs(A.Determinant(), 0.f, 1e-2f);

            Matrix3x3 A2 = A;
            bool success = A2.InverseFast();
            assert(success || mayFail);

            if (success)
            {
                Matrix3x3 id = A * A2;
                Matrix3x3 id2 = A2 * A;
                assert(id.Equals(Matrix3x3::Identity, 0.3f));
                assert(id2.Equals(Matrix3x3::Identity, 0.3f));
            }
             */
        });

        Matrix3x3Unit += Test("MulMat4x4", []
        {
            RNG rng;
            Matrix3x3 m = Matrix3x3::RandomGeneral(rng, -10.f, 10.f);
            Matrix4x4 m_ = m;
            Matrix4x4 m2 = Matrix4x4::RandomGeneral(rng, -10.f, 10.f);

            Matrix4x4 test = m * m2;
            Matrix4x4 correct = m_ * m2;
            jtest::check(test.Equals(correct));
        });
    }

    inline void Run()
    {
        Matrix3x3Unit.RunAll();
    }
}