mipper 0.0.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f3df4957c76c02dc47894208b573de31ffb70d8e
+  data.tar.gz: d83b68ff194145a7dd6ab43f34df6480eef6901f
+SHA512:
+  metadata.gz: 3c2fccdb2cfa9fd3796344c09b1335b460446d1a674034fd9143e3400cede2cc6483b386e297d01028ec64deff57d9a7886ea3fbe86a0863de047d266fb37014
+  data.tar.gz: f93a8c1ffa8e7ff786ebbcc7fd551deca62506e85bc99d2b5bcc0c14e40c2bf25363c42bb8864b095567c96319f0547491320d376b7329aa13c93842a44550e2

data/lib/mipper/cbc/ext.rb

@@ -0,0 +1,36 @@
+require 'ffi'
+
+module MIPPeR
+  module Cbc
+    extend FFI::Library
+    ffi_lib_flags :now, :global
+    ffi_lib 'z', 'bz2', 'CoinUtils', 'Osi', 'Clp', 'OsiClp', 'Cgl', 'Cbc',
+            'CbcSolver'
+
+    attach_function :Cbc_newModel, [], :pointer
+    attach_function :Cbc_deleteModel, [:pointer], :void
+    attach_function :Cbc_loadProblem, [:pointer, :int, :int, :pointer, :pointer,
+                                       :pointer, :pointer, :pointer, :pointer,
+                                       :pointer, :pointer], :void
+    attach_function :Cbc_setColName, [:pointer, :int, :string], :void
+    attach_function :Cbc_setRowName, [:pointer, :int, :string], :void
+    attach_function :Cbc_setObjSense, [:pointer, :double], :void
+    attach_function :Cbc_setRowLower, [:pointer, :int, :double], :void
+    attach_function :Cbc_setRowUpper, [:pointer, :int, :double], :void
+    attach_function :Cbc_setObjCoeff, [:pointer, :int, :double], :void
+    attach_function :Cbc_setColLower, [:pointer, :int, :double], :void
+    attach_function :Cbc_setColUpper, [:pointer, :int, :double], :void
+    attach_function :Cbc_setContinuous, [:pointer, :int], :void
+    attach_function :Cbc_setInteger, [:pointer, :int], :void
+    attach_function :Cbc_solve, [:pointer], :int
+    attach_function :Cbc_getColSolution, [:pointer], :pointer
+    attach_function :Cbc_getObjValue, [:pointer], :double
+    attach_function :Cbc_status, [:pointer], :int
+    attach_function :Cbc_secondaryStatus, [:pointer], :int
+    attach_function :Cbc_printModel, [:pointer, :string], :void
+    attach_function :Cbc_isProvenOptimal, [:pointer], :int
+    attach_function :Cbc_isProvenInfeasible, [:pointer], :int
+    attach_function :Cbc_isContinuousUnbounded, [:pointer], :int
+    attach_function :Cbc_setParameter, [:pointer, :string, :string], :void
+  end
+end

data/lib/mipper/cbc/model.rb

