lpsolver 0.1.0 → 0.2.0

data/ext/lpsolver-highs/version.rc.in

@@ -0,0 +1,50 @@
+
+
+#ifndef DEBUG
+#define VER_DEBUG 0
+#else
+#define VER_DEBUG VS_FF_DEBUG
+#endif
+
+#define VS_FF_DEBUG 0x1L
+#define VS_VERSION_INFO 0x1L
+#define VS_FFI_FILEFLAGSMASK 0x17L
+#define VOS__WINDOWS32 0x4L
+#define VFT_DLL 0x2L
+
+VS_VERSION_INFO VERSIONINFO
+  FILEVERSION    @PROJECT_RC_VERSION@
+  PRODUCTVERSION @PROJECT_VERSION@
+  FILEFLAGSMASK  VS_FFI_FILEFLAGSMASK
+  FILEFLAGS      VER_DEBUG
+  FILEOS         VOS__WINDOWS32
+  FILETYPE       VFT_DLL
+BEGIN
+    BLOCK "StringFileInfo"
+    BEGIN
+        BLOCK "040904b0"
+        BEGIN
+            VALUE "CompanyName", "HIGHS\0"
+            VALUE "FileDescription", "Commit @GITHASH@ compiled with @CMAKE_CXX_COMPILER_ID@ @CMAKE_CXX_COMPILER_VERSION@\0"
+            VALUE "FileVersion", "@PROJECT_VERSION@\0"
+            VALUE "InternalName", "highs\0"
+            VALUE "LegalCopyright", "Copyright (c) 2024 HiGHS. All rights reserved.\0"
+            VALUE "Licence", "MIT\0"
+            VALUE "Info", "https://highs.dev/\0"
+            VALUE "ProductName", "Highs\0"
+            VALUE "ProductVersion", "@PROJECT_VERSION@\0"
+        END
+    END
+
+    BLOCK "VarFileInfo"
+    BEGIN
+        /* The following line should only be modified for localized versions.     */
+        /* It consists of any number of WORD,WORD pairs, with each pair           */
+        /* describing a language,codepage combination supported by the file.      */
+        /*                                                                        */
+        /* For example, a file might have values "0x409,1252" indicating that it  */
+        /* supports English language (0x409) in the Windows ANSI codepage (1252). */
+
+        VALUE "Translation", 0x409, 1252
+    END
+END

data/lib/lpsolver/model.rb

@@ -72,12 +72,25 @@ module LpSolver
   class Model
     # The path to the HiGHS binary.
     #
-    # Set via the HIGHS_PATH environment variable, or defaults to 'highs'
-    # on the system PATH. This is used to invoke the HiGHS solver via
-    # the command line.
+    # Resolution order:
+    #   1. HIGHS_PATH environment variable
+    #   2. Bundled binary at lib/lpsolver/highs (from rake compile)
+    #   3. 'highs' on system PATH
     #
     # @return [String] The path to the HiGHS executable.
-    HIGHS_PATH = ENV.fetch('HIGHS_PATH', 'highs')
+    HIGHS_PATH = begin
+      env_path = ENV.fetch('HIGHS_PATH', nil)
+      if env_path
+        env_path
+      else
+        bundled = File.expand_path('../../lib/lpsolver/highs', __dir__)
+        if File.exist?(bundled)
+          bundled
+        else
+          'highs'
+        end
+      end
+    end
 
     # Creates a new empty LP/QP/MIP model.
     #
@@ -420,6 +433,17 @@ module LpSolver
       File.write(filename, to_lp)
     end
 
+    # Returns all variables defined in this model.
+    #
+    # @return [Hash{Symbol => Variable}] Maps variable names (Symbols) to
+    #   their Variable objects.
+    # @example
+    #   model.variables
+    #   # => { :x => @x(0), :y => @y(1) }
+    def variables
+      @variables
+    end
+
     private
 
     # Looks up a variable name by its internal index.

data/lib/lpsolver/native_model.rb

