mathsClass.py

# coding=utf8
''' Display the doc of all the defined classes
for i in [("\n".join(c)) for c in [[i for i in p.__doc__.split("\n")] for p in defined_class]]: print(i.encode('utf-8').decode('unicode-escape'))
'''

""" MATRIX CLASS"""
class Matrix():
    '''
    Class name : Matrix
    Class type : Math class
    Matrix implementation with methods :
        * initialisation
        * representation
        * addition
        * substraction
        * negation
        * multiplication
        * transpose (__invert__)
        * contain (python "in" funtion)
        * setitem (via matrix[(i,j)]=value)
        * len (return a tuple (i,j))
    '''
    def __init__(self, component):
        assert type(component) is list, str(type(component))+" type isn't supported by <class 'Matrix'>, must be <class 'list'>"

        h = len(component)
        assert h>0, "Empty matrix"

        l = max([len(i) for i in component]) # Search the max row size
        assert l>0, "Empty matrix"

        for i in range(len(component)): # Look in the entire matrix
            component[i]=component[i]+[0]*(l-len(component[i])) # Add missing 0

        self.comp = component # Correctly shaped matrix (fill w missing 0)
        self.l = l # Usefull because its often called in the Matrix class
        self.h = h # Same
        
    def __hash__(self):
        h=0
        for i in range(self.h):
            for j in range(self.l):
                h=h^hash(self.comp[i][j])
        return h
    
    def __repr__(self):
        return "\n".join(["\t".join([str(n) for n in i]) for i in self.comp])
    ## Other methods
    def len(self):
        return (self.h,self.l)

    def scal(self, scal):
        return Matrix([[scal*self.comp[i][j] for j in range(self.l)] for i in range(self.h)])
    ## magic methods
    #  Main magic methods
    def __add__(self, other):
        assert self.h==other.h and self.l==other.l, "Size error"
        return Matrix([[self.comp[i][j]+other.comp[i][j] for j in range(self.l)] for i in range(self.h)])

    def __sub__(self, other):
        return self+(-other)

    def __neg__(self):
        return self.scal(-1)

    def __mul__(self, other):
        if type(other)==type(self) and type(self)==Matrix:
            assert self.l==other.h, "Size error"
            return Matrix([[sum([self.comp[rowN][i]*other.comp[i][colN] for i in range(self.l)]) for colN in range(other.l)] for rowN in range(self.h)])
            '''
            The line above is a little bit too long so i split it here just for reader
    
            for rowN in range(self.h):
                for colN in range(other.l): #Change the name just for readability (cuz it's same as self.h)
                    for i in range(self.l)  #or range(other.h)
                        self.comp[rowN][i]*other.comp[i][colN]
            '''
        else:
            assert type(a)==Matrix and type(other)==type(0), 'nop, on fait Matrix()*n'
            return Matrix.scal(self,other)
    def __invert__(self):
        return Matrix([[self.comp[j][i] for j in range(self.h)] for i in range(self.l)])

    # Additional methods
    transpose = __invert__ #Create an alias of ~self

    def __contains__(self, item):
        checklist = set()
        for i in self.comp:  # Create a set with one occurence of each item in the matrix
            checklist = checklist | set(i)
        return (item in checklist) #Check item is in the set (python know this)
    def __iter__(self):
        for j in range(self.h):
            for i in range(self.l):
                yield self.comp(i,j)
        
    def __getitem__(self, key):
        return self.comp[key[0]][key[1]]

    def __setitem__(self, key, value): #use to redefine a value
        assert type(key) is tuple and len(key)==2, "The key is badly set please use mat[(i,j)]"
        self.comp[key[0]][key[1]] = value
        return self
    set = __setitem__
    
    def __eq__(self,other):
        return hash(a)==hash(b)

def MatNul(dim):
    return funcMatrix(dim, lambda i,j : 0)
    
def MatId(n):
    
    return Matrix([[1 if j==i else 0 for j in range(n)] for i in range(n)])
    
def funcMatrix(dim, func):
    return Matrix([[func(i,j) for j in range(dim[1])] for i in range(dim[0])])


""" COMPLEX CLASS """
class Complex():
    '''
    Class name : Complex
    Class type : Math class
    Complex implementation with methods :
        * initialisation
        * representation
        * real part
        * imaginary part
        * negation
        * equality
        * addition
        * multiplication
        * division
    '''
    def __init__(self, real, imag):
        self.r = real
        self.i = imag

    def __repr__(self):
        if self.r == 0:
            return str(self.i) + 'i'
        else:
            if self.i==0:
                return str(self.r)
            else:
                return str(self.r) + '+' + str(self.i) + 'i'

    def real(self):return self.r
    def imag(self):return self.i

    def __neg__(self):
        return Complex(self.r, -self.i)

    def __eq__(self,other):
        return self.r == other.r and self.i == other.i

    def __add__(self, other):
        return Complex(self.r+other.r, self.i+other.i)

    def __mul__(self, other):
        return Complex(self.r*other.r - self.i*other.i, self.r*other.i + other.r*self.i)

    def __truediv__(self, other):
        return Complex((-other*self).real()/(-other*other).real(),(-other*self).imag()/(-other*other).real())

""" RATIONAL CLASS"""
class Ratio():
    '''
    Class name : Rational
    Class type : Math class
    Rational implementation with methods :
        * initialisation
        * representation
        * equality (__eq__)
        * hash (for set purposes)
        * invert
        * negation
        * addition
        * multiplication
        * substraction
        * division
    '''
    from fractions import gcd

    def __init__(self, num, den):
        assert den != 0, 'Rationnel indéfini : den = 0'
        self.den = den
        self.num = num

    def __repr__(self):
        gc = gcd(self.num, self.den)
        return str(self.num//gc) +'/' + str(self.den//gc)

    def __hash__(self):
        return hash(self.num)^hash(self.den)

    def inv(self):
        return Ratio(self.den, self.num)

    #Classic ops
    def __eq__(self, other):
        return self.num * other.den == other.num * self.den

    def __neg__(self):
        return Ratio(-self.num, self.den)

    def __add__(self, other):
        return Ratio(self.num*other.den + other.num*self.den, other.den*self.den)

    def __mul__(self, other):
        return Ratio(self.num*other.num, self.den*other.den)

    def __sub__(self, other):
        return self + -other

    def __truediv__(self, other):
        return self * other.inv()

defined_class = [Matrix, Complex, Ratio] # Completed/functional classes