265 lines
6.9 KiB
Rust
265 lines
6.9 KiB
Rust
use std::fmt::{self, Display, Formatter};
|
|
use std::ops::{Add, AddAssign, Mul, MulAssign, Neg, Sub, SubAssign};
|
|
|
|
/// A struct that represents a polynomial with a maximum degree of `N-1`.
|
|
///
|
|
/// It provides basic mathematical operations for polynomials like addition, multiplication, differentiation, integration, etc.
|
|
#[derive(Copy, Clone, Debug, PartialEq)]
|
|
pub struct Polynomial<const N: usize> {
|
|
coefficients: [f64; N],
|
|
}
|
|
|
|
impl<const N: usize> Polynomial<N> {
|
|
/// Create a new polynomial from the coefficients given in the array.
|
|
///
|
|
/// The coefficient for nth degree is at the nth index in array. Therefore the order of coefficients are reversed than the usual order for writing polynomials mathematically.
|
|
pub fn new(coefficients: [f64; N]) -> Polynomial<N> {
|
|
Polynomial { coefficients }
|
|
}
|
|
|
|
/// Create a polynomial where all its coefficients are zero.
|
|
pub fn zero() -> Polynomial<N> {
|
|
Polynomial { coefficients: [0.; N] }
|
|
}
|
|
|
|
/// Return an immutable reference to the coefficients.
|
|
///
|
|
/// The coefficient for nth degree is at the nth index in array. Therefore the order of coefficients are reversed than the usual order for writing polynomials mathematically.
|
|
pub fn coefficients(&self) -> &[f64; N] {
|
|
&self.coefficients
|
|
}
|
|
|
|
/// Return a mutable reference to the coefficients.
|
|
///
|
|
/// The coefficient for nth degree is at the nth index in array. Therefore the order of coefficients are reversed than the usual order for writing polynomials mathematically.
|
|
pub fn coefficients_mut(&mut self) -> &mut [f64; N] {
|
|
&mut self.coefficients
|
|
}
|
|
|
|
/// Evaluate the polynomial at `value`.
|
|
pub fn eval(&self, value: f64) -> f64 {
|
|
self.coefficients.iter().rev().copied().reduce(|acc, x| acc * value + x).unwrap()
|
|
}
|
|
|
|
/// Return the same polynomial but with a different maximum degree of `M-1`.\
|
|
///
|
|
/// Returns `None` if the polynomial cannot fit in the specified size.
|
|
pub fn as_size<const M: usize>(&self) -> Option<Polynomial<M>> {
|
|
let mut coefficients = [0.; M];
|
|
|
|
if M >= N {
|
|
coefficients[..N].copy_from_slice(&self.coefficients);
|
|
} else if self.coefficients.iter().rev().take(N - M).all(|&x| x == 0.) {
|
|
coefficients.copy_from_slice(&self.coefficients[..M])
|
|
} else {
|
|
return None;
|
|
}
|
|
|
|
Some(Polynomial { coefficients })
|
|
}
|
|
|
|
/// Computes the derivative in place.
|
|
pub fn derivative_mut(&mut self) {
|
|
self.coefficients.iter_mut().enumerate().for_each(|(index, x)| *x *= index as f64);
|
|
self.coefficients.rotate_left(1);
|
|
}
|
|
|
|
/// Computes the antiderivative at `C = 0` in place.
|
|
///
|
|
/// Returns `None` if the polynomial is not big enough to accommodate the extra degree.
|
|
pub fn antiderivative_mut(&mut self) -> Option<()> {
|
|
if self.coefficients[N - 1] != 0. {
|
|
return None;
|
|
}
|
|
self.coefficients.rotate_right(1);
|
|
self.coefficients.iter_mut().enumerate().skip(1).for_each(|(index, x)| *x /= index as f64);
|
|
Some(())
|
|
}
|
|
|
|
/// Computes the polynomial's derivative.
|
|
pub fn derivative(&self) -> Polynomial<N> {
|
|
let mut ans = *self;
|
|
ans.derivative_mut();
|
|
ans
|
|
}
|
|
|
|
/// Computes the antiderivative at `C = 0`.
|
|
///
|
|
/// Returns `None` if the polynomial is not big enough to accommodate the extra degree.
|
|
pub fn antiderivative(&self) -> Option<Polynomial<N>> {
|
|
let mut ans = *self;
|
|
ans.antiderivative_mut()?;
|
|
Some(ans)
|
|
}
|
|
}
|
|
|
|
impl<const N: usize> Default for Polynomial<N> {
|
|
fn default() -> Self {
|
|
Self::zero()
|
|
}
|
|
}
|
|
|
|
impl<const N: usize> Display for Polynomial<N> {
|
|
fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
|
|
let mut first = true;
|
|
for (index, coefficient) in self.coefficients.iter().enumerate().rev().filter(|(_, &coefficient)| coefficient != 0.) {
|
|
if first {
|
|
first = false;
|
|
} else {
|
|
f.write_str(" + ")?
|
|
}
|
|
|
|
coefficient.fmt(f)?;
|
|
if index == 0 {
|
|
continue;
|
|
}
|
|
f.write_str("x")?;
|
|
if index == 1 {
|
|
continue;
|
|
}
|
|
f.write_str("^")?;
|
|
index.fmt(f)?;
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl<const N: usize> AddAssign<&Polynomial<N>> for Polynomial<N> {
|
|
fn add_assign(&mut self, rhs: &Polynomial<N>) {
|
|
self.coefficients.iter_mut().zip(rhs.coefficients.iter()).for_each(|(a, b)| *a += b);
|
|
}
|
|
}
|
|
|
|
impl<const N: usize> Add for &Polynomial<N> {
|
|
type Output = Polynomial<N>;
|
|
|
|
fn add(self, other: &Polynomial<N>) -> Polynomial<N> {
|
|
let mut output = *self;
|
|
output += other;
|
|
output
|
|
}
|
|
}
|
|
|
|
impl<const N: usize> Neg for &Polynomial<N> {
|
|
type Output = Polynomial<N>;
|
|
|
|
fn neg(self) -> Polynomial<N> {
|
|
let mut output = *self;
|
|
output.coefficients.iter_mut().for_each(|x| *x = -*x);
|
|
output
|
|
}
|
|
}
|
|
|
|
impl<const N: usize> Neg for Polynomial<N> {
|
|
type Output = Polynomial<N>;
|
|
|
|
fn neg(mut self) -> Polynomial<N> {
|
|
self.coefficients.iter_mut().for_each(|x| *x = -*x);
|
|
self
|
|
}
|
|
}
|
|
|
|
impl<const N: usize> SubAssign<&Polynomial<N>> for Polynomial<N> {
|
|
fn sub_assign(&mut self, rhs: &Polynomial<N>) {
|
|
self.coefficients.iter_mut().zip(rhs.coefficients.iter()).for_each(|(a, b)| *a -= b);
|
|
}
|
|
}
|
|
|
|
impl<const N: usize> Sub for &Polynomial<N> {
|
|
type Output = Polynomial<N>;
|
|
|
|
fn sub(self, other: &Polynomial<N>) -> Polynomial<N> {
|
|
let mut output = *self;
|
|
output -= other;
|
|
output
|
|
}
|
|
}
|
|
|
|
impl<const N: usize> MulAssign<&Polynomial<N>> for Polynomial<N> {
|
|
fn mul_assign(&mut self, rhs: &Polynomial<N>) {
|
|
for i in (0..N).rev() {
|
|
self.coefficients[i] = self.coefficients[i] * rhs.coefficients[0];
|
|
for j in 0..i {
|
|
self.coefficients[i] += self.coefficients[j] * rhs.coefficients[i - j];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<const N: usize> Mul for &Polynomial<N> {
|
|
type Output = Polynomial<N>;
|
|
|
|
fn mul(self, other: &Polynomial<N>) -> Polynomial<N> {
|
|
let mut output = *self;
|
|
output *= other;
|
|
output
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod test {
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn evaluation() {
|
|
let p = Polynomial::new([1., 2., 3.]);
|
|
|
|
assert_eq!(p.eval(1.), 6.);
|
|
assert_eq!(p.eval(2.), 17.);
|
|
}
|
|
|
|
#[test]
|
|
fn size_change() {
|
|
let p1 = Polynomial::new([1., 2., 3.]);
|
|
let p2 = Polynomial::new([1., 2., 3., 0.]);
|
|
|
|
assert_eq!(p1.as_size(), Some(p2));
|
|
assert_eq!(p2.as_size(), Some(p1));
|
|
|
|
assert_eq!(p2.as_size::<2>(), None);
|
|
}
|
|
|
|
#[test]
|
|
fn addition_and_subtaction() {
|
|
let p1 = Polynomial::new([1., 2., 3.]);
|
|
let p2 = Polynomial::new([4., 5., 6.]);
|
|
|
|
let addition = Polynomial::new([5., 7., 9.]);
|
|
let subtraction = Polynomial::new([-3., -3., -3.]);
|
|
|
|
assert_eq!(&p1 + &p2, addition);
|
|
assert_eq!(&p1 - &p2, subtraction);
|
|
}
|
|
|
|
#[test]
|
|
fn multiplication() {
|
|
let p1 = Polynomial::new([1., 2., 3.]).as_size().unwrap();
|
|
let p2 = Polynomial::new([4., 5., 6.]).as_size().unwrap();
|
|
|
|
let multiplication = Polynomial::new([4., 13., 28., 27., 18.]);
|
|
|
|
assert_eq!(&p1 * &p2, multiplication);
|
|
}
|
|
|
|
#[test]
|
|
fn derivative_and_antiderivative() {
|
|
let mut p = Polynomial::new([1., 2., 3.]);
|
|
let p_deriv = Polynomial::new([2., 6., 0.]);
|
|
|
|
assert_eq!(p.derivative(), p_deriv);
|
|
|
|
p.coefficients_mut()[0] = 0.;
|
|
assert_eq!(p_deriv.antiderivative().unwrap(), p);
|
|
|
|
assert_eq!(p.antiderivative(), None);
|
|
}
|
|
|
|
#[test]
|
|
fn display() {
|
|
let p = Polynomial::new([1., 2., 0., 3.]);
|
|
|
|
assert_eq!(format!("{:.2}", p), "3.00x^3 + 2.00x + 1.00");
|
|
}
|
|
}
|