@@ -0,0 +1,261 @@
+# frozen_string_literal: true
+
+module LpSolver
+  # A native (C extension) backed model solver for HiGHS.
+  #
+  # This class uses the native C extension to call HiGHS directly,
+  # bypassing the LP file serialization overhead of the CLI approach.
+  # It requires the native extension to be compiled and linked against
+  # the HiGHS library.
+  #
+  # @note This is a prototype. The native extension must be compiled
+  #   separately using `rake compile` or `ruby ext/lpsolver/extconf.rb && make`.
+  #
+  # @example Basic usage
+  #   require 'lpsolver/native_model'
+  #
+  #   model = LpSolver::NativeModel.new
+  #   x = model.add_variable(:x, lb: 0)
+  #   y = model.add_variable(:y, lb: 0)
+  #
+  #   model.add_constraint(:c1, (x + y) >= 4)
+  #   solution = model.minimize!(x * 3 + y * 5)
+  #
+  #   puts solution[:x]  # => 4.0
+  #
+  # @example With MIP
+  #   model = LpSolver::NativeModel.new
+  #   x = model.add_variable(:x, lb: 0, integer: true)
+  #   y = model.add_variable(:y, lb: 0, integer: true)
+  #
+  #   model.add_constraint(:c1, (x + y) == 10)
+  #   solution = model.minimize!(x * 2 + y * 3)
+  #
+  #   puts solution[:x]  # => 10.0
+  class NativeModel
+    # @return [String] A descriptive name for this model.
+    attr_reader :name
+
+    # @return [Hash{Symbol => Variable}] All variables in the model.
+    attr_reader :variables
+
+    # @return [Array<Hash>] Constraint data for each constraint.
+    attr_reader :constraints
+
+    # @return [Symbol] Optimization sense (:minimize or :maximize).
+    attr_reader :sense
+
+    # @return [Hash{Integer => Float}] Linear objective coefficients.
+    attr_reader :objective
+
+    # @return [Array<[Integer, Integer, Float]>] Quadratic terms (for QP).
+    attr_reader :quadratic_terms
+
+    # Creates a new empty model.
+    #
+    # @param name [String] An optional name for this model.
+    def initialize(name = nil)
+      @name = name || 'untitled'
+      @variables = {}
+      @constraints = []
+      @var_counter = 0
+      @sense = :minimize
+      @objective = {}
+      @quadratic_terms = []
+      @var_types = {}
+      @var_bounds = {}
+    end
+
+    # Adds a variable to the model.
+    #
+    # @param name [Symbol, String] The variable name.
+    # @param lb [Float] Lower bound (default: 0.0).
+    # @param ub [Float] Upper bound (default: Float::INFINITY).
+    # @param integer [Boolean] Whether the variable must be integer (default: false).
+    # @return [Variable] The variable object.
+    def add_variable(name, lb: 0.0, ub: Float::INFINITY, integer: false)
+      name = name.to_sym
+      idx = @var_counter
+      var = Variable.new(idx, name)
+      @variables[name] = var
+      @var_types[name] = integer ? 1 : 0
+      @var_bounds[name] = [lb, ub]
+      @var_counter += 1
+      var
+    end
+
+    # Adds a constraint to the model.
+    #
+    # @param name [Symbol, String] The constraint name.
+    # @param expr [ConstraintSpec] The constraint specification.
+    # @return [Symbol] The constraint name.
+    def add_constraint(name, expr)
+      name = name.to_sym
+      lb_val, ub_val = expr.bounds
+      data_expr = expr.expr
+
+      @constraints << {
+        name: name,
+        lb: lb_val,
+        ub: ub_val,
+        expr: data_expr
+      }
+      name
+    end
+
+    # Sets the optimization sense to minimization.
+    #
+    # @return [void]
+    def minimize
+      @sense = :minimize
+    end
+
+    # Sets the optimization sense to maximization.
+    #
+    # @return [void]
+    def maximize
+      @sense = :maximize
+    end
+
+    # Sets the objective function.
+    #
+    # @param objective [LinearExpression, QuadraticExpression] The objective.
+    # @return [void]
+    def set_objective(objective)
+      if objective.is_a?(QuadraticExpression)
+        @objective = objective.linear_terms.transform_values(&:to_f)
+        @quadratic_terms = objective.hessian_entries
+      elsif objective.is_a?(LinearExpression)
+        @objective = objective.terms.transform_values(&:to_f)
+        @quadratic_terms = []
+      end
+    end
+
+    # Solves the model using the native extension.
+    #
+    # @return [Solution] The solution object.
+    # @raise [SolverError] If the solver encounters an error.
+    # @raise [LoadError] If the native extension is not available.
+    def solve
+      unless defined?(LpSolver::Native)
+        raise LoadError, 'Native extension not available. Compile with: rake compile'
+      end
+
+      num_col = @var_counter
+      num_row = @constraints.size
+
+      # Build column arrays
+      col_cost = Array.new(num_col, 0.0)
+      col_lower = Array.new(num_col)
+      col_upper = Array.new(num_col)
+      col_integrality = Array.new(num_col, 0)
+
+      @var_bounds.each do |name, (lb, ub)|
+        idx = @variables[name].index
+        col_lower[idx] = lb
+        col_upper[idx] = ub
+        col_integrality[idx] = @var_types[name] || 0
+      end
+
+      @objective.each do |idx, coeff|
+        col_cost[idx] = coeff
+      end
+
+      # Build constraint arrays (sparse matrix in CSC format)
+      row_lower = Array.new(num_row)
+      row_upper = Array.new(num_row)
+      astart = Array.new(num_row + 1, 0)
+      aindex = []
+      avalues = []
+      nz_count = 0
+
+      @constraints.each_with_index do |constr, row_idx|
+        row_lower[row_idx] = constr[:lb]
+        row_upper[row_idx] = constr[:ub]
+
+        constr[:expr].each do |col_idx, coeff|
+          aindex << col_idx
+          avalues << coeff
+          astart[row_idx + 1] += 1
+          nz_count += 1
+        end
+      end
+
+      # Adjust astart to be cumulative
+      cumulative = 0
+      astart.each_with_index do |val, i|
+        old = astart[i]
+        astart[i] = cumulative
+        cumulative += val
+      end
+
+      # Determine sense
+      sense = @sense == :maximize ? :maximize : :minimize
+
+      # Build quadratic arrays (for QP)
+      q_start = [0]
+      q_index = []
+      q_values = []
+
+      @quadratic_terms.each do |i1, i2, coeff|
+        q_index << i2
+        q_values << coeff
+        q_start << q_index.size
+      end
+
+      # Call native solver
+      if @quadratic_terms.any?
+        result = LpSolver::Native.solve_qp(
+          num_col, num_row,
+          col_cost, col_lower, col_upper,
+          row_lower, row_upper,
+          astart, aindex, avalues,
+          q_start, q_index, q_values,
+          sense
+        )
+      else
+        result = LpSolver::Native.solve_lp(
+          num_col, num_row,
+          col_cost, col_lower, col_upper, col_integrality,
+          row_lower, row_upper,
+          astart, aindex, avalues,
+          sense
+        )
+      end
+
+      # Parse result
+      variables = {}
+      result[:col_value].each_with_index do |val, idx|
+        var_name = @variables.find { |_, v| v.index == idx }&.first
+        variables[var_name.to_s] = val if var_name
+      end
+
+      Solution.new(
+        variables: variables,
+        objective_value: result[:objective],
+        model_status: result[:status].to_s,
+        iterations: 0
+      )
+    end
+
+    # Sets the optimization sense, objective, and solves in one call.
+    #
+    # @param objective [LinearExpression, QuadraticExpression] The objective.
+    # @return [Solution] The solution object.
+    def minimize!(objective)
+      @sense = :minimize
+      set_objective(objective)
+      solve
+    end
+
+    # Sets the optimization sense, objective, and solves in one call.
+    #
+    # @param objective [LinearExpression, QuadraticExpression] The objective.
+    # @return [Solution] The solution object.
+    def maximize!(objective)
+      @sense = :maximize
+      set_objective(objective)
+      solve
+    end
+  end
+end

