neco-monomial 0.1.2

prime-exponent monomials for exact rational radicals
Documentation
use alloc::vec::Vec;
use core::fmt;

use neco_bigint::{BigUint, RawRational, Sign};

use crate::error::{
    reserve_elements_for, AllocationTarget, MonomialErrorKind, NormalizationErrors,
};
use crate::monomial::Monomial;

#[derive(Debug, Eq, PartialEq)]
pub struct RawPower {
    base: BigUint,
    exponent: RawRational,
}

impl RawPower {
    pub fn new(base: BigUint, exponent: RawRational) -> Self {
        Self { base, exponent }
    }

    pub fn base(&self) -> &BigUint {
        &self.base
    }

    pub(crate) fn base_internal(&self) -> &BigUint {
        &self.base
    }

    pub fn exponent(&self) -> &RawRational {
        &self.exponent
    }

    pub(crate) fn exponent_internal(&self) -> &RawRational {
        &self.exponent
    }

    pub fn try_clone(&self) -> Result<Self, MonomialErrorKind> {
        self.try_clone_internal()
    }

    pub(crate) fn try_clone_internal(&self) -> Result<Self, MonomialErrorKind> {
        Ok(Self {
            base: self.base.try_clone()?,
            exponent: self.exponent.try_clone()?,
        })
    }
}

pub struct RawMonomial {
    zero: bool,
    sign: Sign,
    powers: Vec<RawPower>,
}

impl fmt::Debug for RawMonomial {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        formatter
            .debug_struct("RawMonomial")
            .field("zero", &self.zero)
            .field("sign", &self.sign)
            .field("power_count", &self.powers.len())
            .finish()
    }
}

impl PartialEq for RawMonomial {
    fn eq(&self, other: &Self) -> bool {
        self.zero == other.zero
            && self.sign == other.sign
            && self.powers.len() == other.powers.len()
            && self
                .powers
                .iter()
                .zip(&other.powers)
                .all(|(left, right)| left.base == right.base && left.exponent == right.exponent)
    }
}

impl Eq for RawMonomial {}

impl RawMonomial {
    pub fn zero() -> Self {
        Self::zero_internal()
    }

    pub(crate) fn zero_internal() -> Self {
        Self {
            zero: true,
            sign: Sign::Zero,
            powers: Vec::new(),
        }
    }

    pub fn positive(powers: Vec<RawPower>) -> Self {
        Self {
            zero: false,
            sign: Sign::Positive,
            powers,
        }
    }

    pub fn negative(powers: Vec<RawPower>) -> Self {
        Self {
            zero: false,
            sign: Sign::Negative,
            powers,
        }
    }

    pub fn is_zero(&self) -> bool {
        self.zero
    }

    pub(crate) fn is_zero_internal(&self) -> bool {
        self.zero
    }

    pub fn sign(&self) -> Sign {
        self.sign
    }

    pub(crate) fn sign_internal(&self) -> Sign {
        self.sign
    }

    pub fn powers(&self) -> &[RawPower] {
        &self.powers
    }

    pub(crate) fn powers_internal(&self) -> &[RawPower] {
        &self.powers
    }

    pub fn try_clone(&self) -> Result<Self, MonomialErrorKind> {
        self.try_clone_internal()
    }

    pub(crate) fn try_clone_internal(&self) -> Result<Self, MonomialErrorKind> {
        if self.zero {
            return Ok(Self::zero_internal());
        }
        let total = self.powers.len();
        let mut powers = Vec::new();
        reserve_elements_for(&mut powers, total, AllocationTarget::RawPowerClone)?;
        for power in &self.powers {
            powers.push(power.try_clone_internal()?);
        }
        Ok(Self {
            zero: false,
            sign: self.sign,
            powers,
        })
    }

    pub fn normalize(&self) -> Result<Monomial, NormalizationErrors<MonomialErrorKind>> {
        crate::monomial::normalize_raw(self)
    }
}