"""Test of mathematics module.

:Date: 2019-12-20

.. module:: test_mathematics
  :platform: *nix, Windows
  :synopsis: Test of mathematics module.

.. moduleauthor:: Daniel Weschke <daniel.weschke@directbox.de>
"""
import unittest

import os
import sys
sys.path.insert(0, os.path.abspath('..'))

import math
from pylib.mathematics import vector, matrix

class TestGeometry(unittest.TestCase):

  #
  # vector
  # NOTE: vector: scalar != 1 element vector
  #

  def test_vector(self):
    self.assertEqual(
        vector(),
        [])
    self.assertEqual(
        vector([1, 0, 0, 1]),
        [1, 0, 0, 1])

  def test_vector_mul_vs(self):
    self.assertEqual(
        vector([1, 2, 3]) * 4,
        [4, 8, 12])
    self.assertEqual(
        vector([-1, -2, -3]) * 4,
        [-4, -8, -12])
    self.assertEqual(
        vector([1, 2, 3]) * -4,
        [-4, -8, -12])
    self.assertEqual(
        vector([-1, -2, -3]) * -4,
        [4, 8, 12])

  def test_vector_mul_vv(self):
    self.assertEqual(
        vector([1, 2, 3]) * vector([1, 2, 3]),
        14)
    self.assertEqual(
        vector([-1, -2, -3]) * vector([1, 2, 3]),
        -14)
    self.assertEqual(
        vector([1, 2, 3]) * vector([-1, -2, -3]),
        -14)
    self.assertEqual(
        vector([-1, -2, -3]) * vector([-1, -2, -3]),
        14)

  def test_vector_mul_vm(self):
    r"""
    .. math::
      &
      \begin{bmatrix}
        1 & 2 & 3
      \end{bmatrix}
      \cdot
      \begin{bmatrix}
        1 & 2 & 3 \\
        4 & 5 & 6 \\
        7 & 8 & 9
      \end{bmatrix}
      \\
      =&
      \begin{bmatrix}
        1+8+21 & 2+10+24 & 3+12+27
      \end{bmatrix}
      \\
      =&
      \begin{bmatrix}
        30 & 36 & 42
      \end{bmatrix}
    """
    self.assertEqual(
        vector([1, 2, 3]) * matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]),
        [30, 36, 42])
    self.assertEqual(
        vector([-1, -2, -3]) * matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]),
        [-30, -36, -42])
    self.assertEqual(
        vector([1, 2, 3]) * matrix([[-1, -2, -3], [-4, -5, -6], [-7, -8, -9]]),
        [-30, -36, -42])
    self.assertEqual(
        vector([-1, -2, -3]) * matrix([[-1, -2, -3], [-4, -5, -6], [-7, -8, -9]]),
        [30, 36, 42])

  def test_vector_rmul_sv(self):
    self.assertEqual(
        4 * vector([1, 2, 3]),
        [4, 8, 12])
    self.assertEqual(
        -4 * vector([1, 2, 3]),
        [-4, -8, -12])
    self.assertEqual(
        4 * vector([-1, -2, -3]),
        [-4, -8, -12])
    self.assertEqual(
        -4 * vector([-1, -2, -3]),
        [4, 8, 12])

  def test_vector_rmul_mv(self):
    # 2d list * vector, matrix * vector see matrix.__mul__
    self.assertEqual(
        [[1, 2, 3], [4, 5, 6], [7, 8, 9]] * vector([1, 2, 3]),
        [14, 32, 50])
    self.assertEqual(
        [[-1, -2, -3], [-4, -5, -6], [-7, -8, -9]] * vector([1, 2, 3]),
        [-14, -32, -50])
    self.assertEqual(
        [[1, 2, 3], [4, 5, 6], [7, 8, 9]] * vector([-1, -2, -3]),
        [-14, -32, -50])
    self.assertEqual(
        [[-1, -2, -3], [-4, -5, -6], [-7, -8, -9]] * vector([-1, -2, -3]),
        [14, 32, 50])

  def test_vector_abs(self):
    self.assertEqual(
        abs(vector([0.6, 0.8])),
        1)
    self.assertEqual(
        abs(vector([3, 4])),
        5)

  def test_vector_full(self):
    self.assertEqual(
        vector.full(3, 7),
        [7, 7, 7])

  def test_vector_zeros(self):
    self.assertEqual(
        vector.zeros(3),
        [0, 0, 0])
    self.assertEqual(
        vector.zeros((3)),
        [0, 0, 0])
    self.assertEqual(
        vector.zeros(-1),
        [])

  def test_vector_ones(self):
    self.assertEqual(
        vector.ones(3),
        [1, 1, 1])
    self.assertEqual(
        vector.ones((3)),
        [1, 1, 1])
    self.assertEqual(
        vector.ones(-1),
        [])

  def test_vector_random(self):
    obj = vector.random(3)
    self.assertEqual(
        len(obj),
        3)

  def test_vector_ang(self):
    a = vector([1, 0])
    b = vector([0, 1])
    print(vector.ang(a,b), vector.ang(b, a))
    self.assertEqual(
      vector.ang(a, b),
      math.pi/2)
    self.assertEqual(
      vector.ang(b, a),
      math.pi/2)

  def test_vector_normalized(self):
    v1 = vector([3, 4])
    v2 = vector.normalized(v1)
    self.assertEqual(
        v2,
        [0.6, 0.8])
    self.assertEqual(
        abs(v2),
        1)
    self.assertEqual(
        v1,
        [3, 4])

  def test_vector_normalize(self):
    v1 = vector([3, 4])
    v2 = v1.normalize()
    self.assertEqual(
        v2,
        [0.6, 0.8])
    self.assertEqual(
        abs(v2),
        1)
    self.assertEqual(
        v1,
        [0.6, 0.8])

  def test_vector_rotate_x(self):
    # rotation of vector coordinate system about x axis

    # vector points to x -> vector points to x still
    self.assertEqual(                             vector([1, 0, 0, 1]).rotate_x(math.pi/2), [1, 0, 0, 1])
    # vector points to y -> vector points to -z
    [self.assertAlmostEqual(i, j) for i, j in zip(vector([0, 1, 0, 1]).rotate_x(math.pi/2), [0, 0, 1, 1])]
    # vector points to z -> vector points to y
    [self.assertAlmostEqual(i, j) for i, j in zip(vector([0, 0, 1, 1]).rotate_x(math.pi/2), [0, -1, 0, 1])]

  def test_vector_rotate_y(self):
    # rotation of vector coordinate system about y axis

    # vector points to x ->, vector points to z
    [self.assertAlmostEqual(i, j) for i, j in zip(vector([1, 0, 0, 1]).rotate_y(math.pi/2), [0, 0, -1, 1])]
    # vector points to y -> vector points to y still
    self.assertEqual(                             vector([0, 1, 0, 1]).rotate_y(math.pi/2), [0, 1, 0, 1])
    # vector points to z -> vector points to -x
    [self.assertAlmostEqual(i, j) for i, j in zip(vector([0, 0, 1, 1]).rotate_y(math.pi/2), [1, 0, 0, 1])]

  def test_vector_rotate_z(self):
    # rotation of vector coordinate system about z axis

    # vector points to x ->, vector points to z
    [self.assertAlmostEqual(i, j) for i, j in zip(vector([1, 0, 0, 1]).rotate_z(math.pi/2), [0, 1, 0, 1])]
    # vector points to y -> vector points to
    [self.assertAlmostEqual(i, j) for i, j in zip(vector([0, 1, 0, 1]).rotate_z(math.pi/2), [-1, 0, 0, 1])]
    # vector points to z -> vector points to z still
    self.assertEqual(                             vector([0, 0, 1, 1]).rotate_z(math.pi/2), [0, 0, 1, 1])

  #
  # matrix
  # NOTE: matrix: scalar != 1x1 matrix
  #

  def test_matrix_mul_ms(self):
    self.assertEqual(
        matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) * 4,
        [[4, 8, 12], [16, 20, 24], [28, 32, 36]])
    self.assertEqual(
        matrix([[-1, -2, -3], [-4, -5, -6], [-7, -8, -9]]) * 4,
        [[-4, -8, -12], [-16, -20, -24], [-28, -32, -36]])
    self.assertEqual(
        matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) * -4,
        [[-4, -8, -12], [-16, -20, -24], [-28, -32, -36]])
    self.assertEqual(
        matrix([[-1, -2, -3], [-4, -5, -6], [-7, -8, -9]]) * -4,
        [[4, 8, 12], [16, 20, 24], [28, 32, 36]])

  def test_matrix_mul_mv(self):
    r"""
    .. math::
      \begin{bmatrix}
        1 & 2 & 3 \\
        4 & 5 & 6 \\
        7 & 8 & 9
      \end{bmatrix}
      \cdot
      \begin{bmatrix}
        1 \\
        2 \\
        3
      \end{bmatrix}
      =
      \begin{bmatrix}
        1+4+9   \\
        4+10+18 \\
        7+16+27
      \end{bmatrix}
      =
      \begin{bmatrix}
        14 \\
        32 \\
        50
      \end{bmatrix}
    """
    self.assertEqual(
        matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) * vector([1, 2, 3]),
        [14, 32, 50])
    self.assertEqual(
        matrix([[-1, -2, -3], [-4, -5, -6], [-7, -8, -9]]) * vector([1, 2, 3]),
        [-14, -32, -50])
    self.assertEqual(
        matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) * vector([-1, -2, -3]),
        [-14, -32, -50])
    self.assertEqual(
        matrix([[-1, -2, -3], [-4, -5, -6], [-7, -8, -9]]) * vector([-1, -2, -3]),
        [14, 32, 50])

    self.assertEqual(
        matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) * matrix([[1], [2], [3]]),
        [[14], [32], [50]])
    self.assertEqual(
        matrix([[-1, -2, -3], [-4, -5, -6], [-7, -8, -9]]) * matrix([[1], [2], [3]]),
        [[-14], [-32], [-50]])
    self.assertEqual(
        matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) * matrix([[-1], [-2], [-3]]),
        [[-14], [-32], [-50]])
    self.assertEqual(
        matrix([[-1, -2, -3], [-4, -5, -6], [-7, -8, -9]]) * matrix([[-1], [-2], [-3]]),
        [[14], [32], [50]])

  def test_matrix_mul_vm(self):
    # matrix-vector * matrix, vector * matrix see vector.__mul__
    self.assertEqual(
        matrix([[1, 2, 3]]) * matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]),
        [[30, 36, 42]])
    self.assertEqual(
        matrix([[-1, -2, -3]]) * matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]),
        [[-30, -36, -42]])
    self.assertEqual(
        matrix([[1, 2, 3]]) * matrix([[-1, -2, -3], [-4, -5, -6], [-7, -8, -9]]),
        [[-30, -36, -42]])
    self.assertEqual(
        matrix([[-1, -2, -3]]) * matrix([[-1, -2, -3], [-4, -5, -6], [-7, -8, -9]]),
        [[30, 36, 42]])

  def test_matrix_mul_mm(self):
    r"""
    .. math::
      &
      \begin{bmatrix}
        1 & 2 & 3 \\
        4 & 5 & 6 \\
        7 & 8 & 9
      \end{bmatrix}
      \cdot
      \begin{bmatrix}
        11 & 12 & 13 \\
        14 & 15 & 16 \\
        17 & 18 & 19
      \end{bmatrix}
      \\
      =&
      \begin{bmatrix}
        11+28+51   & 12+30+54   & 13+32+57   \\
        44+70+102  & 48+75+108  & 52+80+114  \\
        77+112+153 & 84+120+162 & 91+128+171
      \end{bmatrix}
      \\
      =&
      \begin{bmatrix}
        90  & 96  & 102 \\
        216 & 231 & 246 \\
        342 & 366 & 390
      \end{bmatrix}

    interesting

    .. math::
      90  \xrightarrow{+6}  96  \xrightarrow{+6}  102 \quad &\Big| \sum\{1, 2, 3\} = 6  \\
      216 \xrightarrow{+15} 231 \xrightarrow{+15} 246 \quad &\Big| \sum\{4, 5, 6\} = 15 \\
      342 \xrightarrow{+24} 366 \xrightarrow{+24} 390 \quad &\Big| \sum\{7, 8, 9\} = 24

    .. math::
      90  \xrightarrow{+126} 216 \xrightarrow{+126} 342 \quad &\Big| \sum\{11, 14, 17\} = 42 = 126/3 \\
      96  \xrightarrow{+135} 231 \xrightarrow{+135} 366 \quad &\Big| \sum\{12, 15, 18\} = 45 = 135/3 \\
      102 \xrightarrow{+144} 246 \xrightarrow{+144} 390 \quad &\Big| \sum\{13, 16, 19\} = 48 = 144/3
    """
    self.assertEqual(
        matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) * matrix([[11, 12, 13], [14, 15, 16], [17, 18, 19]]),
        [[90, 96, 102], [216, 231, 246], [342, 366, 390]])
    self.assertEqual(
        matrix([[-1, -2, -3], [-4, -5, -6], [-7, -8, -9]]) * matrix([[11, 12, 13], [14, 15, 16], [17, 18, 19]]),
        [[-90, -96, -102], [-216, -231, -246], [-342, -366, -390]])
    self.assertEqual(
        matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) * matrix([[-11, -12, -13], [-14, -15, -16], [-17, -18, -19]]),
        [[-90, -96, -102], [-216, -231, -246], [-342, -366, -390]])
    self.assertEqual(
        matrix([[-1, -2, -3], [-4, -5, -6], [-7, -8, -9]]) * matrix([[-11, -12, -13], [-14, -15, -16], [-17, -18, -19]]),
        [[90, 96, 102], [216, 231, 246], [342, 366, 390]])

  def test_matrix_rmul_sm(self):
    self.assertEqual(
        4 * matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]),
        [[4, 8, 12], [16, 20, 24], [28, 32, 36]])
    self.assertEqual(
        -4 * matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]),
        [[-4, -8, -12], [-16, -20, -24], [-28, -32, -36]])
    self.assertEqual(
        4 * matrix([[-1, -2, -3], [-4, -5, -6], [-7, -8, -9]]),
        [[-4, -8, -12], [-16, -20, -24], [-28, -32, -36]])
    self.assertEqual(
        -4 * matrix([[-1, -2, -3], [-4, -5, -6], [-7, -8, -9]]),
        [[4, 8, 12], [16, 20, 24], [28, 32, 36]])

  def test_matrix_rmul_vm(self):
    # 1d list * matrix, vector * matrix see vector.__mul__
    self.assertEqual(
        [1, 2, 3] * matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]),
        [30, 36, 42])
    self.assertEqual(
        [-1, -2, -3] * matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]),
        [-30, -36, -42])
    self.assertEqual(
        [1, 2, 3] * matrix([[-1, -2, -3], [-4, -5, -6], [-7, -8, -9]]),
        [-30, -36, -42])
    self.assertEqual(
        [-1, -2, -3] * matrix([[-1, -2, -3], [-4, -5, -6], [-7, -8, -9]]),
        [30, 36, 42])

  def test_matrix_rmul_mm(self):
    # 2d list * matrix, matrix * matrix see matrix.__mul__
    self.assertEqual(
        [[1, 2, 3], [4, 5, 6], [7, 8, 9]] * matrix([[11, 12, 13], [14, 15, 16], [17, 18, 19]]),
        [[90, 96, 102], [216, 231, 246], [342, 366, 390]])
    self.assertEqual(
        [[-1, -2, -3], [-4, -5, -6], [-7, -8, -9]] * matrix([[11, 12, 13], [14, 15, 16], [17, 18, 19]]),
        [[-90, -96, -102], [-216, -231, -246], [-342, -366, -390]])
    self.assertEqual(
        [[1, 2, 3], [4, 5, 6], [7, 8, 9]] * matrix([[-11, -12, -13], [-14, -15, -16], [-17, -18, -19]]),
        [[-90, -96, -102], [-216, -231, -246], [-342, -366, -390]])
    self.assertEqual(
        [[-1, -2, -3], [-4, -5, -6], [-7, -8, -9]] * matrix([[-11, -12, -13], [-14, -15, -16], [-17, -18, -19]]),
        [[90, 96, 102], [216, 231, 246], [342, 366, 390]])


if __name__ == '__main__':
  unittest.main(verbosity=2)