from Matrix import Matrix
from FiniteField import FiniteFieldGF7
        
class FiniteFieldMatrix( Matrix ):
    
    def __init__(self,*args, **kwargs):
        self.inverse_element = self.class_type(1)
        super(FiniteFieldMatrix, self).__init__(*args, **kwargs)


import unittest
class TestOtherFiniteFieldFunctions(unittest.TestCase):
    def setUp(self):
        self.test_matrix = [[2,1,0,7,6,5,4,3],
                            [3,1,2,4,7,5,6,0],
                            [5,6,3,4,1,2,7,0]]
        self.square_matrix = [[2,1,0,],
                              [3,1,2,],
                              [5,6,3,]]
        self.known_invertable = [[1,1,1],
                                 [4,3,6],
                                 [0,0,1]]        
        self.inverse_value = [[7,4,2],
                              [6,4,3],
                              [0,0,1]]        
    def testClass(self):
        from FiniteField import FiniteFieldGF257 as myfield
        ffm = FiniteFieldMatrix(2,class_type=myfield)
        for i in range(0,2):
            for j in range(0,2):
                self.failUnless(isinstance(ffm.m[i][j],myfield), "FiniteFieldMatrix was built with %s but has %s objects" % (myfield.__name__,ffm.m[i][j].__class__))

    def testClassTypeOfTestMatrix(self):
        from FiniteField import FiniteFieldGF257 as myfield
        ffm = FiniteFieldMatrix(self.test_matrix,class_type=myfield)
        for i in range(0,ffm.rows()):
            for j in range(0,ffm.cols()):
                self.failUnless(isinstance(ffm.m[i][j],myfield), "FiniteFieldMatrix was built with %s but has %s objects" % (myfield.__name__,ffm.m[i][j].__class__))

    def testAddition(self):
        from FiniteField import FiniteFieldGF257 as myfield
        ffm = FiniteFieldMatrix(self.test_matrix,class_type=myfield)
        test = ffm+ffm
        for i in range(0,test.rows()):
            for j in range(0,test.cols()):
                self.failUnless(isinstance(test.m[i][j],myfield), "FiniteFieldMatrix was built with %s but has %s objects" % (myfield.__name__,test.m[i][j].__class__))

    def testDotProduct(self):
        from FiniteField import FiniteFieldGF7 as myfield
        ffm = FiniteFieldMatrix(self.square_matrix,class_type=myfield)
        test = ffm*ffm
        for i in range(0,test.rows()):
            for j in range(0,test.cols()):
                self.failUnless(isinstance(test.m[i][j],myfield), "FiniteFieldMatrix was built with %s but has %s objects" % (myfield.__name__,test.m[i][j].__class__))
                self.failUnless(test.m[i][j] <= 7, "FiniteFieldMatrix build with GF(7) but has a value greater than 7: %d" % test.m[i][j])

    def testGauss(self):
        from FiniteField import FiniteFieldGF7 as myfield
        ffm = FiniteFieldMatrix(self.known_invertable,class_type=myfield)
        self.failUnless(ffm.gauss_jordan(), "Could not preform gauss elimination on a known invertable matrix")
        
    def testInverse(self):
        from FiniteField import FiniteFieldGF7 as myfield
        ffm = FiniteFieldMatrix(self.known_invertable,class_type=myfield)
        inverse = ffm.inverse()
        for i in range(0,inverse.rows()):
            for j in range(0,inverse.cols()):
                self.failUnless(isinstance(inverse.m[i][j],myfield), "FiniteFieldMatrix was built with %s but has %s objects" % (myfield.__name__,inverse.m[i][j].__class__))
                self.failUnless(inverse.m[i][j] <= 7, "FiniteFieldMatrix build with GF(7) but has a value greater than 7: %d" % inverse.m[i][j])
                self.failUnless(inverse.m[i][j] == self.inverse_value[i][j], "Found inverse value of %d but expected %d -\n%s\n%s" % (inverse.m[i][j], self.inverse_value[i][j], str(inverse), str(self.inverse_value)))
                    

if __name__ == "__main__":
    unittest.main()