Struct Linear 

struct Linear<T>
where
    T: Signed,
{
    a: T,
    b: T,
}

ax + b

Fields

a: T

b: T

Implementations

impl<T> Linear<T>

where T: Signed,

fn new(a: T, b: T) -> Self

Examples found in repository

crates/competitive/src/math/linear_diophantine.rs (line 145)

pub fn solve_linear_diophantine<T>(a: T, b: T, c: T) -> Option<LinearDiophantineSolution<T>>
where
    T: Signed,
{
    assert!(!a.is_zero(), "a must be non-zero");
    assert!(!b.is_zero(), "b must be non-zero");
    let ExtendedGcd { g, x: x0, y: y0 } = a.extgcd(b);
    let g = g.signed();
    let a = a / g;
    let b = b / g;
    if c.is_zero() {
        return Some(LinearDiophantineSolution {
            x: Linear::new(b, T::zero()),
            y: Linear::new(-a, T::zero()),
            k_range: (T::minimum(), T::maximum()),
        });
    }
    if !(c % g).is_zero() {
        return None;
    }
    let c = c / g;
    let x = Linear::new(b, x0 * c);
    let y = Linear::new(-a, y0 * c);
    Some(LinearDiophantineSolution {
        x,
        y,
        k_range: (T::minimum(), T::maximum()),
    })
}

fn eval(&self, x: T) -> T

Examples found in repository

crates/competitive/src/math/linear_diophantine.rs (line 73)

    pub fn eval(&self, k: T) -> (T, T) {
        (self.x.eval(k), self.y.eval(k))
    }

Trait Implementations

impl<T> Clone for Linear<T>

where T: Signed + Clone,

fn clone(&self) -> Linear<T>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T> Debug for Linear<T>

where T: Signed + Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T> Copy for Linear<T>

where T: Signed + Copy,