rlsm 1.1.0 → 1.8.1

data/ext/binop/binop_c_ext.c

@@ -1,57 +0,0 @@
-#include <ruby.h>
-
-
-static VALUE 
-non_associative_triple(VALUE self) {
-  VALUE table = rb_iv_get(self, "@table");
-  VALUE max = NUM2INT(rb_iv_get(self, "@order"));  
-  VALUE base = rb_iv_get(self, "@elements");
-  
-  int i,j,k;
-  for (i=0; i < max; ++i) {
-    for (j=0; j < max; ++j) {
-      for (k=0; k < max; ++k) {
-        int ij,jk, i_jk, ij_k;
-        ij = NUM2INT(RARRAY(table)->ptr[max*i + j]);
-        jk = NUM2INT(RARRAY(table)->ptr[max*j + k]);
-        i_jk = NUM2INT(RARRAY(table)->ptr[max*i + jk]);
-        ij_k = NUM2INT(RARRAY(table)->ptr[max*ij + k]);
-        if (ij_k != i_jk) {
-          return (rb_ary_new3(3,RARRAY(base)->ptr[i],RARRAY(base)->ptr[j],RARRAY(base)->ptr[k]));
-        }
-      }
-    }
-  }
-  
-  return (Qnil);
-}
-
-static VALUE 
-is_commutative(VALUE self) {
-  VALUE table = rb_iv_get(self, "@table");
-  VALUE max = NUM2INT(rb_iv_get(self, "@order"));
-
-  int i,j;
-  for (i=0; i < max; ++i) {
-    for (j=0; j < max; ++j) {
-      if (NUM2INT(RARRAY(table)->ptr[max*i + j]) != NUM2INT(RARRAY(table)->ptr[max*j + i]))
-	return (Qfalse);
-    }
-  }
-
-  return (Qtrue);
-}
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-  void Init_binop_cext() {
-    VALUE rlsm = rb_define_module("RLSM");
-    VALUE binop = rb_define_class_under(rlsm, "BinaryOperation", rb_cObject);
-
-    rb_define_private_method(binop, "is_commutative", (VALUE(*)(ANYARGS))is_commutative, 0);
-    rb_define_private_method(binop, "non_associative_triple", (VALUE(*)(ANYARGS))non_associative_triple, 0);
-  }
-#ifdef __cplusplus
-}
-#endif

data/ext/binop/extconf.rb

@@ -1,2 +0,0 @@
-require 'mkmf'
-create_makefile('binop_cext')

data/lib/rlsm/binary_operation.rb

@@ -1,151 +0,0 @@
-require File.join(File.dirname(__FILE__), 'helper')
-RLSM.require_extension 'binop'
-
-module RLSM
-  class BinaryOperation
-    class << self; alias original_new new; end
-=begin rdoc
-Creates a BinaryOperation from given description and validates the result.
-Raises a ParseError if validation fails.
-
-The description is of the form
-  [<elements>:]<table>
-where the optional <elements> part lists the elements on which the binary 
-operation acts in the order in which they appear in the table part. 
-The elements are seperated by commas. The commas are optional if each 
-element is identified by a single letter. no withespaces are allowed in 
-an element identifier.
-
-The table part describes the transition table of the binary operation. 
-Rows are seperated by at least one whitespace character and elements in 
-a row are seperated by commas.  The commas are optional if each element 
-is identified by a single letter.
-If commas are used in one row to seperate the elements, one must use 
-commas in each row.
-
-*Remark*: If the elements part is omitted it is assumed that
-the elements are appearing in the right order and all elements
-are appearing. This is the case for a monoid with neutral element 
-in the first row.
-
-*Examples*
-  012 120 201
-  012:000 000 000
-  x1,x2,x3: x1,x2,x2 x2,x2,x1 x3,x2,x1
-  000 000 000   -> error
-  0,1,2 120 2,1,0 -> error
-=end
-    def self.new(description)
-      binop = new!(description)
-      validate(binop)
-
-      binop
-    end
-
-    #Like new, but without validation of the input.
-    def self.new!(description)
-      original_new *parse(description)
-    end
-
-    #:call-seq:
-    #  original_new(table,elements,mapping) -> BinaryOperation
-    #
-    #Creates a BinaryOperation. The arguments are a table an array with elements
-    #and a mapping.
-    #*Remark*: Use this method only if you know what you're doing. No 
-    #validation or argument checking is made. Its primary porpose is to speed up
-    #monoid generation in the RLSM::Monoid.each method.
-    def initialize(table, elements, mapping)
-      @table, @elements, @mapping = table, elements, mapping
-      @order = @mapping.size
-    end
-
-    #Internal representation of the table.
-    attr_reader :table
-
-    #Array with all different elements
-    attr_reader :elements
-    
-    #The number of elements.
-    attr_reader :order
-
-    #Maps element names to numbers.
-    attr_reader :mapping
-
-    #Calculate the product of +x+ and +y+.
-    #
-    #If at least one of the given elements is unknown raises an ArgumentError.
-    def [](x, y)
-      if @mapping[x].nil?
-        raise ArgumentError, "Unknown element #{x}"
-      elsif @mapping[y].nil?
-        raise ArgumentError, "Unknown element #{y}"
-      else
-        @elements[@table[@mapping[x]*@order + @mapping[y]]]
-      end
-    end
-
-    #Checks if binary operation is associative.
-    def associative?
-      !non_associative_triple
-    end
-
-    #Checks if binary operation is commutative.
-    def commutative?
-      is_commutative
-    end
-
-    #Checks if the binary operation is associative. If not raises an BinOpError.
-    def enforce_associativity
-      nat = non_associative_triple
-
-      unless nat.nil?
-        err_str = "(#{nat[0]}#{nat[0]})#{nat[0]} != #{nat[0]}(#{nat[1]}#{nat[2]})"
-        raise BinOpError, "Associativity required, but #{err_str}."
-      end
-    end
-    
-    private
-    def self.validate(binop)
-      if binop.table.size == 0
-        raise ArgumentError, "No elements given."
-      end
-
-      if binop.table.size != binop.mapping.size**2
-        raise ParseError, "Either to many elements or wrong table format."
-      end
-    end
-
-    def self.parse(description)
-      mapping = {}
-      elements = []
-      table = []
-      if description =~ /\s*:\s*/
-        elements = desc2ary(Regexp.last_match.pre_match)
-        elements.each_with_index { |el,i| mapping[el] = i }
-
-        desc2ary(Regexp.last_match.post_match).
-          each { |el| table << mapping[el] }
-      else
-        desc2ary(description).each do |element|
-          if mapping[element].nil?
-            mapping[element] = elements.size
-            elements << element
-          end
-
-          table << mapping[element]
-        end
-      end
-      
-      [table, elements, mapping]
-    end
-
-    def self.desc2ary(str)
-      if str.include?(',')
-        str.gsub(/^\s+/,'').gsub(/,*\s+,*/,',').split(',')
-      else
-        str.gsub(/\s+/,'').scan(/./)
-      end
-    end
-  end
-end

