rsl-polynomials 0.1.3

A re-write of GSL's Polynomials Routines in Rust.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

use crate::{PolyError, Polynomial};
use is_close::is_close;
use num::complex::Complex64;
use std::f64::EPSILON;

// GSL's tests use this tolerance
const EPS: f64 = 100.0 * EPSILON;

#[test]
/// Source: gsl/poly/test.c
fn test_gsl_eval1() {
    let p = Polynomial::build(&vec![1.0, 0.5, 0.3]).unwrap();
    let x = 0.5;

    assert!(is_close!(
        p.eval(x),
        1.0 + 0.5 * x + 0.3 * x * x,
        rel_tol = EPS
    ));
}

#[test]
/// Source: gsl/poly/test.c
fn test_gsl_eval2() {
    let p = Polynomial::build(&vec![
        1.0, -1.0, 1.0, -1.0, 1.0, -1.0, 1.0, -1.0, 1.0, -1.0, 1.0,
    ])
    .unwrap();
    let x = 1.0;

    assert!(is_close!(p.eval(x), 1.0, rel_tol = EPS));
}

#[test]
/// Source: gsl/poly/test.c
fn test_gsl_eval_deriv1() {
    let p = Polynomial::build(&vec![1.0, -2.0, 3.0, -4.0, 5.0, -6.0]).unwrap();
    let x = -0.5;

    let derivs = p.eval_derivs(x, 6);

    assert!(is_close!(derivs[0], 3.75, rel_tol = EPS));
    assert!(is_close!(derivs[1], -12.375, rel_tol = EPS));
    assert!(is_close!(derivs[2], 48.0, rel_tol = EPS));
    assert!(is_close!(derivs[3], -174.0, rel_tol = EPS));
    assert!(is_close!(derivs[4], 480.0, rel_tol = EPS));
    assert!(is_close!(derivs[5], -720.0, rel_tol = EPS));
}

#[test]
fn test_build_invalid_coefficients() {
    let poly1 = Polynomial::build(&vec![1.0, 2.0, std::f64::NAN]);
    let poly2 = Polynomial::build(&vec![1.0, 2.0, std::f64::INFINITY]);

    assert!(matches!(poly1.unwrap_err(), PolyError::InvalidCoefficients));
    assert!(matches!(poly2.unwrap_err(), PolyError::InvalidCoefficients));
}

// ===============================================================================================

#[test]
/// Source: gsl/poly/test.c
fn test_gsl_complex_eval1() {
    let coef = Complex64::new(0.3, 0.0);
    let p = Polynomial::build(&vec![coef]).unwrap();
    let x = Complex64::new(0.75, 1.2);
    let y = p.eval(x);

    assert!(is_close!(y.re, 0.3, rel_tol = EPS));
    assert!(is_close!(y.im, 0.0, rel_tol = EPS));
}

#[test]
/// Source: gsl/poly/test.c
fn test_gsl_complex_eval2() {
    let coefs = &vec![
        Complex64::new(2.1, 0.0),
        Complex64::new(-1.34, 0.0),
        Complex64::new(0.76, 0.0),
        Complex64::new(0.45, 0.0),
    ];
    let p = Polynomial::build(coefs).unwrap();
    let x = Complex64::new(0.49, 0.95);
    let y = p.eval(x);

    assert!(is_close!(y.re, 0.3959143, rel_tol = EPS));
    assert!(is_close!(y.im, -0.6433305, rel_tol = EPS));
}

#[test]
/// Source: gsl/poly/test.c
fn test_gsl_complex_eval3() {
    let coef = &vec![Complex64::new(0.674, -1.423)];
    let p = Polynomial::build(coef).unwrap();
    let x = Complex64::new(-1.44, 9.55);
    let y = p.eval(x);

    assert!(is_close!(y.re, 0.674, rel_tol = EPS));
    assert!(is_close!(y.im, -1.423, rel_tol = EPS));
}

#[test]
/// Source: gsl/poly/test.c
fn test_gsl_complex_eval4() {
    let coefs = &vec![
        Complex64::new(-2.31, 0.44),
        Complex64::new(4.21, -3.19),
        Complex64::new(0.93, 1.04),
        Complex64::new(-0.42, 0.68),
    ];
    let p = Polynomial::build(coefs).unwrap();
    let x = Complex64::new(0.49, 0.95);
    let y = p.eval(x);

    assert!(is_close!(y.re, 1.82462012, rel_tol = EPS));
    assert!(is_close!(y.im, 2.30389412, rel_tol = EPS));
}