data/lib/lpsolver/solution.rb

@@ -55,24 +55,89 @@ module LpSolver
 
     # Retrieves the value of a variable by name.
     #
-    # @param name [Symbol, String] The variable name.
+    # @param name [Symbol, String, Variable] The variable name (Symbol, String,
+    #   or Variable object).
     # @return [Float] The optimal value of the variable.
     # @raise [KeyError] If the variable name is not found in the solution.
     # @example
-    #   solution[:x]  # => 4.0
+    #   solution[:x]        # => 4.0 (by symbol)
+    #   solution['x']       # => 4.0 (by string)
+    #   solution[x]         # => 4.0 (by Variable object)
     def [](name)
-      variables[name.to_s]
+      key = if name.is_a?(Variable)
+        name.name.to_s
+      else
+        name.to_s
+      end
+      variables[key]
     end
 
     # Retrieves values for multiple variables by name.
     #
-    # @param *names [Symbol, String] The variable names to retrieve.
+    # @param *names [Symbol, String, Variable] The variable names to retrieve.
     # @return [Array<Float>] An array of variable values in the same order.
     # @example
-    #   solution.values_at(:x, :y)  # => [4.0, 0.0]
-    # @param [Array<Object>] names
+    #   solution.values_at(:x, :y)      # => [4.0, 0.0]
+    #   solution.values_at(x, y)        # => [4.0, 0.0] (by Variable objects)
+    #   solution.values_at(:x, y, 'z')  # => [4.0, 0.0, 3.0] (mixed types)
     def values_at(*names)
