Python/linear_algebra/src/lib.py

# -*- coding: utf-8 -*-
"""
Created on Mon Feb 26 14:29:11 2018

@author: Christian Bender
@license: MIT-license

This module contains some useful classes and functions for dealing
with linear algebra in python.

Overview:

- class Vector
- function zeroVector(dimension)
- function unitBasisVector(dimension,pos)
- function axpy(scalar,vector1,vector2)
- function randomVector(N,a,b)
- class Matrix
- function squareZeroMatrix(N)
- function randomMatrix(W,H,a,b)
"""


import math
import random


class Vector(object):
    """
        This class represents a vector of arbitray size.
        You need to give the vector components. 
        
        Overview about the methods:
        
        constructor(components : list) : init the vector
        set(components : list) : changes the vector components.
        __str__() : toString method
        component(i : int): gets the i-th component (start by 0)
        __len__() : gets the size of the vector (number of components)
        euclidLength() : returns the eulidean length of the vector.
        operator + : vector addition
        operator - : vector subtraction
        operator * : scalar multiplication and dot product
        copy() : copies this vector and returns it.
        changeComponent(pos,value) : changes the specified component.
        TODO: compare-operator
    """
    def __init__(self,components=[]):
        """
            input: components or nothing
            simple constructor for init the vector
        """
        self.__components = list(components)
    def set(self,components):
        """
            input: new components
            changes the components of the vector.
            replace the components with newer one.
        """
        if len(components) > 0:
            self.__components = list(components)
        else:
            raise Exception("please give any vector")
    def __str__(self):
        """
            returns a string representation of the vector
        """
        return "(" + ",".join(map(str, self.__components)) + ")"
    def component(self,i):
        """
            input: index (start at 0)
            output: the i-th component of the vector.
        """
        if type(i) is int and -len(self.__components) <= i < len(self.__components) :
            return self.__components[i]
        else:
            raise Exception("index out of range")
    def __len__(self):
        """
            returns the size of the vector
        """
        return len(self.__components)
    def eulidLength(self):
        """
            returns the eulidean length of the vector
        """
        summe = 0
        for c in self.__components:
            summe += c**2
        return math.sqrt(summe)
    def __add__(self,other):
        """
            input: other vector
            assumes: other vector has the same size
            returns a new vector that represents the sum.
        """
        size = len(self)
        if size == len(other):
            result = [self.__components[i] + other.component(i) for i in range(size)]
            return Vector(result)
        else:
            raise Exception("must have the same size")
    def __sub__(self,other):
        """
            input: other vector
            assumes: other vector has the same size
            returns a new vector that represents the differenz.
        """
        size = len(self)
        if size == len(other):
            result = [self.__components[i] - other.component(i) for i in range(size)]
            return result
        else: # error case
            raise Exception("must have the same size")
    def __mul__(self,other):
        """
            mul implements the scalar multiplication 
            and the dot-product
        """
        if isinstance(other,float) or isinstance(other,int):
            ans = [c*other for c in self.__components]
            return ans
        elif (isinstance(other,Vector) and (len(self) == len(other))):
            size = len(self)
            summe = 0
            for i in range(size):
                summe += self.__components[i] * other.component(i)
            return summe
        else: # error case
            raise Exception("invalide operand!")
    def copy(self):
        """
            copies this vector and returns it.
        """
        return Vector(self.__components)
    def changeComponent(self,pos,value):
        """
            input: an index (pos) and a value
            changes the specified component (pos) with the
            'value'
        """
        #precondition
        assert (-len(self.__components) <= pos < len(self.__components))
        self.__components[pos] = value
    
def zeroVector(dimension):
    """
        returns a zero-vector of size 'dimension'
    """        
    #precondition
    assert(isinstance(dimension,int))
    return Vector([0]*dimension)


def unitBasisVector(dimension,pos):
    """
        returns a unit basis vector with a One 
        at index 'pos' (indexing at 0)
    """
    #precondition
    assert(isinstance(dimension,int) and (isinstance(pos,int)))
    ans = [0]*dimension
    ans[pos] = 1
    return Vector(ans)
        

def axpy(scalar,x,y):
    """
        input: a 'scalar' and two vectors 'x' and 'y'
        output: a vector
        computes the axpy operation
    """
    # precondition
    assert(isinstance(x,Vector) and (isinstance(y,Vector)) \
    and (isinstance(scalar,int) or isinstance(scalar,float)))
    return (x*scalar + y)
    

