rlsm 1.1.0 → 1.8.1

data/ext/array/array_c_ext.c

@@ -1,5 +1,13 @@
 #include <ruby.h>
 
+#ifndef RARRAY_PTR
+#define RARRAY_PTR(ary) RARRAY(ary)->ptr
+#endif
+
+#ifndef RARRAY_LEN
+#define RARRAY_LEN(ary) RARRAY(ary)->len
+#endif
+
 static int 
 c_subset_next(int* sub, int n, int k) {
   int i = k - 1;
@@ -49,16 +57,16 @@ ary2ruby(int* subset, int k, VALUE ary) {
   int i;
   
   for (i=0; i < k; ++i) {
-    rb_ary_store(result, i, RARRAY(ary)->ptr[subset[i]]);
+    rb_ary_store(result, i, RARRAY_PTR(ary)[subset[i]]);
   }
 
   return result; 
 }
 
 static VALUE 
-powerset(VALUE self) {
+powerset(VALUE self, VALUE ary) {
   int k;
-  int n = RARRAY(self)->len;
+  int n = RARRAY_LEN(ary);
   if (!rb_block_given_p()) {
     VALUE result = rb_ary_new();
     for (k=0; k <= n; ++k) {
@@ -67,7 +75,7 @@ powerset(VALUE self) {
       for (i=0; i < k; ++i)  { subset[i] = i; }
       
       while(1) {
-	rb_ary_push(result, ary2ruby(subset,k,self));
+	rb_ary_push(result, ary2ruby(subset,k,ary));
 	res = c_subset_next(subset, n, k);
 	if (res == -1)
 	  break;
@@ -82,7 +90,7 @@ powerset(VALUE self) {
       for (i=0; i < k; ++i)  { subset[i] = i; }
       
       while(1) {
-	rb_yield(ary2ruby(subset,k,self));
+	rb_yield(ary2ruby(subset,k,ary));
 	res = c_subset_next(subset, n, k);
 	if (res == -1)
 	  break;
@@ -94,16 +102,16 @@ powerset(VALUE self) {
 }
 
 static VALUE
-permutations(VALUE self) {
+permutations(VALUE self, VALUE ary) {
   int res;
-  int n = RARRAY(self)->len;
+  int n = RARRAY_LEN(ary);
   int* perm = (int*) ALLOCA_N(int, n);
   int t;
   for (t=0; t < n; ++t)  { perm[t] = t; }
 
   if (rb_block_given_p()) {
     while(1) {
-      rb_yield(ary2ruby(perm, n, self));
+      rb_yield(ary2ruby(perm, n, ary));
       res = c_next_perm(perm, n);
       if (res == -1)
 	break;
@@ -112,7 +120,7 @@ permutations(VALUE self) {
   else {
     VALUE result = rb_ary_new();
     while(1) {
-      rb_ary_push(result,ary2ruby(perm, n, self));
+      rb_ary_push(result,ary2ruby(perm, n, ary));
       res = c_next_perm(perm, n);
       if (res == -1)
 	break;
@@ -128,9 +136,10 @@ permutations(VALUE self) {
 extern "C" {
 #endif
   void Init_array_cext() {
-    VALUE ary = rb_const_get(rb_cObject, rb_intern("Array")); 
-    rb_define_method(ary, "powerset", (VALUE(*)(ANYARGS))powerset, 0);
-    rb_define_method(ary, "permutations", (VALUE(*)(ANYARGS))permutations, 0);
+    VALUE rlsm = rb_define_module("RLSM");
+    VALUE ary_ext = rb_define_module_under(rlsm, "ArrayExt");
+    rb_define_singleton_method(ary_ext, "powerset", (VALUE(*)(ANYARGS))powerset, 1);
+    rb_define_singleton_method(ary_ext, "permutations", (VALUE(*)(ANYARGS))permutations, 1);
   }
 #ifdef __cplusplus
 }

data/ext/monoid/monoid_c_ext.c

@@ -1,12 +1,20 @@
 #include <ruby.h>
 
+#ifndef RARRAY_PTR
+#define RARRAY_PTR(ary) RARRAY(ary)->ptr
+#endif
+
+#ifndef RARRAY_LEN
+#define RARRAY_LEN(ary) RARRAY(ary)->len
+#endif
+
 typedef int bool;
 
 static int 
 mi_index(VALUE ary, int index) {
   int i;
-  for (i=0; i < RARRAY(ary)->len; ++i) {
-    if (NUM2INT(RARRAY(ary)->ptr[i]) == index) { return i; }
+  for (i=0; i < RARRAY_LEN(ary); ++i) {
+    if (NUM2INT(RARRAY_PTR(ary)[i]) == index) { return i; }
   }
 
   return -1;
@@ -40,7 +48,7 @@ mi_helper_init_table(VALUE diagonal, int order) {
     else if (i % order == 0)
       result[i] = i / order;
     else if (i % order == i / order)
-      result[i] = NUM2INT(RARRAY(diagonal)->ptr[i / order]);
+      result[i] = NUM2INT(RARRAY_PTR(diagonal)[i / order]);
     else
       result[i] = 0;
   }
@@ -51,9 +59,9 @@ mi_helper_init_table(VALUE diagonal, int order) {
 static bool 
 mi_is_perm_stable(VALUE diagonal, VALUE perm) {
   int i;
-  for (i=0; i < RARRAY(diagonal)->len; ++i) {
-    int a = NUM2INT(RARRAY(diagonal)->ptr[i]);
-    int b = NUM2INT(RARRAY(perm)->ptr[NUM2INT(RARRAY(diagonal)->ptr[mi_index(perm, i)])]);
+  for (i=0; i < RARRAY_LEN(diagonal); ++i) {
+    int a = NUM2INT(RARRAY_PTR(diagonal)[i]);
+    int b = NUM2INT(RARRAY_PTR(perm)[NUM2INT(RARRAY_PTR(diagonal)[mi_index(perm, i)])]);
 
     if ( a != b)
       return 0;
@@ -62,25 +70,13 @@ mi_is_perm_stable(VALUE diagonal, VALUE perm) {
   return 1;
 }
 
-static bool 
-mi_is_invertable(VALUE diag, int index) {
-  int i, pot = NUM2INT(RARRAY(diag)->ptr[index]);
-
-  for (i=0; i < RARRAY(diag)->len; ++i) {
-    if (pot == 0) { return 1; }
-    pot = NUM2INT(RARRAY(diag)->ptr[pot]);
-  }
-
-  return 0;
-}
-
 static VALUE 
 mi_helper_select_perms(VALUE diagonal, VALUE perms, int order) {
   VALUE result = rb_ary_new();
   VALUE perm;
   int i;
-  for (i=0; i < RARRAY(perms)->len; ++i) {
-    perm = RARRAY(perms)->ptr[i];
+  for (i=0; i < RARRAY_LEN(perms); ++i) {
+    perm = RARRAY_PTR(perms)[i];
     if (mi_is_perm_stable(diagonal, perm))
       rb_ary_push(result, perm);
   }
@@ -88,36 +84,19 @@ mi_helper_select_perms(VALUE diagonal, VALUE perms, int order) {
   return result;
 }
 
-static int* 
-mi_helper_rc_restrictions(VALUE diagonal, int order) {
-  int* result = (int*) calloc(order, sizeof(int));
-  result[0] = 1;
-
-  int i;
-  for (i=1; i < order; ++i) {
-    result[i] = 1;
-    if (NUM2INT(RARRAY(diagonal)->ptr[i]) == i)
-      result[i] *= 2; /* idempotent */
-    if (mi_is_invertable(diagonal, i))
-      result[i] *= 3; /* invertible */
-  }
-
-  return result;
-}
-
 static bool 
 mi_is_diagonal_valid(int* diagonal, int ord, VALUE perms) {
   int i,j;
   VALUE perm;
-  for (i=0; i < RARRAY(perms)->len; ++i) {
-    perm = RARRAY(perms)->ptr[i];
+  for (i=0; i < RARRAY_LEN(perms); ++i) {
+    perm = RARRAY_PTR(perms)[i];
 
     for (j=0; j < ord; ++j) {
       int ii, pdii;
       ii = mi_index(perm, j);
       if (diagonal[ii] == -1) { break; }
 
-      pdii = NUM2INT(RARRAY(perm)->ptr[diagonal[ii]]);
+      pdii = NUM2INT(RARRAY_PTR(perm)[diagonal[ii]]);
       if (diagonal[j] < pdii) { break; }
       if (diagonal[j] > pdii) { return 0; }
     }
@@ -162,9 +141,9 @@ mi_is_iso_antiiso(const int* table, int order, VALUE perms) {
   int max_index = order*order;
   VALUE perm;
 
-  for (p = 0; p < RARRAY(perms)->len; ++p) {
+  for (p = 0; p < RARRAY_LEN(perms); ++p) {
     int smaller_iso = 0, smaller_aiso = 0;
-    perm = RARRAY(perms)->ptr[p];
+    perm = RARRAY_PTR(perms)[p];
     for (i = order+1; i < max_index; ++i) {
       int ix1, ix2, ti, tii, taii, ptii, ptaii;
       ix1 = mi_index(perm, i / order);
@@ -177,8 +156,8 @@ mi_is_iso_antiiso(const int* table, int order, VALUE perms) {
       if (ti == -1 || tii == -1 || taii == -1 )
         break;
 
-      ptii  = NUM2INT(RARRAY(perm)->ptr[tii]);
-      ptaii = NUM2INT(RARRAY(perm)->ptr[taii]);
+      ptii  = NUM2INT(RARRAY_PTR(perm)[tii]);
+      ptaii = NUM2INT(RARRAY_PTR(perm)[taii]);
       
       if (ti < ptii)
         smaller_iso = 1;
@@ -197,40 +176,9 @@ mi_is_iso_antiiso(const int* table, int order, VALUE perms) {
   return 1;
 }
 
-static bool 
-mi_is_rc_rest_satisfied(const int* table, int order, const int* rc_rest) {
-  int i,j,k;
-  for (i=1; i < order; ++i) {
-    if (rc_rest[i] != 1) {
-      if (rc_rest[i] % 2 == 0) {
-        for (j=1; j < order; ++j) {
-          if (table[order*i + j] == 0 || table[order*j + i] == 0)
-            return 0;
-        }
-      }
-
-      if (rc_rest[i] % 3 == 0) {
-        for (j=0; j < order; ++j) {
-          for (k=j+1; k < order; ++k) {
-            if (table[order*i + j] != -1 && table[order*i + j] == table[order*i + k] )
-              return 0;
-            if (table[order*j + i] != -1 &&  table[order*j + i] == table[order*k + i])
-              return 0;
-
-          }
-        }
-      }
-    }
-  }
-
-  return 1;
-}
 
 static bool 
-mi_table_valid(const int* table, int order, const int* rc_rest, VALUE perms) {
-  if (!mi_is_rc_rest_satisfied(table, order, rc_rest))
-    return 0;
-  
+mi_table_valid(const int* table, int order, VALUE perms) {
   if (!mi_is_associative(table, order))
     return 0;
 
@@ -253,7 +201,7 @@ each_diagonal(VALUE self, VALUE rorder, VALUE perms) {
   while(1) {
     diagonal[index]++;
     if (diagonal[index] >= order) {
-      if (index == 1) { return; }  /* finished */
+      if (index == 1) { return Qnil; }  /* finished */
       diagonal[index] = -1;
       index--;
     }
@@ -270,25 +218,24 @@ each_diagonal(VALUE self, VALUE rorder, VALUE perms) {
 
 static VALUE 
 e_w_diagonal(VALUE self, VALUE diagonal, VALUE perms) {
-  int order = RARRAY(diagonal)->len, t_order = order*order;
+  int order = RARRAY_LEN(diagonal), t_order = order*order;
   int* table = mi_helper_init_table(diagonal, order);
   VALUE rperms = mi_helper_select_perms(diagonal, perms, order);
-  int* rc_rest = mi_helper_rc_restrictions(diagonal, order);
 
-  if (mi_table_valid(table, order, rc_rest, rperms)) { rb_yield(mi_ary2rb(table, t_order)); }
+  if (mi_table_valid(table, order, rperms)) { rb_yield(mi_ary2rb(table, t_order)); }
 
   int index = t_order - 2;
   while (1) {
     table[index]++;
     if (table[index] >= order) {
-      if (index <= order + 2) { return; }  /* finished */
+      if (index <= order + 2) { return Qnil; }  /* finished */
       table[index] = -1;
       index--;
       /* skip diagonal and first column */
       if ((index % order == index / order) || (index % order == 0))
         index--;
     }
-    else if (mi_table_valid(table, order, rc_rest, rperms)) {
+    else if (mi_table_valid(table, order, rperms)) {
       if (index == t_order - 2)
         rb_yield(mi_ary2rb(table, t_order));
       else {
@@ -307,14 +254,56 @@ static VALUE
 e_pos(VALUE self, VALUE table, VALUE rorder) {
   int i, order = NUM2INT(rorder);
   for(i=0; i < order; ++i) {
-    if (NUM2INT(RARRAY(table)->ptr[i]) != i || NUM2INT(RARRAY(table)->ptr[order*i]) != i) {
-      rb_raise(rb_const_get(rb_cObject, rb_intern("MonoidError")), "Neutral element isn't in first row.");
+    if (NUM2INT(RARRAY_PTR(table)[i]) != i || NUM2INT(RARRAY_PTR(table)[order*i]) != i) {
+      rb_raise(rb_const_get(rb_define_module("RLSM"), rb_intern("Error")), "Neutral element isn't in first row.");
     }
   }
 
   return Qnil;
 }
 
+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_PTR(table)[max*i + j]);
+        jk = NUM2INT(RARRAY_PTR(table)[max*j + k]);
+        i_jk = NUM2INT(RARRAY_PTR(table)[max*i + jk]);
+        ij_k = NUM2INT(RARRAY_PTR(table)[max*ij + k]);
+        if (ij_k != i_jk) {
+          return (rb_ary_new3(3,RARRAY_PTR(base)[i],RARRAY_PTR(base)[j],RARRAY_PTR(base)[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_PTR(table)[max*i + j]) != NUM2INT(RARRAY_PTR(table)[max*j + i]))
+	return (Qfalse);
+    }
+  }
+
+  return (Qtrue);
+}
+
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -323,7 +312,9 @@ extern "C" {
     VALUE monoid = rb_define_class_under(rlsm, "Monoid", rb_cObject);
     rb_define_singleton_method(monoid, "each_diagonal", (VALUE(*)(ANYARGS))each_diagonal, 2);
     rb_define_singleton_method(monoid, "each_with_diagonal", (VALUE(*)(ANYARGS))e_w_diagonal, 2);
-    rb_define_singleton_method(monoid, "enforce_identity_position", (VALUE(*)(ANYARGS))e_pos, 2);
+    rb_define_method(monoid, "enforce_identity_position", (VALUE(*)(ANYARGS))e_pos, 2);
+    rb_define_method(monoid, "is_commutative", (VALUE(*)(ANYARGS))is_commutative, 0);
+    rb_define_method(monoid, "non_associative_triple", (VALUE(*)(ANYARGS))non_associative_triple, 0);
   }
 #ifdef __cplusplus
 }

data/lib/rlsm.rb

@@ -1,5 +1,5 @@
 module RLSM
-  VERSION = "1.1.0"
+  VERSION = "1.8.1"
 
   def self.lib_path_to(file_name)
     File.join(File.dirname(__FILE__), 'rlsm', file_name)

data/lib/rlsm/dfa.rb

@@ -6,6 +6,7 @@ RLSM::require_extension('array')
 require "strscan"
 
 module RLSM
+  # @private
   class DFA
     #Synonym for new.
     def self.[](description)
@@ -65,7 +66,7 @@ module RLSM
     #Processes given +string+ starting in state +state+.
     def [](state, string)
       unless @states.include?(state)
-        raise DFAError, "Unknown state: #{state}"
+        raise RLSM::Error, "Unknown state: #{state}"
       end
 
       present_state = state
@@ -92,7 +93,7 @@ module RLSM
 
     #Checks if given +state+ is dead, i.e. its not a final state and it hs no outgoing transitions.
     def dead?(state)
-      raise DFAError, "Unknown state: #{state}" unless @states.include?(state)
+      raise RLSM::Error, "Unknown state: #{state}" unless @states.include?(state)
       
       state != @initial_state and
         ! @final_states.include?(state) and
@@ -101,7 +102,7 @@ module RLSM
 
     #Checks if given +state+ is reachable, i.e. it exists a +string+, such that <tt>self << string == state</tt> is true.
     def reachable?(state)
-      raise DFAError, "Unknown state: #{state}" unless @states.include?(state)
+      raise RLSM::Error, "Unknown state: #{state}" unless @states.include?(state)
 
       reachable_states.include? state
     end
@@ -312,7 +313,7 @@ module RLSM
     end
 
     def bijective_maps_to(other)
-      bijective_maps = other.states.permutations.map do |perm| 
+      bijective_maps = RLSM::ArrayExt::permutations(other.states).map do |perm| 
         Hash[*@states.zip(perm).flatten]
       end
 
@@ -391,7 +392,7 @@ module RLSM
 
     def parse_initial_state(description)
       unless description.count('}') == 1
-        raise DFAError, "None or at least two initial states."
+        raise RLSM::Error, "None or at least two initial states."
       end
 
       @initial_state = description[/\}\s*\*?(\w+)/,1]
@@ -436,14 +437,14 @@ module RLSM
         elsif parser.scan(/\w+/)
           #do nothing (states already parsed)
         else
-          raise DFAError, "Parse Error, could not parse #{description}"
+          raise RLSM::Error, "Parse Error, could not parse #{description}"
         end
           
         break unless parser.scan(/ /)
       end
 
       unless parser.eos?
-        raise DFAError, "Parse Error, could not parse #{description}"
+        raise RLSM::Error, "Parse Error, could not parse #{description}"
       end
       
       @alphabet = @alphabet.sort
@@ -466,7 +467,7 @@ module RLSM
         if trans[label].nil?
           trans[label] = destination
         elsif trans[label] != destination
-          raise DFAError, "Parse Error: Transition labels must be uniq."
+          raise RLSM::Error, "Parse Error: Transition labels must be uniq."
         end
       end
     end