rams 0.1.6 → 0.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: d4517c505465b19e574e3cc95c74f2752e2f86c6
-  data.tar.gz: 8a89edf255ae13faecef79b088405fa4585f0bcd
+SHA256:
+  metadata.gz: defc078f3cd03a2c628d0e11188285cb9ee9382a51aa1f9ec1f922ed07e572fb
+  data.tar.gz: 272fea822e2e6653b9c459c771c4791872336f052c792e08da3b0408a57058b4
 SHA512:
-  metadata.gz: 057e75b5aed5a80b4522becfe96377c80c3f55c635db61dad3e53a7a22586b6774935e8d339c8acb81906e4de9817d6dbe555d2a207a4d57927632400cfe3a3e
-  data.tar.gz: 543e206a28a6b83918b1dd9edb390b55986a1f25cbec295f49251abcec9c1af5f3a7d41b4b8e2a3c0059d05459bc6ba1e2f9efe25b93cfa8938ac636a0970512
+  metadata.gz: 8786c449623e046a876cf4d6a17fc67839d050bfe0e8cea3a3045965b54bb78230d7741ac54d92486af7fdf4e693fecfe7a7c4020870b95692d262d8cbf02638
+  data.tar.gz: 5594f7fb97c6b6e22127a7feeb6a2032319f5d00cc38c37fb22baa96011af6dfea6fe4994c583d8fbc221c51019bd25f6ed11e1c202986e5064b30e9351d683b

data/lib/rams/model.rb

@@ -3,8 +3,8 @@ require_relative 'expression'
 require_relative 'formatters/lp'
 require_relative 'solvers/cbc'
 require_relative 'solvers/clp'
-require_relative 'solvers/cplex'
 require_relative 'solvers/glpk'
+require_relative 'solvers/highs'
 require_relative 'solvers/scip'
 require_relative 'variable'
 
@@ -38,8 +38,8 @@ module RAMS
     SOLVERS = {
       cbc: RAMS::Solvers::CBC.new,
       clp: RAMS::Solvers::CLP.new,
-      cplex: RAMS::Solvers::CPLEX.new,
       glpk: RAMS::Solvers::GLPK.new,
+      highs: RAMS::Solvers::HiGHS.new,
       scip: RAMS::Solvers::SCIP.new
     }.freeze
 

data/lib/rams/numeric.rb

@@ -30,7 +30,7 @@ class Integer
   end
 end
 
-# Floats can be treated the same way as Fixnums.
+# Floats can be treated the same way as Integers.
 class Float
   alias old_add +
   alias old_sub -

data/lib/rams/solvers/cbc.rb

@@ -5,7 +5,7 @@ module RAMS
     # Interface to COIN-OR Branch-and-Cut
     class CBC < Solver
       def solver_command(model_path, solution_path, args)
-        ['cbc', model_path] + args + ['printingOptions', 'all', 'solve', 'solution', solution_path]
+        [solver_executable('coin.cbc', 'cbc'), model_path] + args + ['printingOptions', 'all', 'solve', 'solution', solution_path]
       end
 
       private
@@ -22,8 +22,7 @@ module RAMS
 
       def parse_objective(model, lines)
         return nil if lines.count < 1
-        objective = lines.first.split[-1].to_f
-        model.sense == :max ? -objective : objective
+        lines.first.split[-1].to_f
       end
 
       def parse_primal(model, lines)
@@ -36,7 +35,7 @@ module RAMS
       def parse_dual(model, lines)
         lines[1, model.constraints.count].map do |l|
           comps = l.split
-          dual = model.sense == :max ? -comps[3].to_f : comps[3].to_f
+          dual = comps[3].to_f
           [model.constraints[comps[1]], dual]
         end.to_h
       end

data/lib/rams/solvers/clp.rb

@@ -5,7 +5,7 @@ module RAMS
     # Interface to COIN-OR Linear Programming
     class CLP < Solver
       def solver_command(model_path, solution_path, args)
-        ['clp', model_path] + args + ['printingOptions', 'all', 'solve', 'solution', solution_path]
+        [solver_executable('clp', 'clp'), model_path] + args + ['printingOptions', 'all', 'solve', 'solution', solution_path]
       end
 
       private