@@ -0,0 +1,174 @@
+module MIPPeR
+  class CbcModel < Model
+    attr_reader :ptr
+
+    def initialize
+      super
+
+      @var_count = 0
+      @constr_count = 0
+
+      # Construct a new model
+      @ptr = FFI::AutoPointer.new Cbc.Cbc_newModel,
+                                  Cbc.method(:Cbc_deleteModel)
+      Cbc.Cbc_setParameter @ptr, 'logLevel', '0'
+    end
+
+    # Set the sense of the model
+    def sense=(sense)
+      @sense = sense
+      sense = sense == :min ? 1 : -1
+      Cbc.Cbc_setObjSense @ptr, sense
+    end
+
+    # Optimize the model
+    def optimize
+      # Ensure pending variables and constraints are added
+      update
+
+      # Run the solver and save the status for later
+      Cbc.Cbc_solve @ptr
+      fail if Cbc.Cbc_status(@ptr) != 0
+
+      # Check and store the model status
+      if Cbc.Cbc_isProvenOptimal(@ptr) == 1
+        @status = :optimized
+      elsif Cbc.Cbc_isProvenInfeasible(@ptr) == 1 or
+            Cbc.Cbc_isContinuousUnbounded(@ptr) == 1
+        @status = :invalid
+      else
+        @status = :unknown
+      end
+    end
+
+    # Get the status of the model
+    def status
+      @status
+    end
+
+    # The value of the objective function
+    def objective_value
+      Cbc.Cbc_getObjValue @ptr
+    end
+
+    # Get the value of a variable from the model
+    def variable_value(var)
+      dblptr = Cbc.Cbc_getColSolution @ptr
+      dblptr.read_array_of_double(@variables.length)[var.index]
+    end
+
+    def set_variable_bounds(var_index, lb, ub)
+      Cbc.Cbc_setColLower @ptr, var_index, lb
+      Cbc.Cbc_setColUpper @ptr, var_index, ub
+    end
+
+    protected
+
+    # Add multiple variables to the model simultaneously
+    def add_variables(vars)
+      # Store all the variables in the model
+      # Most of the work will be done when we add the constraints
+      vars.each do |var|
+        var.instance_variable_set :@model, self
+        @variables << var
+      end
+    end
+
+    # Add multiple constraints at once
+    def add_constraints(constrs)
+      # Store the index which will be used for each constraint
+      constrs.each do |constr|
+        constr.instance_variable_set :@index, @constr_count
+        @constr_count += 1
+      end
+
+      # Construct a matrix of non-zero values in CSC format
+      start = []
+      index = []
+      value = []
+      col_start = 0
+      @variables.each do |var|
+        # Mark the start of this column
+        start << col_start
+
+        var.constraints.each do |constr|
+          col_start += 1
+          index << constr.instance_variable_get(:@index)
+          value << constr.expression.terms[var]
+        end
+      end
+      start << col_start
+
+      start_buffer = FFI::MemoryPointer.new :int, start.length
+      start_buffer.write_array_of_int start
+      index_buffer = FFI::MemoryPointer.new :int, index.length
+      index_buffer.write_array_of_int index
+      value_buffer = FFI::MemoryPointer.new :double, value.length
+      value_buffer.write_array_of_double value
+
+      Cbc.Cbc_loadProblem @ptr, @variables.length, constrs.length,
+                          start_buffer, index_buffer, value_buffer,
+                          nil, nil, nil, nil, nil
+
+      constrs.each do |constr|
+        store_constraint constr
+        @constraints << constr
+      end
+
+      # We store variables now since they didn't exist earlier
+      @variables.each_with_index do |var, i|
+        var.instance_variable_set(:@index, i)
+        store_variable var
+      end
+    end
+
+    private
+
+    # Save the constraint to the model and update the constraint pointers
+    def store_constraint(constr)
+      # Update the constraint to track the index in the model
+      index = constr.instance_variable_get(:@index)
+      constr.instance_variable_set :@model, self
+
+      # Set constraint properties
+      Cbc.Cbc_setRowName(@ptr, index, constr.name) unless constr.name.nil?
+
+      case constr.sense
+      when :==
+        lb = ub = constr.rhs
+      when :>=
+        lb = constr.rhs
+        ub = Float::INFINITY
+      when :<=
+        lb = -Float::INFINITY
+        ub = constr.rhs
+      end
+      Cbc.Cbc_setRowLower @ptr, index, lb
+      Cbc.Cbc_setRowUpper @ptr, index, ub
+    end
+
+    # Set the properties of a variable in the model
+    def store_variable(var)
+      # Force the correct bounds since we can't explicitly specify binary
+      if var.type == :binary
+        var.instance_variable_set(:@lower_bound, 0)
+        var.instance_variable_set(:@upper_bound, 1)
+      end
+
+      Cbc.Cbc_setColLower @ptr, var.index, var.lower_bound
+      Cbc.Cbc_setColUpper @ptr, var.index, var.upper_bound
+      Cbc.Cbc_setObjCoeff @ptr, var.index, var.coefficient
+
+      case var.type
+      when :continuous
+        Cbc.Cbc_setContinuous @ptr, var.index
+      when :integer, :binary
+        Cbc.Cbc_setInteger @ptr, var.index
+      else
+        fail :type
+      end
+
+      Cbc.Cbc_setColName(@ptr, var.index, var.name) unless var.name.nil?
+    end
+  end
+end

data/lib/mipper/cbc.rb

@@ -0,0 +1,3 @@
+require_relative 'cbc/ext'
+
+require_relative 'cbc/model'

data/lib/mipper/constraint.rb

@@ -0,0 +1,17 @@
+module MIPPeR
+  class Constraint
+    attr_reader :expression, :sense, :rhs, :name
+
+    def initialize(expr, sense, rhs, name = nil)
+      @expression = expr
+      @sense = sense
+      @rhs = rhs
+      @name = name
+
+      # Store this constraint for each associated variable
+      @expression.terms.each_key do |var|
+        var.constraints << self
+      end
+    end
+  end
+end

data/lib/mipper/expression.rb

@@ -0,0 +1,53 @@
+module MIPPeR
+  class LinExpr
+    attr_reader :terms
+
+    def initialize(terms = {})
+      @terms = terms
+    end
+
+    # Add two {LinExpr}s
+    def +(other)
+      case other
+      when LinExpr
+        # Add the terms of two expressions
+        # For now, this assumes variables are not duplicated
+        LinExpr.new(@terms.merge(other.terms) { |_, c1, c2| c1 + c2 })
+      when Variable
+        # Add the variable to the expression
+        self + other * 1.0
+      else
+        fail TypeError
+      end
+    end
+
+    # Add terms from the other expression to this one
+    def add(other)
+      case other
+      when LinExpr
+        @terms.merge!(other.terms) { |_, c1, c2| c1 + c2 }
+      when Variable
+        if @terms.key? other
+          @terms[other] += 1.0
+        else
+          @terms[other] = 1.0
+        end
+      else
+        fail TypeError
+      end
+
+      self
+    end
+
+    # Produce a string representing the expression
+    def inspect
+      @terms.map do |var, coeff|
+        # Skip if the coefficient is zero or the value is zero
+        value = var.value
+        next if coeff == 0 || value == 0 || value == false
+
+        coeff == 1 ? var.name : "#{var.name} * #{coeff}"
+      end.compact.join(' + ')
+    end
+  end
+end