0

I have a class that was taking in lists of 1's and 0's and performing GF(2) finite field arithmetic operations. It used to work until I tried to make it take the input in polynomial format. As for how the finite arithmetic will be done after fixing the regex issue, I was thinking about overloading the operators.

The actual code in parsePolyToListInput(input) works when outside the class. The problem seems to be in the regex, which errors that it will only take in a string (this makes sense), but does not seem to initialize with self.expr as a parameter (that's a problem). The @staticmethod just before the initialization was an attempt to salvage the unbound error as it the polynomial was passed in, but this is apparently completely wrong. Just to save you time if you decide to look at any of the arithmetic operations, modular inverse does not work (seems to be due to the formatting issue after every iteration of that while loop for division in the function and what the return type is):

import re

class gf2poly:
    #binary arithemtic on polynomials
    #@staticmethod
    def __init__(self,expr):
        self.expr = expr
        #self.expr = [int(i) for i in expr]
        self.expr = gf2poly.parsePolyToListInput(self.expr)
    def convert(self):  #to clarify the input if necessary
        convertToString = str(self.expr)
        print "expression is %s"%(convertToString)
    def id(self): #returns modulus 2 (1,0,0,1,1,....) for input lists
        return [int(self.expr[i])%2 for i in range(len(self.expr))]
    def listToInt(self):  #converts list to integer for later use
        result = gf2poly.id(self)
        return int(''.join(map(str,result)))
    def prepBinary(a,b):  #converts to base 2 and orders min and max for use
        a = gf2poly.listToInt(a); b = gf2poly.listToInt(b)
        bina = int(str(a),2); binb = int(str(b),2)
        a = min(bina,binb); b = max(bina,binb);
        return a,b
    @staticmethod
    def outFormat(raw):
        raw = str(raw[::-1]); g = [] #reverse binary string for enumeration
        [g.append(i) for i,c in enumerate(raw) if c == '1']
        processed = "x**"+' + x**'.join(map(str, g[::-1]))
        if len(g) == 0: return 0 #return 0 if list empty
        return processed  #returns result in gf(2) polynomial form
    def parsePolyToListInput(poly):
        c = [int(i.group(0)) for i in re.finditer(r'\d+', poly)] #re.finditer returns an iterator
        #m = max(c)
        return [1 if x in c else 0  for x in xrange(max(c), -1, -1)]
        #return d
    def add(self,other): #accepts 2 lists as parameters
        a = gf2poly.listToInt(self); b = gf2poly.listToInt(other)
        bina = int(str(a),2); binb = int(str(b),2)
        m = bina^binb; z = "{0:b}".format(m)
        return z  #returns binary string
    def subtract(self,other):  #basically same as add() but built differently
        result = [self.expr[i] ^ other.expr[i] for i in range(len(max(self.expr,other.expr)))]
        return int(''.join(map(str,result)))
    def multiply(a,b): #a,b are lists like (1,0,1,0,0,1,....)
        a,b = gf2poly.prepBinary(a,b)
        g = []; bitsa = "{0:b}".format(a)
        [g.append((b<<i)*int(bit)) for i,bit in enumerate(bitsa)]
        m = reduce(lambda x,y: x^y,g); z = "{0:b}".format(m)
        return z #returns product of 2 polynomials in gf2
    def divide(a,b): #a,b are lists like (1,0,1,0,0,1,....)
        a,b = gf2poly.prepBinary(a,b)
        bitsa = "{0:b}".format(a); bitsb = "{0:b}".format(b)
        difflen = len(str(bitsb)) - len(str(bitsa))
        c = a<<difflen; q=0
        while difflen >= 0 and b != 0:  #a is divisor, b is dividend, b/a
            q+=1<<difflen; b = b^c  # b/a because of sorting in prep
            lendif = abs(len(str(bin(b))) - len(str(bin(c))))
            c = c>>lendif; difflen -= lendif
        r = "{0:b}".format(b); q = "{0:b}".format(q)
        return r,q #returns r remainder and q quotient in gf2 division
    def remainder(a,b): #separate function for clarity when calling
        r = gf2poly.divide(a,b)[0]; r = int(str(r),2)
        return "{0:b}".format(r)
    def quotient(a,b): #separate function for clarity when calling
        q = gf2poly.divide(a,b)[1]; q = int(str(q),2)
        return "{0:b}".format(q)
    def extendedEuclideanGF2(a,b): # extended euclidean. a,b are GF(2) polynomials in list form
        inita,initb=a,b;  x,prevx=0,1;  y,prevy = 1,0
        while sum(b) != 0:
            q = gf2poly.quotient(a,b);
            q = list(q); q = [int(x) for x in q]
            #q = list(q);
            #q = tuple([int(i) for i in q])
            q = gf2poly(q)
            a,b = b,gf2poly.remainder(a,b);
            #a = map(list, a);
            #b = [list(x) for x in a];
            #a = [int(x) for x in a]; b = [int(x) for x in b];
            b = list(b); b = [int(x) for x in b]
            #b = list(b);
            #b = tuple([int(i) for i in b])
            b = gf2poly(b)
            #x,prevx = (prevx-q*x, x);
            #y,prevy=(prevy-q*y, y)
            print "types  ",type(q),type(a),type(b)
            #q=a//b;  a,b = b,a%b;  x,prevx = (prevx-q*x, x);  y,prevy=(prevy-q*y, y)
        #print("%d * %d + %d * %d = %d" % (inita,prevx,initb,prevy,a))
        return a,prevx,prevy  # returns gcd of (a,b), and factors s and t
    def modular_inverse(a,mod): # where a,mod are GF(2) polynomials in list form
        gcd,s,t = gf2poly.extendedEuclideanGF2(a,mod); mi = gf2poly.remainder(s,mod)
        #gcd,s,t = ext_euc_alg_i(a,mod); mi = s%mod
        if gcd !=1: return False
        #print ("%d * %d mod %d = 1"%(a,mi,mod))
        return mi   # returns modular inverse of a,mod

I usually test it with this input:

a = x**14 + x**1 + x**0
p1 = gf2poly(a)
b = x**6 + x**2 + x**1
p2 = gf2poly(b)

The first thing you might notice about my code is that it's not very good. There are 2 reasons for that:

1) I wrote it so that the 1st version could do work in the finite field GF(2), and output in polynomial format. Then the next versions were supposed to be able to take polynomial inputs, and also perform the crucial 'modular inverse' function which is not working as planned (this means it's actually not working at all).

2) I'm teaching myself Python (I'm actually teaching myself programming overall), so any constructive criticism from pro Python programmers is welcome as I'm trying to break myself of beginner habits as quickly as possible.