def randomVector(N,a,b):
    """
        input: size (N) of the vector.
               random range (a,b)
        output: returns a random vector of size N, with 
                random integer components between 'a' and 'b'.
    """
    random.seed(None)
    ans = [random.randint(a,b) for i in range(N)]
    return Vector(ans)


class Matrix(object):
    """
    class: Matrix
    This class represents a arbitrary matrix.
    
    Overview about the methods:
    
           __str__() : returns a string representation 
           operator * : implements the matrix vector multiplication
                        implements the matrix-scalar multiplication.
           changeComponent(x,y,value) : changes the specified component.
           component(x,y) : returns the specified component.
           width() : returns the width of the matrix
           height() : returns the height of the matrix
           operator + : implements the matrix-addition.
           operator - _ implements the matrix-subtraction
    """
    def __init__(self,matrix,w,h):
        """
            simple constructor for initialzes 
            the matrix with components.
        """
        self.__matrix = matrix
        self.__width = w
        self.__height = h
    def __str__(self):
        """
            returns a string representation of this
            matrix.
        """
        ans = ""
        for i in range(self.__height):
            ans += "|"
            for j in range(self.__width):
                if j < self.__width -1:
                    ans += str(self.__matrix[i][j]) + ","
                else:
                    ans += str(self.__matrix[i][j]) + "|\n"
        return ans
    def changeComponent(self,x,y, value):
        """
            changes the x-y component of this matrix
        """
        if x >= 0 and x < self.__height and y >= 0 and y < self.__width:
            self.__matrix[x][y] = value
        else:
            raise Exception ("changeComponent: indices out of bounds")
    def component(self,x,y):
        """
            returns the specified (x,y) component
        """
        if x >= 0 and x < self.__height and y >= 0 and y < self.__width:
            return self.__matrix[x][y]
        else:
            raise Exception ("changeComponent: indices out of bounds")
    def width(self):
        """
            getter for the width
        """
        return self.__width
    def height(self):
        """
            getter for the height
        """
        return self.__height
    def __mul__(self,other):
        """
            implements the matrix-vector multiplication.
            implements the matrix-scalar multiplication
        """
        if isinstance(other, Vector): # vector-matrix 
            if (len(other) == self.__width):
                ans = zeroVector(self.__height)
                for i in range(self.__height):
                    summe = 0
                    for j in range(self.__width):
                        summe += other.component(j) * self.__matrix[i][j]
                    ans.changeComponent(i,summe)
                    summe = 0
                return ans
            else:
                raise Exception("vector must have the same size as the " + "number of columns of the matrix!")
        elif isinstance(other,int) or isinstance(other,float): # matrix-scalar
            matrix = [[self.__matrix[i][j] * other for j in range(self.__width)] for i in range(self.__height)]
            return Matrix(matrix,self.__width,self.__height)
    def __add__(self,other):
        """
            implements the matrix-addition.
        """
        if (self.__width == other.width() and self.__height == other.height()):
            matrix = []
            for i in range(self.__height):
                row = []
                for j in range(self.__width):
                    row.append(self.__matrix[i][j] + other.component(i,j))
                matrix.append(row)
            return Matrix(matrix,self.__width,self.__height)
        else:
            raise Exception("matrix must have the same dimension!")
    def __sub__(self,other):
        """
            implements the matrix-subtraction.
        """
        if (self.__width == other.width() and self.__height == other.height()):
            matrix = []
            for i in range(self.__height):
                row = []
                for j in range(self.__width):
                    row.append(self.__matrix[i][j] - other.component(i,j))
                matrix.append(row)
            return Matrix(matrix,self.__width,self.__height)
        else:
            raise Exception("matrix must have the same dimension!")
    

def squareZeroMatrix(N):
    """
        returns a square zero-matrix of dimension NxN
    """
    ans = [[0]*N for i in range(N)]
    return Matrix(ans,N,N)
    
    
def randomMatrix(W,H,a,b):
    """
        returns a random matrix WxH with integer components
        between 'a' and 'b'
    """
    random.seed(None)
    matrix = [[random.randint(a,b) for j in range(W)] for i in range(H)]
    return Matrix(matrix,W,H)