reps

character_table2.py

class Representation(object):

    character = []
    name = None
    
    def __init__(self, character, name = None):
        self.character = character
        self.name = name
        
    def __add__(self, other):
        new_character = [i + j for i, j in zip(self.character, other.character)]
        return Representation(new_character)
        
    def __mul__(self,other):
        new_character = [i * j for i, j in zip(self.character, other.character)]
        return Representation(new_character)
        
    def __pow__(self, n):
        new_character = [i ** n for i in self.character]
        return Representation(new_character)
        
    def __str__(self):
        out = self.name.ljust(10)
        for char in self.character:
            out = out + str(char).ljust(10)
        return out


class CharacterTable(object):
    representations = []
    conjClasses = []
    is_Full = None
    groupOrder = None
    
    def __init__(self, conjClasses):
        self.conjClasses = conjClasses
        self.groupOrder = sum(conjClasses)
        
    def __str__(self):
        out = ''.ljust(10)
        for size in self.conjClasses:
            out = out + str(size).ljust(10)
        out = out + '\n'
        for rep in self.representations:
            out = out + rep.name.ljust(10)
            for char in rep.character:
                out = out + str(char).ljust(10)
            out = out + '\n'
        return out    
    
    def inner(self, rep1, rep2):
        return sum([i * j * k for (i, j, k) in zip(self.conjClasses,
               rep1.character, rep2.character)])/self.groupOrder
       
    def append(self, rep):
        if self.is_Full is True:
            raise ValueError('Character table is full!')
        if len(self.conjClasses) == len(self.representations):
            self.is_Full = True
            raise ValueError('Character table is full!')
        if rep.character in [irrep.character for irrep in self.representations]:
            raise ValueError('Representation is already in table!')
        if self.inner(rep,rep) != 1: 
            raise ValueError('Representation is reducible!')
        if [irrep for irrep in self.representations if self.inner(rep,irrep) !=
           0] is []:
            raise ValueError('Representation is not orthogonal to the other'+
                  ' representations in the table!')            
        else:
            self.representations.append(rep)
       
    def erase(self, name = None):
        if name is None:           
            self.representations = []
        else:
            self.representations = [rep for rep in self.representations if
                                   rep.name != name] 
            
    def decompose(self,rep):    
        return [(irrep.name, self.inner(rep,irrep)) for irrep in 
               self.representations]
        
            
            
            
T = CharacterTable([1,3,2])            
a = Representation([1,1,1],'triv')
b = Representation([1,-1,1], 'alt')
c = Representation([2,0,-1], 'standard')
T.append(a)
T.append(b)
T.append(c)