@@ -21,22 +21,21 @@ module RAMS
       end
 
       def parse_objective(model, lines)
-        return nil if lines.count < 2
-        objective = lines[1].split[-1].to_f
-        model.sense == :max ? -objective : objective
+        return nil if lines.count < 1
+        lines[0].split[-1].to_f
       end
 
       def parse_primal(model, lines)
-        lines[model.constraints.count + 2, model.variables.count].map do |l|
+        lines[model.constraints.count + 1, model.variables.count].map do |l|
           comps = l.split
           [model.variables[comps[1]], comps[2].to_f]
         end.to_h
       end
 
       def parse_dual(model, lines)
-        lines[2, model.constraints.count].map do |l|
+        lines[1, model.constraints.count].map do |l|
           comps = l.split
-          dual = model.sense == :max ? -comps[3].to_f : comps[3].to_f
+          dual = comps[3].to_f
           [model.constraints[comps[1]], dual]
         end.to_h
       end

data/lib/rams/solvers/glpk.rb

@@ -5,7 +5,7 @@ module RAMS
     # Interface to the GNU Linear Programming Kit
     class GLPK < Solver
       def solver_command(model_path, solution_path, args)
-        ['glpsol', '--lp', model_path, '--output', solution_path] + args
+        [solver_executable('glpsol', 'glpk'), '--lp', model_path, '--output', solution_path] + args
       end
 
       private

data/lib/rams/solvers/highs.rb

