Skip to main content

neco_jet/
lib.rs

1#![cfg_attr(not(feature = "std"), no_std)]
2#![forbid(unsafe_code)]
3#![doc = include_str!("../README.md")]
4
5extern crate alloc;
6
7use alloc::vec::Vec;
8
9use neco_algnum::{AlgnumError, RealAlgebraic};
10
11pub use neco_polynomial::DerivativeOrder;
12
13pub const MAX_JET_ORDER: usize = 64;
14
15#[derive(Debug, Eq, PartialEq)]
16pub struct Jet {
17    value: RealAlgebraic,
18    derivatives: Vec<RealAlgebraic>,
19}
20
21impl Jet {
22    pub fn from_value_and_derivatives(
23        value: RealAlgebraic,
24        derivatives: Vec<RealAlgebraic>,
25    ) -> Result<Self, JetFailure> {
26        if derivatives.is_empty() {
27            return Err(JetFailure::EmptyDerivatives);
28        }
29        if derivatives.len() > MAX_JET_ORDER + 1 {
30            return Err(JetFailure::OrderLimitExceeded {
31                requested: derivatives.len() - 1,
32                maximum: MAX_JET_ORDER,
33            });
34        }
35        if derivatives[0] != value {
36            return Err(JetFailure::ValueDerivativeMismatch);
37        }
38        Ok(Self { value, derivatives })
39    }
40
41    pub fn value(&self) -> &RealAlgebraic {
42        &self.value
43    }
44
45    pub fn order(&self) -> DerivativeOrder {
46        DerivativeOrder::new(self.derivatives.len() - 1)
47    }
48
49    pub fn derivative(&self, order: DerivativeOrder) -> Result<&RealAlgebraic, JetFailure> {
50        self.derivatives
51            .get(order.get())
52            .ok_or(JetFailure::OrderOutOfRange)
53    }
54
55    pub fn derivatives(&self) -> &[RealAlgebraic] {
56        &self.derivatives
57    }
58
59    pub fn shift(&self) -> Result<Self, JetFailure> {
60        if self.derivatives.len() <= 1 {
61            return Err(JetFailure::OrderOutOfRange);
62        }
63        let mut shifted = Vec::new();
64        for derivative in self.derivatives.iter().skip(1) {
65            shifted.push(derivative.try_clone()?);
66        }
67        let value = shifted[0].try_clone()?;
68        Ok(Self {
69            value,
70            derivatives: shifted,
71        })
72    }
73}
74
75#[derive(Debug, Eq, PartialEq)]
76pub enum JetFailure {
77    EmptyDerivatives,
78    ValueDerivativeMismatch,
79    OrderOutOfRange,
80    OrderLimitExceeded { requested: usize, maximum: usize },
81    Algebra(AlgnumError),
82}
83
84impl From<AlgnumError> for JetFailure {
85    fn from(error: AlgnumError) -> Self {
86        Self::Algebra(error)
87    }
88}