Class: Rulp::Problem

Inherits:
Object show all
Defined in:
lib/rulp/rulp.rb

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(objective, objective_expression) ⇒ Problem

Returns a new instance of Problem.



84
85
86
87
88
89
90
 
# File 'lib/rulp/rulp.rb', line 84

def initialize(objective, objective_expression)
  @objective = objective
  @variables = Set.new
  @objective_expression = objective_expression.kind_of?(LV) ? 1 * objective_expression : objective_expression
  @variables.merge(@objective_expression.variables)
  @constraints = []
end

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(method_name, *args) ⇒ Object 



107
108
109
 
# File 'lib/rulp/rulp.rb', line 107

def method_missing(method_name, *args)
  self.call(method_name, *args)
end

Instance Attribute Details

#result ⇒ Object

Returns the value of attribute result.



82
83
84
 
# File 'lib/rulp/rulp.rb', line 82

def result
  @result
end

#trace ⇒ Object

Returns the value of attribute trace.



82
83
84
 
# File 'lib/rulp/rulp.rb', line 82

def trace
  @trace
end

Instance Method Details

#[](*constraints) ⇒ Object 



92
93
94
95
96
97
98
99
100
101
 
# File 'lib/rulp/rulp.rb', line 92

def [](*constraints)
  "Got constraints".log(:info)
  constraints.flatten!
  "Flattened constraints".log(:info)
  @constraints.concat(constraints)
  "Joint constraints".log(:info)
  @variables.merge(constraints.flat_map(&:variables).uniq)
  "Extracted variables".log(:info)
  self
end

#bits ⇒ Object 



134
135
136
137
 
# File 'lib/rulp/rulp.rb', line 134

def bits
  bits = @variables.select{|x| x.kind_of?(BV) }.join(" ")
  return "\nBinary\n #{bits}" if(bits.length > 0)
end

#bounds ⇒ Object 



139
140
141
142
143
144
 
# File 'lib/rulp/rulp.rb', line 139

def bounds
  @variables.map{|var|
    next unless var.bounds
    " #{var.bounds}"
  }.compact.join("\n")
end

#call(using = nil, options = {}) ⇒ Object 



116
117
118
 
# File 'lib/rulp/rulp.rb', line 116

def call(using=nil, options={})
  Rulp.send(self.solver(using), self, options)
end

#constraints ⇒ Object 



120
121
122
123
124
125
126
127
 
# File 'lib/rulp/rulp.rb', line 120

def constraints
  return  "0 #{@variables.first} = 0" if @constraints.length == 0
  constraints_str = " "
  @constraints.each.with_index{|constraint, i|
    constraints_str << " c#{i}: #{constraint}\n"
  }
  constraints_str
end

#get_output_filename ⇒ Object 



146
147
148
 
# File 'lib/rulp/rulp.rb', line 146

def get_output_filename
  "/tmp/rulp-#{Random.rand(0..1000)}.lp"
end

#inspect ⇒ Object 



182
183
184
 
# File 'lib/rulp/rulp.rb', line 182

def inspect
  to_s
end

#integers ⇒ Object 



129
130
131
132
 
# File 'lib/rulp/rulp.rb', line 129

def integers
  ints = @variables.select{|x| x.kind_of?(IV) }.join(" ")
  return "\nGeneral\n #{ints}" if(ints.length > 0)
end

#output(filename = choose_file) ⇒ Object Also known as: save 



150
151
152
 
# File 'lib/rulp/rulp.rb', line 150

def output(filename=choose_file)
  IO.write(filename, self)
end

#solve(opts = {}) ⇒ Object 



103
104
105
 
# File 'lib/rulp/rulp.rb', line 103

def solve(opts={})
  Rulp.send(self.solver, self, opts)
end

#solve_with(type, options = {}) ⇒ Object 



154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
 
# File 'lib/rulp/rulp.rb', line 154

def solve_with(type, options={})
  filename = get_output_filename
  solver = SOLVERS[type].new(filename, options)

  "Writing problem".log(:info)
  IO.write(filename, self)

  Rulp.exec("open #{filename}") if options[:open_definition]

  "Solving problem".log(:info)
  self.trace, time = _profile{ solver.solve }

  Rulp.exec("open #{solver.outfile}") if options[:open_solution]

  "Solver took #{time}".log(:debug)

  "Parsing result".log(:info)
  solver.store_results(@variables)

  solver.remove_lp_file  if options[:remove_lp_file]
  solver.remove_sol_file if options[:remove_sol_file]

  self.result = @objective_expression.evaluate

  "Objective: #{result}\n#{@variables.map{|v|[v.name, "=", v.value].join(' ') if v.value}.compact.join("\n")}".log(:debug)
  return self.result
end

#solver(solver = nil) ⇒ Object 



111
112
113
114
 
# File 'lib/rulp/rulp.rb', line 111

def solver(solver=nil)
  solver = solver || ENV["SOLVER"] || "Scip"
  solver = solver[0].upcase + solver[1..-1].downcase
end

#to_s ⇒ Object 



196
197
198
199
200
201
202
203
204
205
206
 
# File 'lib/rulp/rulp.rb', line 196

def to_s
  %Q(
#{'  '*0}#{@objective}
#{'  '*0} obj: #{@objective_expression}
#{'  '*0}Subject to
#{'  '*0}#{constraints}
#{'  '*0}Bounds
#{'  '*0}#{bounds}#{integers}#{bits}
#{'  '*0}End
  )
end

#write(output) ⇒ Object 



186
187
188
189
190
191
192
193
194
 
# File 'lib/rulp/rulp.rb', line 186

def write(output)
  output.puts "#{@objective}"
  output.puts " obj: #{@objective_expression}"
  output.puts "Subject to"
  output.puts "#{constraints}"
  output.puts "Bounds"
  output.puts "#{bounds}#{integers}#{bits}"
  output.puts "End"
end