-      names.map { |name| variables[name.to_s] }
+      names.map { |name| self[name] }
+    end
+
+    # Returns all variables as a hash with Symbol keys.
+    #
+    # This is a convenience method that converts the internal String-keyed
+    # variables hash to a Symbol-keyed hash for easier Ruby-style access.
+    #
+    # @return [Hash{Symbol => Float}] Maps variable names (as symbols) to
+    #   their optimal values.
+    # @example
+    #   solution.all_variables
+    #   # => { :x => 4.0, :y => 0.0 }
+    def all_variables
+      variables.transform_keys(&:to_sym)
+    end
+
+    # Returns the solution as a plain hash with Symbol keys.
+    #
+    # This is equivalent to #all_variables and is provided for Ruby
+    # convention compatibility.
+    #
+    # @return [Hash{Symbol => Float}] Maps variable names to values.
+    # @example
+    #   solution.to_h  # => { :x => 4.0, :y => 0.0 }
+    def to_h
+      all_variables
+    end
+
+    # Iterates over all variables and their optimal values.
+    #
+    # Yields each variable name (as a Symbol) and its value.
+    #
+    # @yieldparam name [Symbol] The variable name.
+    # @yieldparam value [Float] The optimal value of the variable.
+    # @return [self] self for chaining.
+    # @example
+    #   solution.each_variable { |name, value| puts "#{name} = #{value}" }
+    def each_variable
+      all_variables.each { |name, value| yield name, value }
+      self
+    end
+
+    # Checks if a variable exists in the solution.
+    #
+    # @param name [Symbol, String, Variable] The variable name to check.
+    # @return [Boolean] True if the variable exists in the solution.
+    # @example
+    #   solution.has_variable?(:x)  # => true
+    #   solution.has_variable?(:z)  # => false
+    def has_variable?(name)
+      key = if name.is_a?(Variable)
+        name.name.to_s
+      else
+        name.to_s
+      end
+      variables.key?(key)
     end
 
     # Checks if the solution is feasible.

data/lib/lpsolver/version.rb

@@ -4,5 +4,5 @@ module LpSolver
   # The current version of the LpSolver gem.
   #
   # @return [String] The version string (e.g., "0.1.0").
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
 end

data/lpsolver.gemspec

@@ -22,8 +22,11 @@ Gem::Specification.new do |spec|
   spec.metadata['documentation_uri'] = 'https://davidsiaw.github.io/lpsolver'
   spec.metadata['rubygems_mfa_required'] = 'true'
 
-  spec.files         = Dir['{exe,data,lib}/**/*'] + %w[Gemfile lpsolver.gemspec README.md LICENSE.txt]
+  spec.add_development_dependency 'rake-compiler', '~> 1.2'
+
+  spec.files         = Dir['{exe,data,lib,ext}/**/*'] + %w[Gemfile lpsolver.gemspec README.md LICENSE.txt]
   spec.bindir        = 'exe'
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
+  spec.extensions    = %w[ext/lpsolver/extconf.rb]
 end