@@ -0,0 +1,94 @@
+require_relative 'solver'
+
+module RAMS
+  module Solvers
+    # Interface to HiGHS solver
+    class HiGHS < Solver
+      def solver_command(model_path, solution_path, args)
+        [solver_executable('highs', 'highs'), model_path, '--solution_file', solution_path] + args
+      end
+
+      private
+
+      def parse_status(_model, lines)
+        status_idx = lines.index { |l| l =~ /^Model status/ }
+        return :undefined unless status_idx
+
+        # Status is on the next line after "Model status"
+        status = lines[status_idx + 1]
+        return :undefined unless status
+
+        return :optimal if status =~ /optimal/i
+        return :feasible if status =~ /^feasible/i
+        return :infeasible if status =~ /infeasible/i
+        return :unbounded if status =~ /unbounded/i
+        :undefined
+      end
+
+      def parse_objective(_model, lines)
+        objective_line = lines.find { |l| l =~ /^Objective/ }
+        return nil unless objective_line
+        objective_line.split.last.to_f
+      end
+
+      def parse_primal(model, lines)
+        # Find the primal section
+        start_idx = lines.index { |l| l =~ /^# Columns/ }
+        return {} unless start_idx
+
+        num_columns = lines[start_idx].split.last.to_i
+        primal_values = {}
+
+        # Parse variable values
+        (1..num_columns).each do |i|
+          line = lines[start_idx + i]
+          next unless line
+
+          parts = line.split
+          next unless parts.length >= 2
+
+          var_name = parts[0]
+          var_value = parts[1].to_f
+          variable = model.variables[var_name]
+          primal_values[variable] = var_value if variable
+        end
+
+        primal_values
+      end
+
+      def parse_dual(model, lines)
+        # Find the dual section
+        dual_start_idx = lines.index { |l| l =~ /^# Dual solution values/ }
+        return {} unless dual_start_idx
+
+
+        # Check if dual solution is available
+        lines = lines[dual_start_idx..-1]
+        return {} if lines[dual_start_idx + 1] =~ /^None/
+
+        # Find the rows section within dual values
+        rows_idx = lines.index { |l| l =~ /^# Rows/ }
+        return {} unless rows_idx
+
+        num_rows = lines[rows_idx].split.last.to_i
+        dual_values = {}
+
+        # Parse constraint dual values
+        (1..num_rows).each do |i|
+          line = lines[rows_idx + i]
+          next unless line
+
+          parts = line.split
+          next unless parts.length >= 2
+
+          constraint_name = parts[0]
+          dual_value = parts[1].to_f
+          constraint = model.constraints[constraint_name]
+          dual_values[constraint] = dual_value if constraint
+        end
+
+        dual_values
+      end
+    end
+  end
+end

data/lib/rams/solvers/scip.rb

@@ -11,7 +11,7 @@ module RAMS
       end
 
       def solver_command(model_path, _solution_path, args)
-        ['scip', '-c', "read #{model_path}"] + args +
+        [solver_executable('scip', 'scip'), '-c', "read #{model_path}"] + args +
           ['-c', 'optimize', '-c', 'display solution', '-c', 'display dualsolution', '-c', 'quit']
       end
 
@@ -28,9 +28,9 @@ module RAMS
       end
 
       def parse_objective(_model, lines)
-        status = (lines.select { |l| l =~ /^objective value:/ }.first || '').split
-        return nil if status.size < 3
-        status[2].to_f
+        objective = (lines.select { |l| l =~ /^objective value:/ }.first || '').split
+        return nil if objective.size < 3
+        objective[2].to_f
       end
 
       def parse_primal(model, lines)

data/lib/rams/solvers/solver.rb

@@ -60,6 +60,11 @@ module RAMS
         raise NotImplementedError
       end
 
+      # Get solver executable name, checking environment variable first
+      def solver_executable(default_name, solver_name)
+        ENV["RAMS_SOLVER_PATH_#{solver_name.upcase}"] || default_name
+      end
+
       def parse_solution(model, solution_text)
         lines = solution_text.split "\n"
         RAMS::Solution.new(

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: rams
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.1.8
 platform: ruby
 authors:
 - Ryan J. O'Neil
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-02-05 00:00:00.000000000 Z
+date: 2025-06-24 00:00:00.000000000 Z
 dependencies: []
 description: A library for solving MILPs in Ruby.
 email:
@@ -26,8 +25,8 @@ files:
 - lib/rams/solution.rb
 - lib/rams/solvers/cbc.rb
 - lib/rams/solvers/clp.rb
-- lib/rams/solvers/cplex.rb
 - lib/rams/solvers/glpk.rb
+- lib/rams/solvers/highs.rb
 - lib/rams/solvers/scip.rb
 - lib/rams/solvers/solver.rb
 - lib/rams/variable.rb
@@ -35,7 +34,6 @@ homepage: https://github.com/ryanjoneil/rams
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -43,16 +41,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.4.0
+      version: 3.1.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.8
-signing_key: 
+rubygems_version: 3.6.2
 specification_version: 4
 summary: Ruby Algebraic Modeling System
 test_files: []

data/lib/rams/solvers/cplex.rb

@@ -1,55 +0,0 @@
-require 'nokogiri'
-require_relative 'solver'
-
-module RAMS
-  module Solvers
-    # Interface to CPLEX
-    class CPLEX < Solver
-      def solve_and_parse(model, model_path, solution_path)
-        call_solver model, model_path, solution_path
-        return RAMS::Solution.new(:infeasible, nil, {}, {}) unless File.exist? solution_path
-        parse_solution model, File.read(solution_path)
-      end
-
-      def solver_command(model_path, solution_path, args)
-        ['cplex', '-c', "read #{model_path}"] + args + ['optimize', "write #{solution_path}"]
-      end
-
-      private
-
-      def parse_solution(model, solution_text)
-        xml_doc = Nokogiri::XML solution_text
-        RAMS::Solution.new(
-          parse_status(model, xml_doc),
-          parse_objective(model, xml_doc),
-          parse_primal(model, xml_doc),
-          parse_dual(model, xml_doc)
-        )
-      end
-
-      def parse_status(_model, xml_doc)
-        status = xml_doc.css('CPLEXSolution').css('header').first['solutionStatusString']
-        return :optimal if status =~ /optimal/i
-        return :feasible if status =~ /feasible/i
-        return :unbounded if status =~ /unbounded/i
-        :unknown
-      end
-
-      def parse_objective(_model, xml_doc)
-        xml_doc.css('CPLEXSolution').css('header').first['objectiveValue'].to_f
-      end
-
-      def parse_primal(model, xml_doc)
-        xml_doc.css('CPLEXSolution').css('variables').css('variable').map do |v|
-          [model.variables[v['name']], v['value'].to_f]
-        end.to_h
-      end
-
-      def parse_dual(model, xml_doc)
-        xml_doc.css('CPLEXSolution').css('linearConstraints').css('constraint').map do |c|
-          [model.constraints[c['name']], c['dual'].to_f]
-        end.to_h
-      end
-    end
-  end
-end