simplex-trace 0.2.0

Exact-arithmetic simplex (primal, Big-M, two-phase, dual) that records every tableau and pivot as data, with sensitivity analysis.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

//! Serde helpers that write rationals as exact strings (`"3"`, `"-1/2"`), never as floats.
//!
//! Used through `#[serde(with = "crate::serde_rational::...")]` on fields.

use serde::{Deserialize, Deserializer, Serializer};

use crate::num::Rational;

fn parse<E: serde::de::Error>(s: &str) -> Result<Rational, E> {
    s.trim()
        .parse::<Rational>()
        .map_err(|e| E::custom(format!("invalid rational {s:?}: {e}")))
}

pub(crate) mod one {
    use super::*;

    pub(crate) fn serialize<S: Serializer>(v: &Rational, s: S) -> Result<S::Ok, S::Error> {
        s.collect_str(v)
    }

    pub(crate) fn deserialize<'de, D: Deserializer<'de>>(d: D) -> Result<Rational, D::Error> {
        parse(&String::deserialize(d)?)
    }
}

pub(crate) mod option {
    use super::*;

    pub(crate) fn serialize<S: Serializer>(v: &Option<Rational>, s: S) -> Result<S::Ok, S::Error> {
        match v {
            Some(v) => s.collect_str(v),
            None => s.serialize_none(),
        }
    }

    pub(crate) fn deserialize<'de, D: Deserializer<'de>>(
        d: D,
    ) -> Result<Option<Rational>, D::Error> {
        Option::<String>::deserialize(d)?
            .map(|s| parse(&s))
            .transpose()
    }
}

pub(crate) mod vec {
    use super::*;

    pub(crate) fn serialize<S: Serializer>(v: &[Rational], s: S) -> Result<S::Ok, S::Error> {
        s.collect_seq(v.iter().map(ToString::to_string))
    }

    pub(crate) fn deserialize<'de, D: Deserializer<'de>>(d: D) -> Result<Vec<Rational>, D::Error> {
        Vec::<String>::deserialize(d)?
            .iter()
            .map(|s| parse(s))
            .collect()
    }
}

pub(crate) mod vec_vec {
    use super::*;

    pub(crate) fn serialize<S: Serializer>(v: &[Vec<Rational>], s: S) -> Result<S::Ok, S::Error> {
        s.collect_seq(
            v.iter()
                .map(|row| row.iter().map(ToString::to_string).collect::<Vec<_>>()),
        )
    }

    pub(crate) fn deserialize<'de, D: Deserializer<'de>>(
        d: D,
    ) -> Result<Vec<Vec<Rational>>, D::Error> {
        Vec::<Vec<String>>::deserialize(d)?
            .iter()
            .map(|row| row.iter().map(|s| parse(s)).collect())
            .collect()
    }
}