Least recently used matrix

matrix-least-recently-used.py

#!/usr/bin/env python
import string
import sys

class LeastRecentlyUsedMatrix(object):
    """
    Output matrix in table format
    Return least recently used references
    """
    MAX_MATRIX_SIZE = 70

    def page_is_referenced(self, matrix, page):
        """
        Rows = 1,1,1,1
        Columns = 0,0,0,0
        """
        matrix[page] = [1]*len(matrix)
        for i in range(len(matrix)):
            matrix[i][page] = 0
        return matrix

    def matrix_table_format(self,matrix):
        """
        Output matrix in table format
          1 2
        1 0 0
        2 0 0
        """
        matrix_table = ''
        pages =range(len(matrix))
        format = ["%2d"]*len(matrix)
        matrix_table += " ".join(["%2s"] + format) % tuple(['x'] + pages) + '\n'
        for points in matrix:
            matrix_table += " ".join(["%2d"] + format) % tuple([pages.pop(0)] + points) + '\n'
        return matrix_table

    def least_recently_used(self, matrix):
        """
        Return least referenced page(s) from multi dimensional list
        """
        least_value = None
        for idx, val in enumerate(matrix):
            page_value = int("".join(map(str, val)), 2)
            if  least_value == None or least_value > page_value:
                least_recently_used = []
                least_recently_used.append(idx)
                least_value = page_value
            elif least_value == page_value:
                least_recently_used.append(idx)

        return least_recently_used

    def run(self, matrix_size, reference_pages):
        """
        Matrix size : integer
        Reference pages : integer [integer,]
        """
        try:
            matrix_size = int(matrix_size)
            reference_pages = map(int,reference_pages)

            if  not (0 < matrix_size <= LeastRecentlyUsedMatrix.MAX_MATRIX_SIZE):
                print "Matrix too large: %d outside range: %d" % (
                        matrix_size, LeastRecentlyUsedMatrix.MAX_MATRIX_SIZE
                        )
                raise ValueError
            elif not reference_pages:
                print "Please enter the page references"
                raise IndexError
            elif  max(reference_pages) >= matrix_size:
                print "Page reference: %d must be within matrix range: %d" % (
                        max(reference_pages), matrix_size-1
                        )
                raise IndexError
        except (IndexError,ValueError):
            print self.run.__doc__
            sys.exit(1)

        # Set up matrix, initialize all values = 0
        matrix = [[0]*matrix_size]*matrix_size

        # Pages referenced in matrix
        for page in reference_pages:
            matrix = self.page_is_referenced(matrix,page)

        print self.matrix_table_format(matrix)
        print "\nLeast recently used\n", self.least_recently_used(matrix)

if __name__ == "__main__":
    try:
        LeastRecentlyUsedMatrix().run(sys.argv[1], sys.argv[2:])
    except IndexError:
        print LeastRecentlyUsedMatrix.run.__doc__