data/test/test_binop.rb

@@ -1,119 +0,0 @@
-require 'rubygems'
-require 'shoulda'
-
-$:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
-
-require 'rlsm/binary_operation'
-
-class BinaryOperationTest < Test::Unit::TestCase
-  context "BinaryOperation::new" do
-    should "Require argument" do
-      assert_raises ArgumentError do
-        RLSM::BinaryOperation.new
-      end
-    end
-
-    should "Parse a valid description with elements" do
-      binop = RLSM::BinaryOperation.new "012:000 000 000"
-
-      assert_equal Hash['0', 0, '1', 1, '2', 2], binop.mapping
-      assert_equal %w(0 1 2), binop.elements
-      assert_equal 3, binop.order
-      assert_equal [0]*9, binop.table
-    end
-
-    should "Ignore whitspaces between element seperators" do
-      binop = RLSM::BinaryOperation.new "0,   1,2:0,0,0 0,0,  0     0, 0,0"
-
-      assert_equal Hash['0', 0, '1', 1, '2', 2], binop.mapping
-      assert_equal %w(0 1 2), binop.elements
-      assert_equal 3, binop.order
-      assert_equal [0]*9, binop.table
-    end
-
-    should "Raise ParseError if some commas are missing" do
-      assert_raises ParseError do
-        RLSM::BinaryOperation.new "012:0,1,2 210 2,2,2"
-      end
-    end
-
-    should "Parse commas in the elements part, no commas in table part" do
-      binop = RLSM::BinaryOperation.new "0,1,2:000 000 000"
-
-      assert_equal Hash['0', 0, '1', 1, '2', 2], binop.mapping
-      assert_equal %w(0 1 2), binop.elements
-      assert_equal 3, binop.order
-      assert_equal [0]*9, binop.table
-    end
-
-    should "Parse commas in the table part, no commas in elements part" do
-      binop = RLSM::BinaryOperation.new "012:0,0,0 0,0,0 0,0,0"
-
-      assert_equal Hash['0', 0, '1', 1, '2', 2], binop.mapping
-      assert_equal %w(0 1 2), binop.elements
-      assert_equal 3, binop.order
-      assert_equal [0]*9, binop.table
-    end
-
-    should "Raise ParseError if too many elements are given." do
-      assert_raises ParseError do
-        RLSM::BinaryOperation.new "012:0,1,3 210 2,2,2"
-      end
-    end
-
-    should "Raise ParseError if too few elements are given." do
-      assert_raises ParseError do
-        RLSM::BinaryOperation.new "000 000 000"
-      end
-    end
-
-    should "Raise ParseError if table format is wrong." do
-      assert_raises ParseError do
-        RLSM::BinaryOperation.new "012:0,1,2 2,1 2,2,2"
-      end
-    end
-
-    should "Parse a monoid with neutral element in first row." do
-      binop = RLSM::BinaryOperation.new "0123 1230 2301 3012"
-
-      assert_equal Hash['0', 0, '1', 1, '2', 2, '3', 3], binop.mapping
-      assert_equal %w(0 1 2 3), binop.elements
-      assert_equal 4, binop.order
-      assert_equal [0,1,2,3,1,2,3,0,2,3,0,1,3,0,1,2], binop.table
-    end
-  end
-
-  context "BinaryOperation#associative?" do
-    should "Return true if binary operation is associative." do
-      assert_equal true, RLSM::BinaryOperation.new("01:00 00").associative?
-    end
-
-    should "Return false if binary operation is not associative." do
-      assert_equal false, RLSM::BinaryOperation.new("01 00").associative?
-    end
-  end
-
-  context "BinaryOperation#commutative?" do
-    should "Return true if binary operation is commutative." do
-      assert_equal true, RLSM::BinaryOperation.new("012 111 211").commutative?
-    end
-
-    should "Return false if binary operation is not commutative." do
-      assert_equal false, RLSM::BinaryOperation.new("012 111 222").commutative?
-    end
-  end
-
-  context "BinaryOperation#enforce_associativity" do
-    should "Raise BinOpError for nonassociative binary operation." do
-      assert_raises BinOpError do
-        RLSM::BinaryOperation.new("01 00").enforce_associativity
-      end
-    end
-
-    should "Do nothing for assovityive binary operation." do
-      assert_nothing_raised do
-        RLSM::BinaryOperation.new("01 10").enforce_associativity
-      end
-    end
-  end
-end