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.



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

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)
  @lp_file = nil
  @constraints = []
end

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(method_name, *args) ⇒ Object 



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

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.



89
90
91
 
# File 'lib/rulp/rulp.rb', line 89

def lp_file
  @lp_file
end

#result ⇒ Object

Returns the value of attribute result.



89
90
91
 
# File 'lib/rulp/rulp.rb', line 89

def result
  @result
end

#trace ⇒ Object

Returns the value of attribute trace.



89
90
91
 
# File 'lib/rulp/rulp.rb', line 89

def trace
  @trace
end

Instance Method Details

#[](*constraints) ⇒ Object 



100
101
102
103
104
105
106
107
108
109
 
# File 'lib/rulp/rulp.rb', line 100

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 



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

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

#bounds ⇒ Object 



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

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

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



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

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

#constraints ⇒ Object 



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

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 



152
153
154
 
# File 'lib/rulp/rulp.rb', line 152

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

#inspect ⇒ Object 



204
205
206
 
# File 'lib/rulp/rulp.rb', line 204

def inspect
  to_s
end

#integers ⇒ Object 



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

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 



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

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

#solve(opts = {}) ⇒ Object 



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

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

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



160
161
162
163
164
165
166
167
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
 
# File 'lib/rulp/rulp.rb', line 160

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: solution infeasible" if IO.read(solver.outfile).downcase.include?("infeasible")
    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 



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

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

#to_s ⇒ Object 



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

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 



208
209
210
211
212
213
214
215
216
 
# File 'lib/rulp/rulp.rb', line 208

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