| ︙ | | |
22
23
24
25
26
27
28
29
30
31
32
33
34
35
|
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
|
+
|
use std::f64::INFINITY;
use std::fmt;
use std::fs::File;
use std::io::Read;
use std::iter;
use std::result;
use std::sync::RwLock;
/// An error in the mmcf file format.
#[derive(Debug)]
pub enum MMCFReadError {
Format(String),
Solver(mcf::solver::Error),
Io(std::io::Error),
|
| ︙ | | |
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
|
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
|
-
+
|
cbase: DVector,
c: DVector,
}
pub struct MMCFProblem {
pub multimodel: bool,
subs: Vec<Subproblem>,
subs: Vec<RwLock<Subproblem>>,
nvars: usize,
}
impl Subproblem {
fn evaluate(&mut self, y: &[Real]) -> Result<(Real, DVector, DVector)> {
// compute costs
self.c.clear();
|
| ︙ | | |
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
|
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
|
+
+
-
+
-
-
-
-
-
+
-
+
|
.map(|(net, cbase, lhs, rhs)| Subproblem {
net,
cbase,
c: dvec![],
lhs,
rhs,
})
.map(RwLock::new)
.collect();
Ok(MMCFProblem {
multimodel: false,
subs: subproblems,
nvars: ncaps,
})
}
/// Compute costs for a primal solution.
pub fn get_primal_costs(&self, fidx: usize, primals: &[DVector]) -> Real {
let sub = self.subs[fidx].read().unwrap();
if self.multimodel {
primals[0]
primals[0].iter().enumerate().map(|(i, x)| x * sub.cbase[i]).sum()
.iter()
.enumerate()
.map(|(i, x)| x * self.subs[fidx].cbase[i])
.sum()
for (fidx, p) in primals.iter().enumerate() {
for p in primals {
for (i, x) in p.iter().enumerate() {
sum += x * self.subs[fidx].cbase[i];
sum += x * sub.cbase[i];
}
}
sum
}
}
/// Aggregate primal vectors.
|
| ︙ | | |
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
|
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
|
-
+
-
+
|
} else {
1
}
}
fn evaluate(&mut self, fidx: usize, y: &[Real], _nullstep_bound: Real, _relprec: Real) -> Result<Self::EvalResult> {
let (objective, subg, sol) = if self.multimodel {
let (objective, subg, sol) = self.subs[fidx].evaluate(y)?;
let (objective, subg, sol) = self.subs[fidx].write().unwrap().evaluate(y)?;
(objective, subg, vec![sol])
} else {
let mut objective = 0.0;
let mut subg = dvec![0.0; self.nvars];
let mut sols = Vec::with_capacity(self.subs.len());
for sub in &mut self.subs {
let (obj, sg, sol) = sub.evaluate(y)?;
let (obj, sg, sol) = sub.write().unwrap().evaluate(y)?;
objective += obj;
subg.add_scaled(1.0, &sg);
sols.push(sol);
}
(objective, subg, sols)
};
Ok(SimpleEvaluation {
|
| ︙ | | |