grafy grafy

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

# Grafy reprezentowane przy pomocy macierzy sąsiedztwa.
class AdjacencyMatrix:

    # Wyjątek pojawiający się przy próbie konwersji z błędnej reprezentacji tekstowej.
    class G6Error( Exception ): pass

    # Wyjątek pojawiający się przy próbie stworzenia grafu bez wierzchołków lub posiadającego > 63 wierzchołki.
    class LimitError( Exception ): pass

    # Tworzy graf o podanej reprezentacji tekstowej (domyślnie: 1-wierzchołkowy graf pusty).
    def __init__( self, text = "@" ):
        self.fromString( text )

    # Zwraca liczbę wierzchołków grafu.
    def order( self ): return self.__order

    # Dodaje do grafu nowy izolowany wierzchołek.
    def addVertex( self ):
        if self.__order == 63:
            raise AdjacencyMatrix.LimitError( "Graf nie może mieć więcej niż 63 wierzchołki" )
        for v in range( self.__order ):
            self.__matrix[v] += [False]
        self.__order += 1
        self.__matrix += [ [False] * self.__order ]

    # Usuwa z grafu wskazany wierzchołek.
    def deleteVertex( self, u ):
        if self.__order == 1:
            raise AdjacencyMatrix.LimitError( "Graf musi mieć wierzchołki" )
        if type( u ) != int or u < 0 or u >= self.__order:
            raise ValueError
        del self.__matrix[u]
        for v in range( self.__order - 1 ):
            del self.__matrix[v][u]
        self.__order -= 1

    # Zwraca informację o tym, czy podane wierzchołki sąsiadują z sobą.
    def isEdge( self, u, v ): return self.__matrix[u][v]

    # Dodaje podaną krawędź.
    def addEdge( self, u, v ):
        if type( u ) != int or u < 0 or u >= self.__order:
            raise ValueError
        if type( v ) != int or v < 0 or v >= self.__order:
            raise ValueError
        self.__matrix[u][v] = self.__matrix[v][u] = True

    # Usuwa podaną krawędź.
    def deleteEdge( self, u, v ):
        if type( u ) != int or u < 0 or u >= self.__order:
            raise ValueError
        if type( u ) != int or u < 0 or u >= self.__order:
            raise ValueError
        self.__matrix[u][v] = self.__matrix[v][u] = False

    # Przekształca reprezentację tekstową grafu w graf.
    def fromString( self, text ):
        try:
            t, k = iter( text ), 0
            c = ord( next( t ) ) - 63
            if c < 1 or c > 63:
                raise AdjacencyMatrix.G6Error( "niewłaściwa liczba wierzchołków: {0}".format( c ) )
            self.__order = c
            self.__matrix = [[False for v in range( c )] for u in range( c )]
            for v in range( 1, self.__order ):
                for u in range( v ):
                    if k == 0:
                        c = ord( next( t ) ) - 63
                        if c < 0 or c > 63:
                            raise AdjacencyMatrix.G6Error( "zakazany znak o kodzie {0}".format( c + 63 ) )
                        k = 6
                    k -= 1
                    if (c & (1 << k)) != 0:
                        self.__matrix[u][v] = self.__matrix[v][u] = True
        except StopIteration:
            raise AdjacencyMatrix.G6Error( "niekompletny napis" )
        try:
            c = ord( next( t ) )
            raise AdjacencyMatrix.G6Error( "nadmiarowy znak o kodzie {0}".format( c ) )
        except StopIteration:
            pass

    # Przekształca graf w reprezentację tekstową.
    def __str__( self ):
        text, k, c = chr( self.__order + 63 ), 5, 0
        for v in range( 1,self.__order ):
            for u in range( v ):
                if self.__matrix[u][v]:
                    c |= (1 << k)
                if k == 0:
                    text += chr( c + 63 )
                    k, c = 6, 0
                k -= 1
        if k != 5:
            text += chr( c + 63 )
        return text

    # Test równości dwóch reprezentacji grafów.
    def __eq__( self, other ):
        if self.__order != other.order():
            return False
        for v in range( 1, self.__order ):
            for u in range( v ):
                if self.__matrix[u][v] != other.isEdge( u, v ):
                    return False
        return True

    # Test różności dwóch reprezentacji grafów.
    def __ne__( self, other ):
        if self.__order != other.order():
            return True
        for v in range( 1, self.__order ):
            for u in range( v ):
                if self.__matrix[u][v] != other.isEdge( u, v ):
                    return True
        return False