finitefield 0.0.1

data/LICENSE.txt

@@ -0,0 +1,52 @@
+FiniteField is copyrighted free software by Stephen Doyle <stephendoyle75@gmail.com>.
+You can redistribute it and/or modify it under either the terms of the GPL
+(see COPYING.txt file), or the conditions below:
+
+  1. You may make and give away verbatim copies of the source form of the
+     software without restriction, provided that you duplicate all of the
+     original copyright notices and associated disclaimers.
+
+  2. You may modify your copy of the software in any way, provided that
+     you do at least ONE of the following:
+
+       a) place your modifications in the Public Domain or otherwise
+          make them Freely Available, such as by posting said
+	  modifications to Usenet or an equivalent medium, or by allowing
+	  the author to include your modifications in the software.
+
+       b) use the modified software only within your corporation or
+          organization.
+
+       c) rename any non-standard executables so the names do not conflict
+	  with standard executables, which must also be provided.
+
+       d) make other distribution arrangements with the author.
+
+  3. You may distribute the software in object code or executable
+     form, provided that you do at least ONE of the following:
+
+       a) distribute the executables and library files of the software,
+	  together with instructions (in the manual page or equivalent)
+	  on where to get the original distribution.
+
+       b) accompany the distribution with the machine-readable source of
+	  the software.
+
+       c) give non-standard executables non-standard names, with
+          instructions on where to get the original software distribution.
+
+       d) make other distribution arrangements with the author.
+
+  4. You may modify and include the part of the software into any other
+     software (possibly commercial).  
+
+  5. The scripts and library files supplied as input to or produced as 
+     output from the software do not automatically fall under the
+     copyright of the software, but belong to whomever generated them, 
+     and may be sold commercially, and may be aggregated with this
+     software.
+
+  6. THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR
+     IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+     WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+     PURPOSE.

data/README.txt

@@ -0,0 +1,11 @@
+Introduction
+------------
+The finitefield library is a utility library that provides support for 
+performing operations on elements in a finite field. Basic operations 
+such as multiplication, division, inverse, addition and subtraction are 
+supported.
+
+The initial release of this library is limited in scope to only supporting
+fields of the form 2^n.
+
+

data/lib/finitefield.rb

@@ -0,0 +1,147 @@
+
+# Finite fields of characteristic 2
+
+class FiniteField
+  attr_reader :polynomial
+  attr_reader :p
+  
+  # Create a field of GF(2^n) using the specified generator polynomial
+  def initialize(n, polynomial)
+    @polynomial = polynomial
+    @n = n
+  end
+  
+  # Adds two finite field elements and returns the result.
+  def add(lhs, rhs)
+    # In characteristic two fields, addition is the xor operation.
+    lhs ^ rhs
+  end  
+  
+  # Subtracts the second argument from the first and return the
+  # result. In fields of characteristic two this is the same as 
+  # the add method.
+  def subtract(lhs, rhs)
+    add(lhs, rhs)
+  end
+  
+  # Multiplies two field elements, modulo the generator polynomial
+  # and returns the result.
+  def multiply(a, b)
+    m = multiplyWithoutReducing(a, b)
+    reduce(m)
+  end
+  
+  # Multiply two field exlements without modulo with the generator 
+  # polynomial.
+  def multiplyWithoutReducing(a, b)
+    result = 0
+    mask = 1
+    i = 0
+    
+    while i <= @n
+      if mask & b != 0
+        result ^= a
+      end
+      a <<= 1
+      mask <<= 1
+      i += 1
+    end
+    
+    return result
+  end
+  
+  # Reduce the input value by modulo with the generator polynomial
+  def reduce(a)
+    result = 0
+    i = degree(a)
+    mask = 1 << i
+    
+    while i >= @n
+      if mask & a != 0
+        result ^=  1 << (i - @n)
+        a = subtract(a, @polynomial << (i - @n))
+      end
+      i -= 1
+      mask >>= 1
+    end
+    return a
+  end
+  
+  # Computes the multiplicative inverse of the element and returns 
+  # the result.
+  def inverse(a)
+    remainder = [0,0,0]
+    quotient = [0,0,0]
+    auxillary = [0,0,0]
+    
+    remainder[1] = @polynomial
+    remainder[2] = a
+    auxillary[1] = 0
+    auxillary[2] = 1
+    i = 2
+    
+#    puts "#{remainder[i].to_s(base=16)} #{quotient[i].to_s(base=16)} #{auxillary[i].to_s(base=16)}"
+
+    while(remainder[i] > 1)
+      i += 1
+      result = binary_div(remainder[i-2], remainder[i-1])
+      remainder[i] = result[1]
+      quotient[i] = result[0]
+      auxillary[i] = binary_mul(quotient[i], auxillary[i-1]) ^ auxillary[i-2]
+#      puts "#{remainder[i].to_s(base=16)} #{quotient[i].to_s(base=16)} #{auxillary[i].to_s(base=16)}"
+    end
+    
+    return auxillary[i]
+  end
+  
+  # Division of two field elements (rhs/lhs). This is the same as
+  # rhs * lhs^-1 i.e. multiply(rhs, inverse(lhs))
+  def divide(lhs, rhs)
+    multiply(lhs, inverse(rhs))
+  end
+
+  # Find the degree of the polynomial representing the input field
+  # element v.  This takes O(degree(v)) operations. 
+  def degree(v)
+    if v != 0
+      result = -1
+      while v != 0
+        v >>= 1
+        result += 1
+      end
+      return result
+    end
+    return 0
+  end
+  
+  # Binary multiplication. Or more explicitly - multiplication over a binary field
+  def binary_mul(lhs, rhs)
+    result = 0
+    a = [degree(lhs), degree(rhs)].max
+    0.upto(a) do |i|
+      if lhs & (1 << i) != 0:
+        result ^= rhs
+      end
+      rhs <<= 1
+    end
+    return result
+  end
+
+  # Binary division. Or more explicitly - division over a binary field
+  def binary_div(lhs, rhs)
+    q = 0
+    r = lhs
+    p1 = degree(lhs)
+    p2 = degree(rhs)
+    
+    (p1 - p2 + 1).downto(0) do |i|
+      q <<= 1
+      if r & (1 << (p2+i)) != 0
+        q |= 1
+        r ^= (rhs << i)
+      end
+    end
+    return [q, r]
+  end
+
+end

