#!/usr/bin/env python

import unittest

from   interp import baker
from   interp import grid

import numpy as np
import scipy.spatial

class Test(unittest.TestCase):
  def setUp(self):
    self.l = [[-1, 1], [-1, 0], [-1, 1], [0, -1], [0, 0], [0, 1], [1, -1], [1, 0], [1, 1]]
    self.all_points = [
                        [ 0, 0], # 0
                        [ 1, 0], # 1
                        [ 1, 1], # 2
                        [ 0, 1], # 3
                        [ 1,-1], # 4
                        [ 0,-1], # 5
                        [-1, 1], # 6
                        [-1, 0], # 7
                        [-1,-1], # 8
                      ]
    self.q = [1, 0, 0, 0, 0, 0, 0, 0, 0]
    self.X = [0.5, 0.25]
    self.accuracy = 8

  def testImports(self):
    import numpy
    import scipy
    import interp.grid
    import interp.baker

  def testGetPhis(self):

    X = [0,0]
    r = [[-1, -1], [0, 2], [1, -1]]

    result = baker.get_phis(X, r)

    right_answer = [1/3.0, 1/3.0, 1/3.0]

    for a,b in zip(result, right_answer):
      self.assertAlmostEqual(a,b)

  def testGetPhis2(self):

    X = [0.5,0.25]
    r = [[0, 0], [1, 0], [1, 1]]

    result = baker.get_phis(X, r)

    right_answer = [0.5, 0.25, 0.25]

    for a,b in zip(result, right_answer):
      self.assertEqual(a,b)

  def testQlinear(self):
    X = [0.5, 0.25]
    r = [[0, 0], [1, 0], [1, 1]]
    q = [1, 0, 0]

    phi, result = baker.qlinear(X, grid.grid(r,q))

    right_answer = 0.5

    self.assertAlmostEqual(result, right_answer)

  def testRunBaker_1(self):
    size_of_simplex = 3
    extra_points    = 3

    R = grid.grid(self.all_points[:size_of_simplex],
                           self.q[:size_of_simplex])

    S = grid.grid(self.all_points[size_of_simplex:size_of_simplex + extra_points],
                           self.q[size_of_simplex:size_of_simplex + extra_points])


    answer = baker.run_baker(self.X, R, S)

    a = answer['abc'][0]
    b = answer['abc'][1]
    c = answer['abc'][2]

    self.assertEqual(sorted((a,b,c)), sorted((0,0.0,1/3.)))

  def testRunBaker_2(self):
    size_of_simplex = 3
    extra_points    = 4

    R = grid.grid(self.all_points[:size_of_simplex],
                           self.q[:size_of_simplex])

    S = grid.grid(self.all_points[size_of_simplex:size_of_simplex + extra_points],
                           self.q[size_of_simplex:size_of_simplex + extra_points])

    answer = baker.run_baker(self.X, R, S)

    a, b, c  = sorted(answer['abc'])
    aa,bb,cc = sorted((2/3.0, 2/3.0, 1/3.0))

    self.assertAlmostEqual(a,aa)
    self.assertAlmostEqual(b,bb)
    self.assertAlmostEqual(c,cc)

  def testRunBaker_3(self):
    size_of_simplex = 3
    extra_points    = 5

    R = grid.grid(self.all_points[:size_of_simplex],
                           self.q[:size_of_simplex])

    S = grid.grid(self.all_points[size_of_simplex:size_of_simplex + extra_points],
                           self.q[size_of_simplex:size_of_simplex + extra_points])

    answer = baker.run_baker(self.X, R, S)

    a = answer['abc'][0]
    b = answer['abc'][1]
    c = answer['abc'][2]

    a,b,c = sorted((a,b,c))
    aa, bb, cc = sorted((13/14., 2/7., 15/14.))

    self.assertAlmostEqual(a,aa)
    self.assertAlmostEqual(b,bb)
    self.assertAlmostEqual(c,cc)

  def testRunBaker_4(self):
    size_of_simplex = 3
    extra_points    = 6

    R = grid.grid(self.all_points[:size_of_simplex],
                           self.q[:size_of_simplex])

    S = grid.grid(self.all_points[size_of_simplex:size_of_simplex + extra_points],
                           self.q[size_of_simplex:size_of_simplex + extra_points])

    answer = baker.run_baker(self.X, R, S)
    a = answer['abc'][0]
    b = answer['abc'][1]
    c = answer['abc'][2]

    a,b,c = sorted((a,b,c))
    aa,bb,cc = sorted((48/53.0, 15/53.0, 54/53.0))

    self.assertAlmostEqual(a, aa)
    self.assertAlmostEqual(b, bb)
    self.assertAlmostEqual(c, cc)

if __name__ == '__main__':
  suite = unittest.TestLoader().loadTestsFromTestCase(Test)
  unittest.TextTestRunner(verbosity=3).run(suite)
