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.



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

def initialize(objective, objective_expression)
  @variables = Set.new
  @objective = objective
  @lp_file = nil
  @constraints = []
  self.objective = objective_expression
end

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(method_name, *args) ⇒ Object 



123
124
125
 
# File 'lib/rulp/rulp.rb', line 123

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

Instance Attribute Details

#lp_file ⇒ Object

Returns the value of attribute lp_file.



93
94
95
 
# File 'lib/rulp/rulp.rb', line 93

def lp_file
  @lp_file
end

#result ⇒ Object

Returns the value of attribute result.



93
94
95
 
# File 'lib/rulp/rulp.rb', line 93

def result
  @result
end

#trace ⇒ Object

Returns the value of attribute trace.



93
94
95
 
# File 'lib/rulp/rulp.rb', line 93

def trace
  @trace
end

Instance Method Details

#[](*constraints) ⇒ Object 



108
109
110
111
112
113
114
115
116
117
 
# File 'lib/rulp/rulp.rb', line 108

def [](*constraints)
  Rulp.log(Logger::INFO, "Got constraints")
  constraints = constraints.flatten.select{|x| x.kind_of?(Constraint)}
  Rulp.log(Logger::INFO, "Flattened constraints")
  @constraints.concat(constraints)
  Rulp.log(Logger::INFO, "Joint constraints")
  @variables.merge(constraints.flat_map(&:variables).uniq)
  Rulp.log(Logger::INFO, "Extracted variables")
  self
end

#bits ⇒ Object 



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

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

#bounds ⇒ Object 



153
154
155
156
157
158
 
# File 'lib/rulp/rulp.rb', line 153

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

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



132
133
134
 
# File 'lib/rulp/rulp.rb', line 132

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

#constraints ⇒ Object 



136
137
138
139
140
141
 
# File 'lib/rulp/rulp.rb', line 136

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

#get_output_filename ⇒ Object 



160
161
162
 
# File 'lib/rulp/rulp.rb', line 160

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

#inspect ⇒ Object 



215
216
217
 
# File 'lib/rulp/rulp.rb', line 215

def inspect
  to_s
end

#integers ⇒ Object 



143
144
145
146
 
# File 'lib/rulp/rulp.rb', line 143

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

#objective=(objective_expression) ⇒ Object 



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

def objective=(objective_expression)
  @objective_expression = objective_expression.kind_of?(LV) ? 1 * objective_expression : objective_expression
  @variables.merge(@objective_expression.variables)
end

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



164
165
166
 
# File 'lib/rulp/rulp.rb', line 164

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

#solve(opts = {}) ⇒ Object 



119
120
121
 
# File 'lib/rulp/rulp.rb', line 119

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

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



168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
 
# File 'lib/rulp/rulp.rb', line 168

def solve_with(type, options={})

  filename = get_output_filename
  solver = SOLVERS[type].new(filename, options)

  Rulp.log(Logger::INFO, "Writing problem")
  IO.write(filename, self)

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

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

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

  Rulp.log(Logger::DEBUG, "Solver took #{time}")

  Rulp.log(Logger::INFO, "Parsing result")

  unless solver.outfile
    raise "No output file detected. Solver failed"
    return
  end

  solver.store_results(@variables)

  if solver.unsuccessful
    raise "Solve failed: #{solver.model_status}" if solver.model_status

    outfile_contents = IO.read(solver.outfile)
    raise "Solve failed: solution infeasible" if outfile_contents.downcase.include?("infeasible") || outfile_contents.strip.length.zero?
    raise "Solve failed: all units undefined"
  end

  if options[:remove_lp_file]
    solver.remove_lp_file
  else
    self.lp_file = solver.filename
  end
  solver.remove_sol_file if options[:remove_sol_file]

  self.result = @objective_expression.evaluate

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

#solver(solver = nil) ⇒ Object 



127
128
129
130
 
# File 'lib/rulp/rulp.rb', line 127

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

#to_s ⇒ Object 



229
230
231
232
233
234
235
236
237
238
239
 
# File 'lib/rulp/rulp.rb', line 229

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 



219
220
221
222
223
224
225
226
227
 
# File 'lib/rulp/rulp.rb', line 219

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