rglpk 0.1

data/lib/glpk.rb

@@ -0,0 +1,320 @@
+require 'rglpk.so'
+
+module GLPK
+
+  Rglpk.constants.each do |c|
+    v = Rglpk.const_get(c)
+    self.const_set(c,v) if v.kind_of? Numeric
+  end
+  TypeConstants =[GLP_FR, GLP_LO, GLP_UP, GLP_DB, GLP_FX]
+
+  class RowColArray < Array
+    def [](i)
+      super(i-1)
+    end
+    def []=(i,n)
+      super(i-1,n)
+    end
+    def fix_idx
+      self.each_with_index do |rc,i|
+        if rc.respond_to?(:i)
+          rc.i = i+1
+        else
+          rc.j = i+1
+        end
+      end
+    end
+  end
+  class RowArray < RowColArray
+    def [](i)
+      if i.kind_of?(Numeric)
+        super(i)
+      elsif i.kind_of?(String)
+        raise RuntimeError if self[1].nil?
+        idx = Rglpk.glp_find_row(self[1].p.lp,i)
+        raise ArgumentError if idx == 0
+        super(idx)
+      else
+        raise ArgumentError
+      end
+    end   
+    def []=(i,n)
+      raise ArgumentError unless n.is_a?(GLPK::Row)
+      super
+    end
+  end
+  class ColArray < RowColArray
+    def [](i)
+      if i.kind_of?(Numeric)
+        super(i)
+      elsif i.kind_of?(String)
+        raise RuntimeError if self[1].nil?
+        idx = Rglpk.glp_find_col(self[1].p.lp,i)
+        raise ArgumentError if idx == 0
+        super(idx)
+      else
+        raise ArgumentError
+      end
+    end   
+    def []=(i,n)
+      raise ArgumentError unless n.is_a?(GLPK::Col)
+      super
+    end
+  end
+
+  class Problem
+
+    attr_accessor :rows, :cols, :obj, :lp
+
+    def initialize
+      @lp = Rglpk.glp_create_prob
+      @obj = GLPK::ObjectiveFunction.new(self)
+      @rows = GLPK::RowArray.new
+      @cols = GLPK::ColArray.new
+      Rglpk.glp_create_index(@lp)
+      @status = nil
+    end
+    
+    def name=(n)
+      Rglpk.glp_set_prob_name(@lp,n)
+    end
+    def name
+      Rglpk.glp_get_prob_name(@lp)
+    end
+    
+    def nz
+      Rglpk.glp_get_num_nz(@lp)
+    end
+
+    def add_rows(n)
+      Rglpk.glp_add_rows(@lp,n)
+      s = @rows.size
+      n.times{|i| @rows << GLPK::Row.new(self,s+i+1)}
+      @rows
+    end
+    def add_cols(n)
+      Rglpk.glp_add_cols(@lp,n)
+      s = @cols.size
+      n.times{|i| @cols << GLPK::Column.new(self,s+i+1)}
+      @cols
+    end      
+        
+    def del_rows(a)
+      #ensure the array of rows tro delete is sorted and unique
+      a = a.sort.uniq
+
+      r = Rglpk.new_intArray(a.size+1)
+      a.each_with_index{|n,i| Rglpk.intArray_setitem(r,i+1,n)}
+      Rglpk.glp_del_rows(@lp,a.size,r)
+
+      a.each do |n|
+        @rows.delete_at(n)
+        a.each_with_index do |nn,i|
+          a[i] -= 1
+        end
+      end
+      @rows.fix_idx
+      a
+    end
+
+    def del_cols(a)
+      #ensure the array of rows tro delete is sorted and unique
+      a = a.sort.uniq
+
+      r = Rglpk.new_intArray(a.size+1)
+      a.each_with_index{|n,i| Rglpk.intArray_setitem(r,i+1,n)}
+      Rglpk.glp_del_cols(@lp,a.size,r)
+
+      a.each do |n|
+        @cols.delete_at(n)
+        a.each_with_index do |nn,i|
+          a[i] -= 1
+        end
+      end
+      @cols.fix_idx
+      a
+    end
+
+    def set_matrix(v)
+      
+      nr = Rglpk.glp_get_num_rows(@lp)
+      nc = Rglpk.glp_get_num_cols(@lp)
+      
+      ia = Rglpk.new_intArray(v.size+1)
+      ja = Rglpk.new_intArray(v.size+1)
+      ar = Rglpk.new_doubleArray(v.size+1)
+      
+      v.each_with_index do |x,y|
+        rn = (y+nr) / nc
+        cn = (y % nc) + 1
+
+        Rglpk.intArray_setitem(ia,y+1,rn) # 1,1,2,2
+        Rglpk.intArray_setitem(ja,y+1,cn) # 1,2,1,2
+        Rglpk.doubleArray_setitem(ar,y+1,x)
+      end
+      
+      Rglpk.glp_load_matrix(@lp,v.size,ia,ja,ar)
+      
+    end
+
+    def simplex(options)
+
+      parm = Rglpk::Glp_smcp.new
+      Rglpk.glp_init_smcp(parm)
+
+      #Default to errors only temrinal output
+      parm.msg_lev = GLPK::GLP_MSG_ERR
+
+      #set options
+      options.each do |k,v|
+        begin
+          parm.send("#{k}=".to_sym,v)
+        rescue NoMethodError
+          raise ArgumentError, "Unrecognised option: #{k}"
+        end
+      end
+
+      Rglpk.glp_simplex(@lp,parm)
+    end
+
+    def status
+      Rglpk.glp_get_status(@lp)
+    end
+
+  end
+        
+  class Row
+    attr_accessor :i, :p
+    def initialize(problem,i)
+      @p = problem
+      @i = i
+    end
+    def name=(n)    
+      Rglpk.glp_set_row_name(@p.lp,@i,n)
+    end
+    def name
+      Rglpk.glp_get_row_name(@p.lp,@i)
+    end
+    def set_bounds(type,lb,ub)
+      raise ArgumentError unless GLPK::TypeConstants.include?(type)
+      lb = 0.0 if lb.nil?
+      ub = 0.0 if ub.nil?
+      Rglpk.glp_set_row_bnds(@p.lp,@i,type,lb.to_f,ub.to_f)
+    end 
+    def bounds
+      t  = Rglpk.glp_get_row_type(@p.lp,@i)
+      lb = Rglpk.glp_get_row_lb(@p.lp,@i)
+      ub = Rglpk.glp_get_row_ub(@p.lp,@i)
+
+      lb = (t == GLPK::GLP_FR or t == GLPK::GLP_UP) ? nil : lb
+      ub = (t == GLPK::GLP_FR or t == GLPK::GLP_LO) ? nil : ub      
+      
+      [t,lb,ub]
+    end
+    def set(v)
+      raise RuntimeError unless v.size == @p.cols.size
+      ind = Rglpk.new_intArray(v.size+1)
+      val = Rglpk.new_doubleArray(v.size+1)
+      
+      1.upto(v.size){|x| Rglpk.intArray_setitem(ind,x,x)}
+      v.each_with_index{|x,y| Rglpk.doubleArray_setitem(val,y+1,x)}
+      
+      Rglpk.glp_set_mat_row(@p.lp,@i,v.size,ind,val)      
+    end
+    def get
+      ind = Rglpk.new_intArray(@p.cols.size+1)
+      val = Rglpk.new_doubleArray(@p.cols.size+1)      
+      len = Rglpk.glp_get_mat_row(@p.lp,@i,ind,val)
+      row = Array.new(@p.cols.size,0)
+      len.times do |i|
+        v = Rglpk.doubleArray_getitem(val,i+1)
+        j = Rglpk.intArray_getitem(ind,i+1)
+        row[j-1] = v
+      end
+      return row
+    end
+  end
+  class Column
+    attr_accessor :j, :p
+    def initialize(problem,i)
+      @p = problem
+      @j = i
+    end
+    def name=(n)
+      Rglpk.glp_set_col_name(@p.lp,@j,n)
+    end
+    def name
+      Rglpk.glp_get_col_name(@p.lp,@j)
+    end
+    def set_bounds(type,lb,ub)
+      raise ArgumentError unless GLPK::TypeConstants.include?(type)
+      lb = 0.0 if lb.nil?
+      ub = 0.0 if ub.nil?
+      Rglpk.glp_set_col_bnds(@p.lp,@j,type,lb,ub)
+    end     
+    def bounds
+      t  = Rglpk.glp_get_col_type(@p.lp,@j)
+      lb = Rglpk.glp_get_col_lb(@p.lp,@j)
+      ub = Rglpk.glp_get_col_ub(@p.lp,@j)
+
+      lb = (t == GLPK::GLP_FR or t == GLPK::GLP_UP) ? nil : lb
+      ub = (t == GLPK::GLP_FR or t == GLPK::GLP_LO) ? nil : ub      
+      
+      [t,lb,ub]
+    end
+    def set(v)
+      raise RuntimeError unless v.size == @p.rows.size
+      ind = Rglpk.new_intArray(v.size+1)
+      val = Rglpk.new_doubleArray(v.size+1)
+      
+      1.upto(v.size){|x| Rglpk.intArray_setitem(ind,x,x)}
+      v.each_with_index{|x,y| Rglpk.doubleArray_setitem(val,y+1,x)}
+      
+      Rglpk.glp_set_mat_col(@p.lp,@j,v.size,ind,val)    
+    end 
+    def get
+      ind = Rglpk.new_intArray(@p.rows.size+1)
+      val = Rglpk.new_doubleArray(@p.rows.size+1)      
+      len = Rglpk.glp_get_mat_col(@p.lp,@j,ind,val)
+      col = Array.new(@p.rows.size,0)
+      len.times do |i|
+        v = Rglpk.doubleArray_getitem(val,i+1)
+        j = Rglpk.intArray_getitem(ind,i+1)
+        col[j-1] = v
+      end
+      return col
+    end    
+  end    
+
+  class ObjectiveFunction
+    def initialize(problem)
+      @p = problem
+    end
+    def name=(n)
+      Rglpk.glp_set_obj_name(@p.lp,n)
+    end
+    def name
+      Rglpk.glp_get_obj_name(@p.lp)
+    end
+    def dir=(d)
+      raise ArgumentError if d != GLPK::GLP_MIN and d != GLPK::GLP_MAX
+      Rglpk.glp_set_obj_dir(@p.lp,d)
+    end
+    def dir
+      Rglpk.glp_get_obj_dir(@p.lp)
+    end
+    def set_coef(j,coef)
+      Rglpk.glp_set_obj_coef(@p.lp,j,coef)
+    end
+    def coefs=(a)
+      @p.cols.each{|c| Rglpk.glp_set_obj_coef(@p.lp,c.j,a[c.j-1])}
+      a
+    end
+    def coefs
+      @p.cols.map{|c| Rglpk.glp_get_obj_coef(@p.lp,c.j)}
+    end
+    def get
+      Rglpk.glp_get_obj_val(@p.lp)
+    end
+  end
+end

