claimr 0.1.0

Claimr — a constraint logic programming language, Prolog III inspired, parsed with a rustemo-generated LR parser.
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
80
81
82
83
84
85

// SPDX-License-Identifier: Apache-2.0

//! δ-rationals: values `c + kδ` for an infinitesimal positive δ, so that a
//! strict bound `x < c` is the non-strict bound `x <= c - δ`. Ordering is
//! lexicographic on `(c, k)`.

use std::fmt;
use std::ops::{Add, Mul, Neg, Sub};

use crate::Number;

/// `c + k·δ`.
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct Delta {
    pub c: Number,
    pub k: Number,
}

impl Delta {
    pub fn new(c: Number, k: Number) -> Self {
        Delta { c, k }
    }

    /// A plain rational.
    pub fn exact(c: Number) -> Self {
        Delta { c, k: Number::zero() }
    }

    pub fn zero() -> Self {
        Delta::exact(Number::zero())
    }

    /// True if there is no infinitesimal part.
    pub fn is_exact(&self) -> bool {
        self.k.is_zero()
    }

    /// Scale by a rational.
    pub fn scale(&self, a: &Number) -> Delta {
        Delta { c: &self.c * a, k: &self.k * a }
    }
}

impl From<Number> for Delta {
    fn from(c: Number) -> Self {
        Delta::exact(c)
    }
}

impl<'a> Add<&'a Delta> for &'a Delta {
    type Output = Delta;
    fn add(self, rhs: &Delta) -> Delta {
        Delta { c: &self.c + &rhs.c, k: &self.k + &rhs.k }
    }
}
impl<'a> Sub<&'a Delta> for &'a Delta {
    type Output = Delta;
    fn sub(self, rhs: &Delta) -> Delta {
        Delta { c: &self.c - &rhs.c, k: &self.k - &rhs.k }
    }
}
impl<'a> Mul<&'a Number> for &'a Delta {
    type Output = Delta;
    fn mul(self, rhs: &Number) -> Delta {
        self.scale(rhs)
    }
}
impl Neg for &Delta {
    type Output = Delta;
    fn neg(self) -> Delta {
        Delta { c: -&self.c, k: -&self.k }
    }
}

impl fmt::Display for Delta {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        if self.k.is_zero() {
            write!(f, "{}", self.c)
        } else if self.k.is_positive() {
            write!(f, "{} + {}δ", self.c, self.k)
        } else {
            write!(f, "{} - {}δ", self.c, self.k.abs())
        }
    }
}