neco-monomial 0.1.2

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

use neco_bigint::ReducedRational;
use neco_bigint::Sign;

use crate::error::{reserve_elements_for, AllocationTarget, MonomialErrorKind};
use crate::prime::ProvenPrime;

pub struct RadicalBasis {
    factors: Vec<(ProvenPrime, ReducedRational)>,
}

impl fmt::Debug for RadicalBasis {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        formatter
            .debug_struct("RadicalBasis")
            .field("factor_count", &self.factors.len())
            .finish()
    }
}

impl PartialEq for RadicalBasis {
    fn eq(&self, other: &Self) -> bool {
        compare_basis(self, other) == Ordering::Equal
    }
}

impl Eq for RadicalBasis {}

impl Ord for RadicalBasis {
    fn cmp(&self, other: &Self) -> Ordering {
        compare_basis(self, other)
    }
}

impl PartialOrd for RadicalBasis {
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        Some(self.cmp(other))
    }
}

fn compare_basis(left: &RadicalBasis, right: &RadicalBasis) -> Ordering {
    for ((left_prime, left_exponent), (right_prime, right_exponent)) in
        left.factors.iter().zip(&right.factors)
    {
        let ordering = left_prime
            .value_internal()
            .cmp(right_prime.value_internal())
            .then_with(|| left_exponent.cmp(right_exponent));
        if ordering != Ordering::Equal {
            return ordering;
        }
    }
    left.factors.len().cmp(&right.factors.len())
}

impl RadicalBasis {
    pub fn one() -> Self {
        Self::one_internal()
    }

    pub(crate) fn one_internal() -> Self {
        Self {
            factors: Vec::new(),
        }
    }

    pub fn factors(&self) -> &[(ProvenPrime, ReducedRational)] {
        &self.factors
    }

    pub fn try_clone(&self) -> Result<Self, MonomialErrorKind> {
        let mut factors = Vec::new();
        reserve_elements_for(
            &mut factors,
            self.factors.len(),
            AllocationTarget::RadicalBasis,
        )?;
        for (prime, exponent) in &self.factors {
            factors.push((prime.try_clone_internal()?, exponent.try_clone()?));
        }
        Ok(Self { factors })
    }

    pub fn try_from_sorted_factors(
        factors: Vec<(ProvenPrime, ReducedRational)>,
    ) -> Result<Self, MonomialErrorKind> {
        let valid_exponents = factors.iter().all(|(_, exponent)| {
            exponent.numerator().sign() == Sign::Positive
                && exponent.numerator().magnitude() < exponent.denominator()
        });
        let sorted_primes = factors
            .windows(2)
            .all(|pair| pair[0].0.value_internal() < pair[1].0.value_internal());
        if !valid_exponents || !sorted_primes {
            return Err(MonomialErrorKind::InvalidRadicalBasis);
        }
        Ok(Self { factors })
    }
}