sudokuhandler 0.1.2

data/README.md

@@ -0,0 +1,149 @@
+# sudokuhandler
+
+Le but du projet Sudoku est de fournir des objets optimisés pour la gestion de sudokus, permettant d'essayer différents algorithmes de résolution.
+Le Sudoku "classique" (9x9) est optimisé au maximum en temps et en mémoire (41 octets).
+
+## Exemple basique
+
+### Création d'un sudoku de 9x9 en diagonale
+
+    $ irb -r sudoku
+		ruby-1.9.2-p290 :000 > s = Sudoku.new 3
+		 => #<Sudoku::S3 9x9 0,0, ... , 0, 0> 
+  	ruby-1.9.2-p290 :001 > s = Sudoku[3].new
+  	 => #<Sudoku::S3 9x9 0,0, ... , 0, 0> 
+  	ruby-1.9.2-p290 :002 > s.each{|x,y,v| s.set x, x, x+1 if x == y}
+  	 => #<Sudoku::S3 9x9 1,0, ... , 0, 9> 
+  	ruby-1.9.2-p290 :003 > puts s
+	
+    1 . .  . . .  . . . 
+  	. 2 .  . . .  . . . 
+  	. . 3  . . .  . . . 
+  
+  	. . .  4 . .  . . . 
+  	. . .  . 5 .  . . . 
+  	. . .  . . 6  . . . 
+  
+  	. . .  . . .  7 . . 
+  	. . .  . . .  . 8 . 
+  	. . .  . . .  . . 9 
+  	 => nil 
+
+###Exportation du sudoku
+
+    ruby-1.9.2-p290 :004 > s.to_sutxt
+     => "3: 1 0 0 0 0 0 0 0 0 0 2 0 0 0 0 0 0 0 0 0 3 0 0 0 0 0 0 0 0 0 4 0 0 0 0 0 0 0 0 0 5 0 0 0 0 0 0 0 0 0 6 0 0 0 0 0 0 0 0 0 7 0 0 0 0 0 0 0 0 0 8 0 0 0 0 0 0 0 0 0 9;" 
+    ruby-1.9.2-p290 :005 > s2 = Sudoku.parse s.to_sutxt
+     => #<Sudoku::S3 9x9 1,0, ... , 0, 9> 
+
+### Un peu de logique
+
+    ruby-1.9.2-p290 :006 > s.possibilities 0, 1
+     => [4, 5, 6, 7, 8, 9] 
+    ruby-1.9.2-p290 :007 > s.valid? 1, 0, 3
+     => false 
+    ruby-1.9.2-p290 :008 > s.valid? 1, 0, 5
+     => true 
+		ruby-1.9.2-p290 :009 > s.col 2
+		 => [3] 
+		ruby-1.9.2-p290 :010 > s.row 3
+		 => [4] 
+		ruby-1.9.2-p290 :011 > s.square 3,3
+		 => [4, 5, 6]
+
+### Generateur
+		
+		class MySudoku < Sudoku::S4_15
+			include Sudoku::Generator
+		end
+		
+		s = MySudoku.new 5
+		s.make_valid
+		puts s
+		
+		=begin     =>>
+		1  2  3  4  5   6  7  8  9  10  11 12 13 14 15  16 17 18 19 20  21 22 23 24 25 
+		6  7  8  9  10  11 12 13 14 15  16 17 18 19 20  21 22 23 24 25  1  2  3  4  5  
+		11 12 13 14 15  16 17 18 19 20  21 22 23 24 25  1  2  3  4  5   6  7  8  9  10 
+		16 17 18 19 20  21 22 23 24 25  1  2  3  4  5   6  7  8  9  10  11 12 13 14 15 
+		21 22 23 24 25  1  2  3  4  5   6  7  8  9  10  11 12 13 14 15  16 17 18 19 20 
+
+		2  3  4  5  6   7  8  9  10 11  12 13 14 15 16  17 18 19 20 21  22 23 24 25 1  
+		7  8  9  10 11  12 13 14 15 16  17 18 19 20 21  22 23 24 25 1   2  3  4  5  6  
+		12 13 14 15 16  17 18 19 20 21  22 23 24 25 1   2  3  4  5  6   7  8  9  10 11 
+		17 18 19 20 21  22 23 24 25 1   2  3  4  5  6   7  8  9  10 11  12 13 14 15 16 
+		22 23 24 25 1   2  3  4  5  6   7  8  9  10 11  12 13 14 15 16  17 18 19 20 21 
+
+		3  4  5  6  7   8  9  10 11 12  13 14 15 16 17  18 19 20 21 22  23 24 25 1  2  
+		8  9  10 11 12  13 14 15 16 17  18 19 20 21 22  23 24 25 1  2   3  4  5  6  7  
+		13 14 15 16 17  18 19 20 21 22  23 24 25 1  2   3  4  5  6  7   8  9  10 11 12 
+		18 19 20 21 22  23 24 25 1  2   3  4  5  6  7   8  9  10 11 12  13 14 15 16 17 
+		23 24 25 1  2   3  4  5  6  7   8  9  10 11 12  13 14 15 16 17  18 19 20 21 22 
+
+		4  5  6  7  8   9  10 11 12 13  14 15 16 17 18  19 20 21 22 23  24 25 1  2  3  
+		9  10 11 12 13  14 15 16 17 18  19 20 21 22 23  24 25 1  2  3   4  5  6  7  8  
+		14 15 16 17 18  19 20 21 22 23  24 25 1  2  3   4  5  6  7  8   9  10 11 12 13 
+		19 20 21 22 23  24 25 1  2  3   4  5  6  7  8   9  10 11 12 13  14 15 16 17 18 
+		24 25 1  2  3   4  5  6  7  8   9  10 11 12 13  14 15 16 17 18  19 20 21 22 23 
+
+		5  6  7  8  9   10 11 12 13 14  15 16 17 18 19  20 21 22 23 24  25 1  2  3  4  
+		10 11 12 13 14  15 16 17 18 19  20 21 22 23 24  25 1  2  3  4   5  6  7  8  9  
+		15 16 17 18 19  20 21 22 23 24  25 1  2  3  4   5  6  7  8  9   10 11 12 13 14 
+		20 21 22 23 24  25 1  2  3  4   5  6  7  8  9   10 11 12 13 14  15 16 17 18 19 
+		25 1  2  3  4   5  6  7  8  9   10 11 12 13 14  15 16 17 18 19  20 21 22 23 24
+		=end
+		
+		s.valid? 		   # => true
+		s.complete? 	 # => true
+		s.completable? # => true
+		
+### Utiliser son propre adapteur
+
+#### Un adapteur doit au moins définir les méthodes suivantes:
+
+* get(x, y)
+* set(x, y, val)
+* each(){|x, y, val| ... }
+* size()
+* initialize(base)
+* initialize_copy(parent) (automatique si on n'utilise que des objets ruby)
+
+#### Exemple:
+
+NB: cet exemple ne tient pas compte de la gestion des erreurs
+		
+		class MonSuperAdapteur
+			attr_reader :size
+			
+			include Sudoku::Generator #methodes de generation automatique
+			include Sudoku::Grid      #methodes communes a tous les sudokus
+			
+			def initialize base
+				@size = base*base
+				@data = Array.new(@size*@size){0}
+			end
+			
+			def get x, y
+				@data[x+y*size]
+			end
+			
+			def set x, y, val
+				@data[x+y*size] = val
+			end
+			
+			def each
+				@data.each_with_index do |val, i|
+					yield i%size, i/size, val
+				end
+				self
+			end
+		end
+		
+		Sudoku[4..7] = MonSuperAdapteur #Tous les sudokus de base 4 à 7 créés automatiquement
+																		#seront des MonSuperAdapteur
+		Sudoku.new(3).class	# => Sudoku::S3
+		Sudoku.new(4).class	# => MonSuperAdapteur					
+		
+		Sudoku[0]    = MonSuperAdapteur #Tous les sudokus, par defaut
+		
+		Sudoku.new(3).class # => MonSuperAdapteur

data/Rakefile

@@ -0,0 +1,57 @@
+require 'rubygems'
+require 'rake/gempackagetask'
+require 'rake/extensiontask'
+require 'rake/testtask.rb'
+require './lib/sudoku/version'
+
+spec = Gem::Specification.new do |s|
+  s.name        = 'sudokuhandler'
+  s.version     = Sudoku::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.summary     = "Ruby Sudoku handler"
+  s.description = "Highly optimised Sudoku objects and mixins for Ruby"
+  s.author      = "Titouan Christophe"
+  s.email       = 'titouanchristophe@gmail.com'
+  s.files       = FileList["lib/*.rb", "lib/sudoku/*.rb", "ext/sudoku.c", "Rakefile", "README.md"]
+  s.homepage    = 'http://github.com/titouanc/rb-sudoku'
+  s.extensions << 'ext/extconf.rb'
+  s.license     = 'Creative Commons BY-NC-SA 3.0'
+  s.test_files  = FileList["tests/*"]
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.need_tar = true
+end
+
+Rake::ExtensionTask.new(:sudokucore, spec) do |ext|
+  ext.ext_dir = 'ext/'
+  ext.lib_dir = 'lib/'
+end
+
+Rake::TestTask.new do |t|
+  t.libs |= ["tests", "lib"]
+  t.test_files = FileList['tests/test*.rb']
+  t.verbose = true
+end
+
+desc "Build gem & install"
+task :install => FileList["pkg/#{spec.full_name}.gem"] do |t|
+  sh "gem install #{t.prerequisites.first}"
+end
+
+desc "Uninstall sudoku gem"
+task :uninstall do |t|
+  sh "gem uninstall #{spec.name}"
+end
+
+desc "Push gem to rubygems.org"
+task :push => FileList["pkg/#{spec.full_name}.gem"] do |t|
+  sh "gem push #{t.prerequisites.first}"
+end
+
+desc "Compile et ouvre uen console"
+task :console => :compile do |t|
+  sh "irb -I ./lib -r sudoku"
+end
+
+task :default => [:clobber, :repackage, :compile, :test]

data/ext/extconf.rb

@@ -0,0 +1,2 @@
+require "mkmf"
+create_makefile "sudokucore"

data/ext/sudoku.c

@@ -0,0 +1,296 @@
+#include <ruby.h>
+#include <stdlib.h>
+
+VALUE module_Sudoku;
+VALUE class_S4_15;
+VALUE class_S3;
+
+/* ############################################ */
+
+typedef struct {
+  unsigned char size;
+  unsigned char init;
+  unsigned char *ptr;
+} S4_15;
+
+static int S4_15_alloc_data(S4_15 *this){
+  int len;
+  
+  if (! this->init){
+    len = this->size*this->size;
+    this->ptr = malloc(len*sizeof(char));
+    if (! this->ptr){
+      rb_raise(rb_eNoMemError, "Cannot allocate Sudoku data (%d bytes)", len);
+      return 0;
+    }
+    this->init = 1;
+  }
+  
+  return 1;
+}
+
+static void S4_15_dealloc(S4_15 *obj){
+  if (obj->init)
+    free(obj->ptr);
+  free(obj);
+}
+
+static VALUE S4_15_alloc(VALUE klass){
+  S4_15 *ptr = malloc(sizeof(S4_15));
+  if (! ptr)
+    rb_raise(rb_eNoMemError, "Cannot allocate Sudoku 4_15 struct (%lu bytes)", sizeof(S4_15));
+  ptr->size = 0;
+  ptr->init = 0;
+  return Data_Wrap_Struct(klass, 0, S4_15_dealloc, ptr);
+}
+
+static VALUE S4_15_init(VALUE self, VALUE init_base){
+  S4_15          *this;
+  unsigned int *cursor;
+  register int       i;
+  int         top, len;
+  unsigned char base = NUM2UINT(init_base) & 0xff;
+  
+  Data_Get_Struct(self, S4_15, this);
+  this->size = base*base;
+  if (base > 15 || base < 2)
+    rb_raise(rb_eArgError, "S4_15 can only handle bases between 2 and 15 (%u not allowed)", base);
+  
+  S4_15_alloc_data(this);
+  
+  len = this->size*this->size;
+  cursor = (unsigned int *) this->ptr;
+  top    = len/(sizeof(int)/sizeof(char));
+  for (i=0; i<top; i++)
+    cursor[i] = 0;
+    
+  for (i=top*(sizeof(int)/sizeof(char)); i<len; i++)
+    this->ptr[i] = 0;
+      
+  return self;
+}
+
+static VALUE S4_15_initCopy(VALUE copy, VALUE orig){
+  S4_15 *this, *parent;
+  int len;
+  
+  Data_Get_Struct(copy, S4_15, this);
+  Data_Get_Struct(orig, S4_15, parent);
+  
+  this->size = parent->size;
+  
+  S4_15_alloc_data(this);
+  memcpy(this->ptr, parent->ptr, parent->size*sizeof(char));
+  
+  return copy;
+}
+
+static VALUE S4_15_get(VALUE self, VALUE col, VALUE row){
+  S4_15 *this;
+  int x = NUM2INT(col);
+  int y = NUM2INT(row);
+  
+  Data_Get_Struct(self, S4_15, this);
+  if (x<0 || x>=this->size || y<0 || y>=this->size)
+    rb_raise(rb_eArgError, "Are you sure thre's a %d,%d cell in a %dx%d Sudoku ?", x, y, this->size, this->size);
+    
+  return INT2NUM(this->ptr[x+y*this->size]);
+}
+
+static VALUE S4_15_set(VALUE self, VALUE col, VALUE row, VALUE value){
+  S4_15 *this;
+  int x = NUM2INT(col);
+  int y = NUM2INT(row);
+  int v = NUM2INT(value);
+  
+  Data_Get_Struct(self, S4_15, this);
+  if (x<0 || x>=this->size || y<0 || y>=this->size || v<0 || v>this->size)
+    rb_raise(rb_eArgError, "%d,%d => %d not allowed in a %dx%d Sudoku", x, y, v, this->size, this->size);
+    
+  this->ptr[x+y*this->size] = v;
+    
+  return INT2NUM(v);
+}
+
+static VALUE S4_15_each(VALUE self){
+  register int i;
+  int len;
+  S4_15 *this;
+  VALUE args;
+  
+  Data_Get_Struct(self, S4_15, this);
+  len = this->size*this->size;
+  for (i=0; i<len; i++){
+    args = rb_ary_new3(3, INT2FIX(i%this->size), INT2FIX(i/this->size), INT2FIX(this->ptr[i]));
+    rb_yield(args);
+  }
+  
+  return self;
+}
+
+static VALUE S4_15_size_internal(VALUE self){
+  S4_15 *this;
+  Data_Get_Struct(self, S4_15, this);
+  return INT2FIX(this->size);
+}
+
+static void Init_S4_15(VALUE module){
+    class_S4_15 = rb_define_class_under(module, "S4_15", rb_cObject);
+    rb_define_alloc_func(class_S4_15, S4_15_alloc);
+    
+    rb_define_const(class_S4_15, "SIZE", INT2FIX(9));
+    
+    rb_define_method(class_S4_15, "initialize",      S4_15_init, 1);
+    rb_define_method(class_S4_15, "initialize_copy", S4_15_initCopy, 1);
+    rb_define_method(class_S4_15, "get",             S4_15_get, 2);
+    rb_define_method(class_S4_15, "set",             S4_15_set, 3);
+    rb_define_method(class_S4_15, "each",            S4_15_each, 0);
+    rb_define_method(class_S4_15, "size_internal",   S4_15_size_internal, 0);
+}
+
+/* ############################################ */
+
+static void S3_dealloc(void *ptr){
+  free(ptr);
+}
+
+static VALUE S3_alloc(VALUE klass){
+  char *ptr = malloc(41*sizeof(char));
+  if (! ptr)
+    rb_raise(rb_eNoMemError, "Cannot allocate Sudoku data (%d bytes)", 41);
+  return Data_Wrap_Struct(klass, 0, S3_dealloc, ptr);
+}
+
+static VALUE S3_init(VALUE self, VALUE dummy){
+  unsigned int  *this;
+  unsigned char *last;
+  register char i;
+  
+  Data_Get_Struct(self, unsigned int, this);
+  for (i=0; i<10; i++)
+    this[i] = 0;
+  last = (char *) &(this[10]);
+  *last =0xf; /* 0x0f => 4 derniers bits pas dans le sudoku */
+    
+  return self;
+}
+
+static VALUE S3_initCopy(VALUE copy, VALUE orig){
+  unsigned char *this, *parent;
+  char i;
+  
+  Data_Get_Struct(copy, unsigned char, this);
+  Data_Get_Struct(orig, unsigned char, parent);
+  if (this == parent)
+    return copy;
+  
+  memcpy(this, parent, 41*sizeof(char));
+    
+  return copy;
+}
+
+static VALUE S3_get(VALUE self, VALUE col, VALUE row){
+  unsigned char *this, x, y, i;
+  
+  Data_Get_Struct(self, unsigned char, this);
+  x = NUM2UINT(col)&0xff;
+  y = NUM2UINT(row)&0xff;
+  
+  if (x>=9 || y>=9)
+    rb_raise(rb_eArgError, "Are you sure thre's a %d,%d cell in a 9x9 Sudoku ?", x, y);
+  
+  i = x + y*9;  
+  if (i%2 == 0)
+    return INT2FIX((this[i/2] >> 4) & 0x0f);
+  else
+    return INT2FIX(this[i/2] & 0x0f);
+}
+
+static VALUE S3_set(VALUE self, VALUE col, VALUE row, VALUE value){
+  unsigned char *this, x, y, i, val;
+  
+  Data_Get_Struct(self, unsigned char, this);
+  x   = NUM2UINT(col)&0x0f;
+  y   = NUM2UINT(row)&0x0f;
+  val = NUM2UINT(value)&0x0f;
+  
+  
+  if (x>=9 || y>=9 || val > 9)
+    rb_raise(rb_eArgError, "%d,%d => %d not allowed in a 9x9 Sudoku", x, y, val);
+    
+  i = x + y*9;
+  if (i%2 == 0)
+    this[i/2] = (this[i/2]&0x0f) | (val<<4);
+  else
+    this[i/2] = (this[i/2]&0xf0) | val;
+    
+  return INT2FIX(val);
+}
+
+static VALUE S3_each(VALUE self){
+  char x=0, y=0, i, val;
+  unsigned char *this;
+  VALUE args;
+  
+  Data_Get_Struct(self, unsigned char, this);
+  for (i=0; i<81; i++){
+    val = (i%2 == 0) ? ((this[i/2] >> 4) & 0x0f) : (this[i/2] & 0x0f);
+    args = rb_ary_new3(3, INT2FIX(x), INT2FIX(y), INT2FIX(val));
+    rb_yield(args);
+    if (x<8)
+      x++;
+    else {
+      y++;
+      x = 0;
+    }
+  }
+  
+  return self;
+}
+
+static VALUE S3_isComplete(VALUE self){
+  char i, val;
+  unsigned char *this;
+  
+  Data_Get_Struct(self, unsigned char, this);
+  for (i=0; i<41; i++)
+    if ((this[i]&0xf0) == 0 || (this[i]&0x0f) == 0)
+      return Qfalse;
+  
+  return Qtrue;
+}
+
+static VALUE S3_dump(VALUE self){
+  char string[83] = {'\0'};
+  int i;
+  unsigned char *data;
+  
+  Data_Get_Struct(self, unsigned char, data);
+  for (i=0; i<41; i++)
+    sprintf(&(string[2*i]), "%X", data[i]);
+
+  return rb_str_new(string, 82);
+}
+
+static void Init_S3(VALUE module){
+    class_S3 = rb_define_class_under(module, "S3", rb_cObject);
+    rb_define_alloc_func(class_S3, S3_alloc);
+    
+    rb_define_const(class_S3, "SIZE", INT2FIX(9));
+    
+    rb_define_method(class_S3, "__initialize", S3_init, 1);
+    rb_define_method(class_S3, "initialize_copy", S3_initCopy, 1);
+    rb_define_method(class_S3, "get", S3_get, 2);
+    rb_define_method(class_S3, "set", S3_set, 3);
+    rb_define_method(class_S3, "each", S3_each, 0);
+    rb_define_method(class_S3, "complete?", S3_isComplete, 0);
+    rb_define_method(class_S3, "dump", S3_dump, 0);
+}
+
+/* ############################################ */
+
+void Init_sudokucore(){
+  module_Sudoku = rb_define_module("Sudoku");
+  Init_S3(module_Sudoku);
+  Init_S4_15(module_Sudoku);
+}

data/lib/sudoku/version.rb

@@ -0,0 +1,3 @@
+module Sudoku
+  VERSION = "0.1.2"
+end

data/lib/sudoku.rb

@@ -0,0 +1,315 @@
+#
+# Sudoku handler 
+#
+
+require "sudokucore"
+require "sudoku/version"
+
+module Sudoku 
+  #Exception lancée lors d'erreurs de lecture d'une chaine Sutxt
+  class MalformedSutxtError < Exception; end
+  
+  #Permet de generer rapidement un sudoku
+  module Generator
+    #Remplit la diagonale descendante de 1 a self.size
+    def make_diagonal
+      each{|x,y,val| set x,x,x+1 if x==y}
+      self
+    end
+    
+    #Remplit tout le sudoku de maniere a ce qu'il soit valide
+    def make_valid
+      pattern = Array.new(size){|i| i+1}
+      size.times do |y|
+        size.times do |x|
+          set x, y, pattern[x]
+        end
+        base.times{|i| pattern.push pattern.shift}
+        pattern.push pattern.shift if base - (y%base) == 1
+      end
+      self
+    end
+  end
+  
+  #Taches communes a tous les Sudokus
+  module Grid
+    #Renvoie le contenu de la ligne x
+    def col x
+      res = []
+      size.times do |y|
+        val = get x, y
+        res << val if val != 0
+      end
+      res
+    end
+    
+    #Renvoie le contenu de la ligne y
+    def row y 
+      res = []
+      size.times do |x|
+        val = get x, y
+        res << val if val != 0
+      end
+      res
+    end
+    
+    #Renvoie le contenu du carré contenant la case x,y
+    def square x, y
+      xmin = x - (x%base)
+      ymin = y - (y%base)
+      res = []
+      
+      base.times do |xx|
+        base.times do |yy|
+          val = get xx+xmin, yy+ymin
+          res << val if val != 0
+        end
+      end
+      
+      res
+    end
+    
+    #Renvoie true si le sudoku ne contient aucune case vide
+    def complete?
+      each{|x,y,val| return false if val == 0}
+      true
+    end
+    
+    #Renvoie true si chaque case a au moins 1 possibilité à ce stade
+    def completable?
+      completed = 0
+      each do |x, y, val|
+        return false if possibilities(x, y).empty?
+      end
+      return true
+    end
+    
+    #Renvoie toutes les possibilités pour la case x,y
+    def possibilities x, y
+      res = Array.new(size){|i| i+1}
+      xmin = x-x%base
+      ymin = y-y%base
+      
+      size.times do |i|
+        res.delete get(x,i) if i!=y
+        res.delete get(i,y) if i!=x
+        xx, yy = xmin+i%base, ymin+i/base
+        res.delete get(xx, yy) if xx!=x && yy!=y
+      end
+      
+      res
+    end
+    
+    #Renvoie true si tous les nombres de la grille sont valides
+    def valid_grid?
+      each do |x, y, val|
+        next if val.zero?
+        return false unless valid_cell? x, y, val
+      end
+      
+      true
+    end
+    
+    #Renvoie true si val est possible en x,y
+    def valid_cell? x, y, val
+      val  = val.to_i
+      xmin = x-x%base
+      ymin = y-y%base
+      
+      size.times do |i|
+        return false if i!=y && get(x,i)==val
+        return false if i!=x && get(i,y)==val
+        xx, yy = xmin+i%base, ymin+i/base
+        return false if xx!=x && yy!=y && get(xx, yy) == val
+      end
+      
+      true
+    end
+    
+    #Si aucun argument n'est passé => valid_grid?
+    #Si 3 arguments sont passés    => valid_cell? x, y, val
+    def valid? *args
+      if args.empty?
+        valid_grid?
+      elsif args.length == 3
+        valid_cell? *args
+      else
+        raise ArgumentError, "wrong number of arguments(#{args.length} for 0 or 3)"
+      end
+    end
+    
+    #Renvoie la base du sudoku
+    def base
+      if @base
+        @base
+      else
+        @base = (size**0.5).to_i
+      end
+    end
+    
+    #Renvoie le nombre de cases dans le sudoku
+    def length
+      if @length
+        @length
+      else
+        @length = size*size
+      end
+    end
+    
+    #Représentation texte humainement lisible
+    def to_s
+      res  = ""
+      width = size.to_s.length
+      zero = ".".center width+1
+      
+      size.times do |y|
+        res += "\n" if y>0 && y%base == 0
+        size.times do |x|
+          res += " " if x>0 && x%base == 0
+          val = get x, y
+          res += val.zero? ? zero : "#{val.to_s.center width} "
+        end
+        res += "\n"
+      end
+      res
+    end
+    
+    #Représentation courte (utile dans irb)
+    def inspect
+      "#<#{self.class} #{size}x#{size} [#{get 0, 0}, #{get 0, 1}, ... , #{get size-2, size-1}, #{get size-1, size-1}]>"
+    end
+    
+    #Représentation pour l'enregistrement
+    def to_sutxt
+      res = "#{base}:"
+      size.times do |y|
+        size.times do |x|
+          res << " #{get x, y}"
+        end
+      end
+      res+';'
+    end
+  end
+  
+  #Sudoku 9x9 (base 3) très rapide
+  class S3
+    include Grid
+    private :__initialize
+    
+    #Argument ignoré, laissé pour des raisons d'uniformité
+    def initialize base=3
+      __initialize nil
+    end
+    
+    def size
+      SIZE
+    end
+  end
+  
+  #Sudokus de base 4 à 15 rapide
+  class S4_15
+    include Grid
+    private :size_internal
+    
+    def size
+      if @size
+        @size
+      else
+        @size = size_internal
+      end
+    end
+  end
+  
+  #Sudoku générique
+  class Sn
+    include Grid
+    attr_reader :size, :base, :length
+    
+    def initialize base=3
+      @base   = base.to_i
+      @size   = @base*@base
+      @length = @size*@size
+      @grid = Array.new(@size) do |i|
+        Array.new(@size){|j| 0}
+      end
+    end
+    
+    def set x, y, val
+      if x<0 || x>=size || y<0 || y>=size || val<0 || val > size
+        raise ArgumentError, "#{x},#{y} => #{val} is impossible in a #{size}x#{size} sudoku"
+      end
+      @grid[x][y] = val
+    end
+    
+    def get x, y
+      if x<0 || x>=size || y<0 || y>=size
+        raise ArgumentError, "Is there a #{x},#{y} cell in a #{size}x#{size} sudoku ?"
+      end
+      @grid[x][y]
+    end
+    
+    def each
+      @size.times do |y|
+        @size.times do |x|
+          yield x, y, @grid[x][y]
+        end
+      end
+    end
+  end
+  
+  ADAPTERS = [
+    [3, S3],
+    [4..15, S4_15],
+    [0, Sn]
+  ]
+  
+  class << self
+    #Renvoie la classe de la meilleure implémentation pour un sudoku de base n
+    def [] n
+      n = n.to_i
+      ADAPTERS.each do |ad|
+        zone    = ad[0]
+        adapter = ad[1]
+        
+        return adapter if zone == 0
+        
+        case n
+        when zone 
+          return adapter
+        end
+      end
+    end
+    
+    #Ajoute un element 
+    def []= zone, adapter
+      ADAPTERS.unshift [zone, adapter]
+    end
+    
+    #Renvoie une instance de la meilleure implémentation pour un sudoku de base n
+    def best_grid_for n=3
+      n = n.to_i
+      self[n].new n
+    end
+    alias :new :best_grid_for
+    
+    #Renvoie un nouveau Sudoku a partir de la chaine donnee
+    def parse str
+      unless str =~ /(\d+):(.+);/
+        raise MalformedSutxtError, "It doesn't seem to be a sutxt line..."
+      end
+
+      base = $1.to_i
+      data = $2.split(/\s+/).delete_if(&:empty?).map(&:to_i)
+      unless data.length == base**4
+        raise MalformedSutxtError, "Expecting #{base**4} numbers, #{data.length} given"
+      end
+
+      res = self.best_grid_for base
+      res.each do |x, y, val|
+        res.set x, y, data[x+y*res.size]
+      end
+
+      return res
+    end
+  end
+end

data/tests/test_sudoku.rb

@@ -0,0 +1,182 @@
+require 'test/unit'
+require 'sudoku'
+
+module GridTest
+  def create
+    klass.new base
+  end
+  
+  def diagonal
+    s = create
+    s.each{|x, y, val| s.set x,x,x+1 if x==y}
+    s
+  end
+  
+  def test_diagonal
+    s = diagonal
+    (s.size-1).times{|i| assert_equal 1, s.get(i+1, i+1)-s.get(i, i)}
+  end
+  
+  def test_limits
+    s = create
+    assert_raise(ArgumentError){s.get s.size, 1}
+    assert_raise(ArgumentError){s.get 1, s.size}
+    assert_raise(ArgumentError){s.set s.size, 1, 1}
+    assert_raise(ArgumentError){s.set 1, s.size, 1}
+    assert_raise(ArgumentError){s.set 1, 1, s.size+1}
+  end
+  
+  def test_getset
+    s = create
+    s.set 0, 0, 1
+    assert_equal 1, s.get(0, 0)
+  end
+  
+  def test_clone
+    s1 = create
+    s1.set 0, 0, 1
+      
+    s2 = s1.clone
+      
+    assert_equal 1, s2.get(0, 0)
+  end
+  
+  def test_each
+    s = diagonal
+    s.size.times{|x| assert_equal x+1, s.get(x, x)}
+  end
+  
+  def test_size
+    s = create
+    assert_equal base   , s.base
+    assert_equal base**2, s.size
+    assert_equal base**4, s.length
+  end
+
+  def test_col_row_square
+    s = create
+    2.times do |x|
+      2.times do |y|
+        s.set x, y, x+y*2+1
+      end
+    end
+    assert_equal [1, 2, 3, 4], s.square(0, 0).sort
+    assert_equal [1, 2],       s.row(0).sort
+    assert_equal [1, 3],       s.col(0).sort
+  end
+
+  def test_possibilities
+    s = create
+    s.set 0,0,1
+    s.set 0,1,2
+    
+    assert s.possibilities(1, 1).include?(3)
+    assert s.possibilities(1, 1).include?(4)
+    
+    assert s.valid?(1,1,3)
+    assert s.valid?(1,1,4)
+    
+    refute s.valid?(1,1,0)
+    refute s.valid?(1,1,1)
+    assert s.valid?(0,0,1)
+  end
+
+  def test_sutxt
+    sutxt = "#{base}:"
+    size = base*base
+    size.times do |y|
+      size.times {|x| sutxt << " #{x+1}"}
+    end
+    sutxt += ';'
+    
+    s = Sudoku.parse(sutxt)
+    assert_equal sutxt, s.to_sutxt
+    assert_equal 1, s.get(0,0)
+    assert_equal 1, s.get(0,1)
+    assert_equal 2, s.get(1,0)
+  end
+
+  def test_complete
+    s = create
+    refute s.complete?
+    assert s.completable?
+    assert s.valid?
+    
+    s.each{|x,y,val| s.set x, y, 1}
+    assert s.complete?
+    assert s.completable?
+    refute s.valid?
+  end
+end
+
+module GeneratorTest
+  def generator
+    Class.new klass do
+      include Sudoku::Generator
+    end
+  end
+  
+  def test_diagonal
+    s = generator.new(base).make_diagonal
+    s.size.times{|x| assert_equal x+1, s.get(x, x)}
+  end
+  
+  def test_valid
+    s = generator.new(base).make_valid
+    assert s.valid?
+    assert s.completable?
+    assert s.complete?
+  end
+end
+
+class S3Test < Test::Unit::TestCase
+  include GridTest
+  include GeneratorTest
+  
+  def base; 3; end
+  def klass; Sudoku::S3; end
+  def create; klass.new; end
+  
+  def test_square
+    s = diagonal
+    9.times do |i|
+      assert_equal [1+3*(i/3), 2+3*(i/3), 3+3*(i/3)], s.square(i,i)
+    end
+  end
+
+  def test_possibilities
+    super
+    s = diagonal
+    assert_equal [1, 4, 5, 6, 7, 8, 9], s.possibilities(0, 0).sort
+  end
+end
+
+class S4_15Test < Test::Unit::TestCase
+  include GridTest
+  include GeneratorTest
+  
+  def base; 4; end
+  def klass; Sudoku::S4_15; end
+  
+  def test_toolarge
+    assert_raise(ArgumentError){klass.new 16}
+  end
+end
+
+class SnTest < Test::Unit::TestCase
+  include GridTest
+  include GeneratorTest
+  
+  def base; 2; end
+  def klass; Sudoku::Sn; end
+end
+
+class SudokuTest < Test::Unit::TestCase
+  def test_autoclass
+    [S3Test, S4_15Test, SnTest].each do |g|
+      grid = g.new nil
+      assert_equal grid.klass, Sudoku[grid.base]
+    end
+  end
+end
+

metadata

@@ -0,0 +1,54 @@
+--- !ruby/object:Gem::Specification
+name: sudokuhandler
+version: !ruby/object:Gem::Version
+  version: 0.1.2
+  prerelease: 
+platform: ruby
+authors:
+- Titouan Christophe
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-01-16 00:00:00.000000000Z
+dependencies: []
+description: Highly optimised Sudoku objects and mixins for Ruby
+email: titouanchristophe@gmail.com
+executables: []
+extensions:
+- ext/extconf.rb
+extra_rdoc_files: []
+files:
+- lib/sudoku.rb
+- lib/sudoku/version.rb
+- ext/sudoku.c
+- Rakefile
+- README.md
+- tests/test_sudoku.rb
+- ext/extconf.rb
+homepage: http://github.com/titouanc/rb-sudoku
+licenses:
+- Creative Commons BY-NC-SA 3.0
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.15
+signing_key: 
+specification_version: 3
+summary: Ruby Sudoku handler
+test_files:
+- tests/test_sudoku.rb