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.



89
90
91
92
93
94
95
 
# File 'lib/rulp/rulp.rb', line 89

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 



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

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

Instance Attribute Details

#result ⇒ Object

Returns the value of attribute result.



87
88
89
 
# File 'lib/rulp/rulp.rb', line 87

def result
  @result
end

#trace ⇒ Object

Returns the value of attribute trace.



87
88
89
 
# File 'lib/rulp/rulp.rb', line 87

def trace
  @trace
end

Instance Method Details

#[](*constraints) ⇒ Object 



97
98
99
100
101
102
103
104
105
106
 
# File 'lib/rulp/rulp.rb', line 97

def [](*constraints)
  Rulp.log(Logger::INFO, "Got constraints")
  constraints.flatten!
  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 



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

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

#bounds ⇒ Object 



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

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

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



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

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

#constraints ⇒ Object 



125
126
127
128
129
130
131
132
 
# File 'lib/rulp/rulp.rb', line 125

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 



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

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

#inspect ⇒ Object 



199
200
201
 
# File 'lib/rulp/rulp.rb', line 199

def inspect
  to_s
end

#integers ⇒ Object 



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

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 



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

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

#solve(opts = {}) ⇒ Object 



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

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

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



159
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
 
# File 'lib/rulp/rulp.rb', line 159

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

  solver.remove_lp_file  if options[:remove_lp_file]
  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 



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

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

#to_s ⇒ Object 



213
214
215
216
217
218
219
220
221
222
223
 
# File 'lib/rulp/rulp.rb', line 213

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 



203
204
205
206
207
208
209
210
211
 
# File 'lib/rulp/rulp.rb', line 203

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