data/test/tc_basic.rb

@@ -0,0 +1,29 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+
+require 'test/unit'
+require 'finitefield'
+
+class BasicTest < Test::Unit::TestCase
+
+  def setup
+    @field = FiniteField.new(8, 0x11D)
+  end
+  
+  def test_get_polynomial
+    assert_equal(0x11D, @field.polynomial)
+  end
+
+  def test_degree
+    assert_equal(8, @field.degree(0x11D))
+  end
+  
+  def test_binary_mul
+    assert_equal(0xa95, @field.binary_mul(0x53, 0x23))
+  end
+  
+  def test_binary_div
+    assert_equal([5, 4], @field.binary_div(0x11b, 0x53))
+  end
+end
+
+

data/test/tc_gf2.rb

@@ -0,0 +1,38 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+
+require 'test/unit'
+require 'finitefield'
+
+class GF2Test < Test::Unit::TestCase
+
+  def setup
+    @field = FiniteField.new(8, 0x11D)
+  end
+  
+  def test_gf2_addition_success
+    assert_equal(3, @field.add(0x1, 0x2))
+  end
+
+  def test_gf2_subtraction_success
+    assert_equal(1, @field.subtract(0x3, 0x2))
+  end
+  
+  def test_gf2_multiplication_success
+    assert_equal(0x6 , @field.multiply(0x3, 0x2))
+    assert_equal(0xc9 , @field.multiply(0xab, 0x11))
+    assert_equal(0x01, @field.multiply(0x8c, 0x53))
+  end
+
+  def test_gf2_inverse_success
+    f = FiniteField.new(8, 0x11B)
+    assert_equal(0xca, f.inverse(0x53))
+    assert_equal(0x8c, @field.inverse(0x53))
+  end
+
+  def test_gf2_division_success
+    assert_equal(0x11 , @field.divide(0xc9, 0xab))
+  end
+
+end
+
+

data/test/ts_finitefield.rb

@@ -0,0 +1,5 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+
+require 'test/unit'
+require 'tc_basic'
+require 'tc_gf2'

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification 
+name: finitefield
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Stephen Doyle
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-10-24 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+description: Finite Field implementation in Ruby.
+email: stephendoyle75@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README.txt
+- LICENSE.txt
+- lib/finitefield.rb
+- test/ts_finitefield.rb
+- test/tc_basic.rb
+- test/tc_gf2.rb
+has_rdoc: false
+homepage: http://finitefield.rubyforge.org/
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.0.1
+signing_key: 
+specification_version: 2
+summary: Finite Field implementation in Ruby.
+test_files: []
+