EDIT:

Maybe some more of the code I've been testing with will help clarify what works and what doesn't:

t1 = [1,1,1]; t2 = [1,0,1]; t3 = [1,1]; t4 = [1, 0, 1, 1, 1, 1, 1]
t5 = [1,1,1,1]; t6 = [1,1,0,1]; t7 = [1,0,1,1,0]
f1 = gf2poly(t1); f2 = gf2poly(t2); f3 = gf2poly(t3); f4 = gf2poly(t4)
f5 = gf2poly(t5);f6 = gf2poly(t6);f7 = gf2poly(t7)
##print "subtract: ",a.subtract(b)
##print "add: ",a.add(b)
##print "multiply: ",gf2poly.multiply(f1,f3)
##print "multiply: ",gf2poly.multiply(f1,f2)
##print "multiply: ",gf2poly.multiply(f3,f4)
##print "degree a: ",a.degree()
##print "degree c: ",c.degree()
##print "divide: ",gf2poly.divide(f1,b)
##print "divide: ",gf2poly.divide(f4,a)
##print "divide: ",gf2poly.divide(f4,f2)
##print "divide: ",gf2poly.divide(f2,a)
##print "***********************************"
##print "quotient: ",gf2poly.quotient(f2,f5)
##print "remainder: ",gf2poly.remainder(f2,f5)
##testq = gf2poly.quotient(f4,f2)
##testr = gf2poly.remainder(f4,f2)
##print "quotient: ",testq,type(testq)
##print "remainder: ",testr,type(testr)
##print "***********************************"
##print "outFormat testp: ",gf2poly.outFormat(testq)
##print "outFormat testr: ",gf2poly.outFormat(testr)
##print "***********************************"
#print "gf2poly.modular_inverse():  ",gf2poly.modular_inverse(f2,f3)
print "p1  ",p1 #,type(f2),type(f3)
#print "parsePolyToListInput   ",gf2poly.parsePolyToListInput(a)
stackuser
  • 869
  • 16
  • 34

1 Answers1

0

Part of your problem is that you haven't declared self as an argument for parsePolyToListInput. When you call a method, the instance you call it on is implicitly bound as the first argument. Naming the first argument self is a convention, not a strict requirement - the instance is being bound to poly, which you then try to run a regexp over.

It looks me like there's some confusion in your design here about what's behavior of individual instances of the class and what's class-level or module-level behavior. In Python, it's perfectly acceptable to leave something that doesn't take an instance of a class as a parameter defined as a module-level function rather than shoehorning it in awkwardly. parsePolyToListInput might be one such function.

Your add implementation, similarly, has a comment saying it "accepts 2 lists as parameters". In fact, it's going to get a gf2poly instance as its first argument - this is probably right if you're planning to do operator overloading, but it means the second argument should also be a gf2poly instance as well.

EDIT: Yeah, your example code shows a breakdown between class behavior and instance behavior. Either your multiply call should look something like this:

print "multiply: ",f1.multiply(f3)

Or multiply shouldn't be a method at all:

gfpoly.py:
def multiply(f1, f2):
    a,b = prepBinary(a,b)
    g = []; bitsa = "{0:b}".format(a)
    [g.append((b<<i)*int(bit)) for i,bit in enumerate(bitsa)]
    m = reduce(lambda x,y: x^y,g); z = "{0:b}".format(m)
    return z #returns product of 2 polynomials in gf2

That latter approach is, for instance, how the standard math library does things.

The advantage of defining a multiplication method is that you could name it appropriately (http://docs.python.org/2/reference/datamodel.html#special-method-names) and use it with the * operator:

print "multiply: ",f1 *f3
Peter DeGlopper
  • 36,326
  • 7
  • 90
  • 83