data/swig/Makefile.in

@@ -0,0 +1,4 @@
+rglpk.c: glpk.i
+	@SWIG@ -I/usr/local/include -ruby -w801 -o $@ $?
+wrap: rglpk.c
+	cp $? ../ext/$?

data/swig/configure.in

@@ -0,0 +1,4 @@
+AC_INIT(glpk.i)
+AC_CHECK_HEADERS_ONCE(glpk.h)
+AC_PATH_PROG([SWIG], [swig])
+AC_OUTPUT(Makefile)

data/swig/glpk.i

@@ -0,0 +1,40 @@
+/*
+* == Author
+* Nigel Galloway
+*
+* == Copyright
+*Copyright (C) 2007 Nigel Galloway
+*
+* Contributor(s):
+*	Alex Gutteridge
+*
+*This library is free software; you can redistribute it and/or
+*modify it under the terms of the GNU Lesser General Public
+*License as published by the Free Software Foundation; either
+*version 2.1 of the License, or (at your option) any later version.
+*
+*This library is distributed in the hope that it will be useful,
+*but WITHOUT ANY WARRANTY; without even the implied warranty of
+*MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+*Lesser General Public License for more details.
+*
+*You should have received a copy of the GNU Lesser General Public
+*License along with this library; if not, write to the Free Software
+*Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+%module rglpk
+
+%{
+#include "glpk.h"
+%}
+
+%include "carrays.i"
+
+%array_functions(int, intArray)
+%array_functions(double, doubleArray)
+
+%include "glpk.h"
+
+
+

data/test/test_all.rb

@@ -0,0 +1,188 @@
+require 'test/unit'
+require 'glpk'
+
+class TestGLPK < Test::Unit::TestCase
+
+  def test_create
+    assert_instance_of GLPK::Problem, GLPK::Problem.new
+  end
+
+  def test_name
+    p = GLPK::Problem.new
+    p.name = 'test'
+    assert_equal 'test', p.name
+  end
+
+  def test_obj_fun_name
+    p = GLPK::Problem.new
+    p.obj.name = 'test'
+    assert_equal 'test', p.obj.name
+  end
+
+  def test_obj_fun_dir
+    p = GLPK::Problem.new
+    p.obj.dir = GLPK::GLP_MIN
+    assert_equal GLPK::GLP_MIN, p.obj.dir
+    p.obj.dir = GLPK::GLP_MAX
+    assert_equal GLPK::GLP_MAX, p.obj.dir
+    assert_raise(ArgumentError){p.obj.dir = 3}    
+  end
+
+  def test_add_rows
+    p = GLPK::Problem.new
+    p.add_rows(2)
+    assert_equal 2, p.rows.length
+    p.add_rows(2)
+    assert_equal 4, p.rows.length
+  end
+
+  def test_add_cols
+    p = GLPK::Problem.new
+    p.add_cols(2)
+    assert_equal 2, p.cols.length
+    p.add_cols(2)
+    assert_equal 4, p.cols.length
+  end
+
+  def test_set_row_name
+    p = GLPK::Problem.new
+    p.add_rows(10)
+    p.rows[1].name = 'test'
+    assert_equal 'test', p.rows[1].name
+    assert_nil p.rows[2].name
+  end
+
+  def test_set_col_name
+    p = GLPK::Problem.new
+    p.add_cols(2)
+    p.cols[1].name = 'test'
+    assert_equal 'test', p.cols[1].name
+    assert_nil p.cols[2].name
+  end
+
+  def test_set_row_bounds
+    p = GLPK::Problem.new
+    p.add_rows(2)
+    p.rows[1].set_bounds(GLPK::GLP_FR,nil,nil)
+    assert_equal [GLPK::GLP_FR, nil, nil], p.rows[1].bounds
+  end
+
+  def test_set_col_bounds
+    p = GLPK::Problem.new
+    p.add_cols(2)
+    p.cols[1].set_bounds(GLPK::GLP_FR,nil,nil)
+    assert_equal [GLPK::GLP_FR, nil, nil], p.cols[1].bounds
+  end
+
+  def test_obj_coef
+    p = GLPK::Problem.new
+    p.add_cols(2)
+    p.obj.set_coef(1,2)
+    assert_equal [2,0], p.obj.coefs
+    p.obj.coefs = [1,2]
+    assert_equal [1,2], p.obj.coefs    
+  end
+
+  def test_set_row
+    p = GLPK::Problem.new
+    p.add_rows(2)
+    assert_raise(RuntimeError){p.rows[1].set([1,2])}    
+    p.add_cols(2)
+    p.rows[1].set([1,2])
+    assert_equal [1,2], p.rows[1].get
+  end
+
+  def test_set_col
+    p = GLPK::Problem.new
+    p.add_cols(2)
+    assert_raise(RuntimeError){p.cols[1].set([1,2])}    
+    p.add_rows(2)
+    p.cols[1].set([1,2])
+    assert_equal [1,2], p.cols[1].get
+  end
+
+  def test_set_mat
+    p = GLPK::Problem.new
+    p.add_cols(2)
+    p.add_rows(2)
+    p.set_matrix([1,2,3,4])
+    assert_equal [1,2], p.rows[1].get
+    assert_equal [3,4], p.rows[2].get
+    assert_equal [1,3], p.cols[1].get
+    assert_equal [2,4], p.cols[2].get
+  end
+
+  def test_del_row
+    p = GLPK::Problem.new
+    p.add_cols(2)
+    p.add_rows(2)
+    p.set_matrix([1,2,3,4])
+    assert_equal [1,2], p.rows[1].get
+    p.del_rows([1])
+    assert_equal [3,4], p.rows[1].get
+    assert_equal [3],   p.cols[1].get
+  end
+
+  def test_del_col
+    p = GLPK::Problem.new
+    p.add_cols(2)
+    p.add_rows(2)
+    p.set_matrix([1,2,3,4])
+    assert_equal [1,3], p.cols[1].get
+    p.del_cols([1])
+    assert_equal [2,4], p.cols[1].get
+    assert_equal [2],   p.rows[1].get
+  end
+
+  def test_nz
+    p = GLPK::Problem.new
+    p.add_cols(2)
+    p.add_rows(2)
+    p.set_matrix([1,2,3,4])
+    assert_equal 4, p.nz
+  end
+
+  def test_row_get_by_name
+    p = GLPK::Problem.new
+    assert_raises(RuntimeError){ p.rows['test'] }
+    p.add_cols(2)
+    p.add_rows(2)
+    p.set_matrix([1,2,3,4])
+    assert_raises(ArgumentError){ p.rows['test'] }
+    p.rows[1].name = 'test'
+    assert_equal [1,2], p.rows['test'].get
+  end
+
+  def test_col_get_by_name
+    p = GLPK::Problem.new
+    assert_raises(RuntimeError){ p.cols['test'] }
+    p.add_cols(2)
+    p.add_rows(2)
+    p.set_matrix([1,2,3,4])
+    assert_raises(ArgumentError){ p.cols['test'] }
+    p.cols[1].name = 'test'
+    assert_equal [1,3], p.cols['test'].get
+  end
+
+  def test_solve
+    p = GLPK::Problem.new
+    assert_raises(RuntimeError){ p.cols['test'] }
+    p.add_cols(2)
+    p.add_rows(2)
+    p.set_matrix([1,2,3,4])
+    p.simplex({:msg_lev => 1})
+  end
+
+  class D < GLPK::Problem
+    attr_accessor :species
+    def initialize
+      @species = []
+      super
+    end
+  end  
+
+  def test_derived
+    D.new.add_rows(10)
+  end
+
+end