RsBundle  Diff

use log::{debug, warn};
use num_traits::Float;
use thiserror::Error;
use threadpool::ThreadPool;

use std::f64::INFINITY;
use std::fs::File;
use std::io::Read;
use std::io::{BufRead, BufReader, Read};
use std::result;
use std::sync::{Arc, RwLock};

/// An error in the mmcf file format.
#[derive(Debug, Error)]
#[non_exhaustive]
pub enum MMCFReadError {

    pub fn read_mnetgen_with_solver<S>(basename: &str) -> std::result::Result<MMCFProblem, MMCFReadError>
    where
        S: Solver + 'static,
    {
        use MMCFReadError::*;

        let mut buffer = String::new();
        {
            let mut f = File::open(&format!("{}.nod", basename))?;
            f.read_to_string(&mut buffer)?;
        }

        let ncom;
        let nnodes;
        let narcs;
        let ncaps;

        {
            let mut data = buffer.split_whitespace();
            ncom = data.next().ok_or(MissingNodField("ncom"))?.parse::<usize>()?;
            nnodes = data.next().ok_or(MissingNodField("nnodes"))?.parse::<usize>()?;
            narcs = data.next().ok_or(MissingNodField("narcs"))?.parse::<usize>()?;
            ncaps = data.next().ok_or(MissingNodField("ncaps"))?.parse::<usize>()?;
            let mut data = File::open(&format!("{}.nod", basename)).map(BufReader::new)?.lines();
            ncom = data.next().ok_or(MissingNodField("ncom"))??.parse::<usize>()?;
            nnodes = data.next().ok_or(MissingNodField("nnodes"))??.parse::<usize>()?;
            narcs = data.next().ok_or(MissingNodField("narcs"))??.parse::<usize>()?;
            ncaps = data.next().ok_or(MissingNodField("ncaps"))??.parse::<usize>()?;
            if data.next().is_some() {
                return Err(ExtraNodField);
            }
        }

        // read nodes
        let mut nets = Vec::with_capacity(ncom);
        for i in 0..ncom {
            nets.push(mcf::NetSpxSolver::new(i, nnodes)?)
        }
        {
            let mut f = File::open(&format!("{}.sup", basename))?;
        for line in File::open(&format!("{}.sup", basename)).map(BufReader::new)?.lines() {
            buffer.clear();
            f.read_to_string(&mut buffer)?;
        }
        for line in buffer.lines() {
            let line = line?;
            let mut data = line.split_whitespace();
            let node = data.next().ok_or(MissingSupField("node"))?.parse::<usize>()?;
            let com = data.next().ok_or(MissingSupField("com"))?.parse::<usize>()?;
            let supply = data.next().ok_or(MissingSupField("supply"))?.parse::<Real>()?;
            if data.next().is_some() {
                return Err(ExtraSupField);
            }

        // read arcs
        let mut arcmap = vec![vec![]; ncom];
        let mut cbase = vec![dvec![]; ncom];

        // lhs nonzeros
        let mut lhsidx = vec![vec![vec![]; ncom]; ncaps];
        {
            let mut f = File::open(&format!("{}.arc", basename))?;
        for line in File::open(&format!("{}.arc", basename)).map(BufReader::new)?.lines() {
            buffer.clear();
            f.read_to_string(&mut buffer)?;
        }
        for line in buffer.lines() {
            let line = line?;
            let mut data = line.split_whitespace();
            let arc = data.next().ok_or(MissingArcField("arc"))?.parse::<usize>()?;
            let src = data.next().ok_or(MissingArcField("src"))?.parse::<usize>()?;
            let snk = data.next().ok_or(MissingArcField("snk"))?.parse::<usize>()?;
            let com = data.next().ok_or(MissingArcField("com"))?.parse::<usize>()?;
            let cost = data.next().ok_or(MissingArcField("cost"))?.parse::<Real>()?;
            let cap = data.next().ok_or(MissingArcField("cap"))?.parse::<Real>()?;

                                   // add to mutual capacity constraint
            if mt > 0 {
                lhsidx[(mt - 1) as usize][com].push(coeff);
            }
        }

        // read rhs of coupling constraints
        {
            let mut f = File::open(&format!("{}.mut", basename))?;
            buffer.clear();
            f.read_to_string(&mut buffer)?;
        }
        let mut rhs = dvec![0.0; ncaps];
        for line in File::open(&format!("{}.mut", basename)).map(BufReader::new)?.lines() {
        for line in buffer.lines() {
            let line = line?;
            let mut data = line.split_whitespace();
            let mt = data.next().ok_or(MissingMutField("mt"))?.parse::<usize>()?;
            let cap = data.next().ok_or(MissingMutField("cap"))?.parse::<Real>()?;
            if data.next().is_some() {
                return Err(ExtraMutField);
            }
            if mt < 1 || mt > ncaps {