#encoding: utf-8
import sys
class SimpleMatrix(object):
    """Klassen kan repræsentere en matrix (tabel) med
    m > 0 rækker og n > 0 søjler hvis elementer er reelle tal, samt den tomme 0 × 0 matrix
    med m = n = 0. Klassen skal som minimum have metoderne:"""
    def __init__(self,m=0,n=0,values=[]):
        self.rows = m
        self.columns = n
        """ Laver en matrice ud fra nogen pramerer. hvis der ikke er nogen værdier i values, vil der blive retuneret en 0 matrix á m*n """
        if len(values) > m*n:
             raise ValueError("Values can't be larger than m * n")
                #print "Values can't be larger than m * n"
        elif len(values)>0:
            self.matrix = [ [0 for i in xrange (n)] for j in xrange(m)]
            var = 0
            for x in xrange(len(self.matrix)):
                for y in xrange(len(self.matrix[x])):
                    if var< len(values):
                        self.matrix[x][y] = values[var]
                        var = var+1
                    else:
                        self.matrix[x][y]=0
        else:
            self.matrix = [ [0 for i in xrange (n)] for j in xrange(m)]
    def __str__(self):
        """Returnerer en tegnstreng, der opstiller matricens værdier på tabelform (række for række med linjeskift efter hver række)."""
        string = ""
        for x in xrange(len(self.matrix) ):
            for y in xrange( len(self.matrix[x]) ):
                string = string + str( self.matrix[x][y] ) + "\t"

            string = string +  "\n"
        return string
    def read(self,filename):
        """Erstatter matricen med den, som indlæses fra filen filename.
        Jeg går ud fra at jeg får at matricen er giver med tabs som afstand imellem søjlerne og newlines imellem rækkerne (se evt write)"""
        f= open(filename, "r")
        #Jeg benytter mig af readlines() for at optimere indlæsningen af filen.
        lines=f.readlines()
        m = len(lines)
        n = len(lines[0].rstrip("\n").split())
        values = []
        for line in lines:
            line = line.rstrip("\n").split()
            for element in line:
                values.append(int(element))
        return SimpleMatrix(m,n,values)
    def write(self,filename):
        """udskriver matricens værdier til filen filename på en måde, som kan læses af read(filename)."""
        f = open(filename, "w+")
        string = ""
        print self
        for line in self.matrix:
            for element in line:
                string =string + str(element)+ "\t"
            string = string + "\n"
        f.write(string)
    def __add__(self,other):
        """som elementvis adderer 2 matricer af samme størrelse.
        Denne metode bruger + operatoren imellem to matricer"""
        if self.rows == other.rows and self.columns == other.columns:
            sum_values = []
            for x in range(self.rows):
                for y in range(self.columns):
                    sum_values.append(self.matrix[x][y] + other.matrix[x][y])
            self = SimpleMatrix(self.rows,self.columns,sum_values)
            return self

        else:
            raise ValueError("I can't add these matrices, because they're not the same size.")
    def __mul__(self,other):
        """multiplicerer 2 matricer når antallet af søjler i den første er lig antallet af rækker i den næste.
        Denne metode bruger * operatoren imellem 2 matricer"""
        if self.columns == other.rows :
            colself = []
            rowother = other.matrix
            a= self.columns
            b= other.rows

            mulmatrix  = SimpleMatrix(a,b)

            for x in xrange(mulmatrix.rows):
                for y in xrange(mulmatrix.columns):
                    counter =0
                    for z in xrange(self.rows):
                        counter += self.matrix[z][y]*other.matrix[x][z]
                    mulmatrix.matrix[x][y] = counter
            return mulmatrix
        else:
            raise ValueError("Matricerne kan ikke multipliceres, da dem første matrices søjle er ikke lig med anallaet af rækker i den anden matrice")
    def __eq__(self,other):
        """Sammenligner 2 matricer af samme dimension og returnerer True,hvis og kun hvis alle elementer er ens, ellers returneres False. Denne metode overskriver sammenligningsoperatoren ==."""

        if self.rows == other.rows and self.columns==other.columns:
            for x in xrange(self.rows):
                for y in xrange(self.columns):
                    if self.matrix[x][y] != other.matrix[x][y]:
                        return False
            return True
        else:
            return False
    def __ne__(self,other):
        """Sammenligner 2 matricer af samme dimension og returnerer False, hvis og kun hvis alle elementer er ens, ellers returneres True
        Denne metode overskriver sammenligningsoperatoren !=."""
        if self.rows == other.rows and self.columns==other.columns:
            for x in xrange(self.rows):
                for y in xrange(self.columns):
                    if self.matrix[x][y] != other.matrix[x][y]:
                        return True
            return False
        else:
            return True

def test():

    print  "Hver gang en matrix printes er det et udtryk for at __str__ virker. \n"

    print"test af __init__"
    nulmatrix = SimpleMatrix()
    print nulmatrix
    mnmatrix = SimpleMatrix(2,2)
    print mnmatrix
    numbers=[1,2,3,4,5,6,7,8,9]
    valuesmatrix = SimpleMatrix(3,3,numbers)
    print valuesmatrix
    print " test af __add__"
    A = SimpleMatrix(2 ,2, [1,2,3,4])
    B = SimpleMatrix(2, 2, [5,6,7,8])
    C = SimpleMatrix(2, 2, [6,8,10,12])
    print A+B
    print C == A+B


    print "test af __mul__"
    D = SimpleMatrix(3,3, numbers)

    E = SimpleMatrix(3, 2, [6,8,10,12])
    F = SimpleMatrix(2, 3, [6,8,10,12])
    print E
    print F*E

    print "test af write(filename)"
    writetest = D
    writetest.write("testmatrix.txt")
    print "test af read(filename)"
    readtest = SimpleMatrix()
    print readtest.read("testmatrix.txt")

    print "test af __eq__"
    G = SimpleMatrix(3,3, [8,2,3,4,5,6,7,8,9])
    print D == D
    print D== G
    print "test af __ne__"
    print D != D
    print D != G
print test