Struct Float

Source

#[repr(transparent)]
pub struct Float<T>(pub T);

Expand description

Provides comprehensive floating-point operations for T, most of them const.

See also the ExtFloat and ExtFloatConst traits.

§Methods

TODO

§Features

It depends on having any _float_f[32|64] features enabled.

The wrapper leverages std or libm if enabled, otherwise implements fallbacks. It also favors std style for method’s names, but changes a few like minimum for min_nan and maximum for max_nan, for consistency.

If both the libm and std features are enabled the libm functions will be used, since it contains more functions, namely:

Gamma functions: gamma, lgamma, lgamma_r.
Bessel functions: j0, j1, jn, y0, y1, yn.
Error functions: erf, erfc.
exp10.

Tuple Fields§

§0: T

Implementations§

$ 2/π $ (A060294) ≈ 0.63661977…

Buffon’s constant.

Source

pub const FRAC_2_SQRT_PI: Float<f32>

$ 2/\sqrt{π} $ (A190732) ≈ 1.12837916…

Source

pub const TAU: Float<f32>

$ τ = 2π = 360º $ (A019692) ≈ 6.28318530…

Source

$ \sqrt{φ} $ (A139339) ≈ 1.27201964…

Source

pub const FRAC_1_SQRT_PHI: Float<f32>

$ 1/\sqrt{φ} = \sqrt{φ/φ^2} = \sqrt{φ^2-2} $ (A197762) ≈ 0.78615137…

Source

pub const TRIBONACCI: Float<f32>

(A058265) ≈ 1.83928675…

Source

pub const EGAMMA: Float<f32>

$ γ $ (A001620) ≈ 0.57721566…

ln(10) (A002392) ≈ 2.30258509…

Source §

impl Float<f64>

§Mathematical constants

.

Machine epsilon value.

$ π = \frac{1}{2} τ = 180º $ (A000796) ≈ 3.14159265…

$ 2/π $ (A060294) ≈ 0.63661977…

Buffon’s constant.

Source

pub const FRAC_2_SQRT_PI: Float<f64>

$ 2/\sqrt{π} $ (A190732) ≈ 1.12837916…

Source

pub const TAU: Float<f64>

$ τ = 2π = 360º $ (A019692) ≈ 6.28318530…

Source

$ \sqrt{φ} $ (A139339) ≈ 1.27201964…

Source

pub const FRAC_1_SQRT_PHI: Float<f64>

$ 1/\sqrt{φ} = \sqrt{φ/φ^2} = \sqrt{φ^2-2} $ (A197762) ≈ 0.78615137…

Source

pub const TRIBONACCI: Float<f64>

(A058265) ≈ 1.83928675…

Source

pub const EGAMMA: Float<f64>

$ γ $ (A001620) ≈ 0.57721566…

ln(10) (A002392) ≈ 2.30258509…

Source §

impl Float<f16>

§Mathematical constants

.

Machine epsilon value.

$ π = \frac{1}{2} τ = 180º $ (A000796) ≈ 3.14159265…

$ 2/π $ (A060294) ≈ 0.63661977…

Buffon’s constant.

Source

pub const FRAC_2_SQRT_PI: Float<f16>

$ 2/\sqrt{π} $ (A190732) ≈ 1.12837916…

Source

pub const TAU: Float<f16>

$ τ = 2π = 360º $ (A019692) ≈ 6.28318530…

Source

$ \sqrt{φ} $ (A139339) ≈ 1.27201964…

Source

pub const FRAC_1_SQRT_PHI: Float<f16>

$ 1/\sqrt{φ} = \sqrt{φ/φ^2} = \sqrt{φ^2-2} $ (A197762) ≈ 0.78615137…

Source

pub const TRIBONACCI: Float<f16>

(A058265) ≈ 1.83928675…

Source

pub const EGAMMA: Float<f16>

$ γ $ (A001620) ≈ 0.57721566…

ln(10) (A002392) ≈ 2.30258509…

Source §

impl Float<f128>

§Mathematical constants

.

Machine epsilon value.

$ π = \frac{1}{2} τ = 180º $ (A000796) ≈ 3.14159265…

$ 2/π $ (A060294) ≈ 0.63661977…

Buffon’s constant.

Source

pub const FRAC_2_SQRT_PI: Float<f128>

$ 2/\sqrt{π} $ (A190732) ≈ 1.12837916…

Source

pub const TAU: Float<f128>

$ τ = 2π = 360º $ (A019692) ≈ 6.28318530…

Source

$ \sqrt{φ} $ (A139339) ≈ 1.27201964…

Source

pub const FRAC_1_SQRT_PHI: Float<f128>

$ 1/\sqrt{φ} = \sqrt{φ/φ^2} = \sqrt{φ^2-2} $ (A197762) ≈ 0.78615137…

Source

pub const TRIBONACCI: Float<f128>

(A058265) ≈ 1.83928675…

Source

pub const EGAMMA: Float<f128>

$ γ $ (A001620) ≈ 0.57721566…

The bessel function of the second kind, of order 1.

Source §

impl Float<f32>

Available on crate feature _float_f32 only.

§Implementations using the `libm` feature.

Source

pub fn fract(self) -> Float<f32>

The fractional part.

§Formulation

$$ \text{fract}(x) = x - \text{trunc}(x) $$

Source

Bessel function of the second kind, of order n.

Source §

impl Float<f64>

Available on crate feature _float_f64 only.

§Implementations using the `libm` feature.

Source

pub fn fract(self) -> Float<f64>

The fractional part.

§Formulation

$$ \text{fract}(x) = x - \text{trunc}(x) $$

Source

Bessel function of the second kind, of order n.

Source §

impl Float<f32>

Available on crate feature _float_f32 only.

§Common implementations with or without `std` or `libm`.

pub const fn const_round_ties_away(self) -> Float<f32>

The nearest integer to itself, rounding ties away from 0.0.

This is the default [round] implementation.

§Formulation

$$ \text{round\_ties\_away}(x) = \begin{cases} \lceil x \rceil, & \text{if } x - \lfloor x \rfloor > 0.5 \text{ or } (x - \lfloor x \rfloor = 0.5 \text{ and } x > 0) \cr \lfloor x \rfloor, & \text{if } x - \lfloor x \rfloor < 0.5 \text{ or } (x - \lfloor x \rfloor = 0.5 \text{ and } x < 0) \end{cases} $$

Source

pub const fn const_round_ties_even(self) -> Float<f32>

Returns the nearest integer to x, rounding ties to the nearest even integer.

§Formulation

$$ \text{round\_ties\_even}(x) = \begin{cases} \lceil x \rceil, & \text{if } x - \lfloor x \rfloor > 0.5 \cr \lfloor x \rfloor, & \text{if } x - \lfloor x \rfloor < 0.5 \cr \lfloor x \rfloor, & \text{if } x - \lfloor x \rfloor = 0.5 \text{ and } \lfloor x \rfloor \text{ is even} \cr \lceil x \rceil, & \text{if } x - \lfloor x \rfloor = 0.5 \text{ and } \lfloor x \rfloor \text{ is odd} \end{cases} $$

assert_eq![Float(45_f32).scale(0., 360., 0., 1.), 0.125];
assert_eq![Float(45_f32).scale(0., 360., -1., 1.), -0.75];
assert_eq![Float(0.125_f32).scale(0., 1., 0., 360.), 45.];
assert_eq![Float(-0.75_f32).scale(-1., 1., 0., 360.), 45.];

Source

pub const fn lerp(self, u: f32, v: f32) -> Float<f32>

Calculates a linearly interpolated value between u..=v based on self as a percentage between [0..=1].

Values of self outside [0..=1] are not clamped and will result in extrapolation.

§Formulation

$$ \large \text{lerp}(x, u, v) = (1 - x) \cdot u + x \cdot v $$

§Example

assert_eq![Float(0.5_f32).lerp(40., 80.), 60.];

Source

pub const fn fisr(self) -> Float<f32>

$ 1 / \sqrt{x} $ the fast inverse square root algorithm.

Source

pub const fn sqrt_nr(self) -> Float<f32>

$ \sqrt{x} $ The square root calculated using the Newton-Raphson method.

$ \sqrt[3]{x} $ The cubic root calculated using the Newton-Raphson method.

Source

pub const fn factorial(x: u32) -> Float<f32>

The factorial of the integer value x.

The maximum values with a representable result are: 34 for f32 and 170 for f64.

Note that precision is poor for large values.

Source

pub const fn abs(self) -> Float<f32>

The absolute value of self.

Source

pub const fn neg_abs(self) -> Float<f32>

The negative absolute value of self (sets its sign to be negative).

Source

pub const fn flip_sign(self) -> Float<f32>

Flips its sign.

Source

pub const fn const_clamp(self, min: f32, max: f32) -> Float<f32>

Returns itself clamped between min and max, ignoring NaN.

§Example

assert_eq![Float(50.0_f32).clamp(40., 80.), 50.];
assert_eq![Float(100.0_f32).clamp(40., 80.), 80.];
assert_eq![Float(10.0_f32).clamp(40., 80.), 40.];

pub const fn const_max(self, other: f32) -> Float<f32>

The maximum between itself and other, ignoring NaN.

Source

pub const fn const_min(self, other: f32) -> Float<f32>

The minimum between itself and other, ignoring NaN.

Source

pub const fn clamp_total(self, min: f32, max: f32) -> Float<f32>

Available on crate feature _cmp_f32 only.

Returns itself clamped between min and max, using total order.

§Example

assert_eq![Float(50.0_f32).clamp_total(40., 80.), 50.];
assert_eq![Float(100.0_f32).clamp_total(40., 80.), 80.];
assert_eq![Float(10.0_f32).clamp_total(40., 80.), 40.];

pub const fn max_total(self, other: f32) -> Float<f32>

Available on crate feature _cmp_f32 only.

Returns the maximum between itself and other, using total order.

pub fn min_total(self, other: f32) -> Float<f32>

Available on crate feature _cmp_f32 only.

assert_eq![Float(50.0_f32).min_nan(80.), 50.];
assert_eq![Float(100.0_f32).min_nan(80.), 80.];

pub const fn const_powi(self, p: i32) -> Float<f32>

Raises itself to the p integer power.

Source

pub const fn eval_poly(self, coefficients: &[f32]) -> Float<f32>

Evaluates a polynomial at the self point value, using Horner’s method.

Expects a slice of coefficients $[a_n, a_{n-1}, …, a_1, a_0]$ representing the polynomial $ a_n * x^n + a_{n-1} * x^{(n-1)} + … + a_1 * x + a_0 $.

§Examples

let coefficients = [2.0, -6.0, 2.0, -1.0];
assert_eq![Float(3.0_f32).eval_poly(&coefficients), 5.0];
assert_eq![Float(3.0_f32).eval_poly(&[]), 0.0];

Source

pub fn derivative<F>(f: F, x: f32, h: f32) -> Float<f32>
where F: Fn(f32) -> f32,

Approximates the derivative of the 1D function f at x point using step size h.

Uses the finite difference method.

§Formulation

$$ f’(x) \approx \frac{f(x + h) - f(x)}{h} $$

See also the autodiff attr macro, enabled with the nightly_autodiff feature.

Source

pub fn integrate<F>(f: F, x: f32, y: f32, n: usize) -> Float<f32>
where F: Fn(f32) -> f32,

Approximates the integral of the 1D function f over the range [x, y] using n subdivisions.

Available on crate feature _float_f64 only.

§Common implementations with or without `std` or `libm`.

pub const fn const_round_ties_away(self) -> Float<f64>

The nearest integer to itself, rounding ties away from 0.0.

This is the default [round] implementation.

§Formulation

$$ \text{round\_ties\_away}(x) = \begin{cases} \lceil x \rceil, & \text{if } x - \lfloor x \rfloor > 0.5 \text{ or } (x - \lfloor x \rfloor = 0.5 \text{ and } x > 0) \cr \lfloor x \rfloor, & \text{if } x - \lfloor x \rfloor < 0.5 \text{ or } (x - \lfloor x \rfloor = 0.5 \text{ and } x < 0) \end{cases} $$

Source

pub const fn const_round_ties_even(self) -> Float<f64>

Returns the nearest integer to x, rounding ties to the nearest even integer.

§Formulation

$$ \text{round\_ties\_even}(x) = \begin{cases} \lceil x \rceil, & \text{if } x - \lfloor x \rfloor > 0.5 \cr \lfloor x \rfloor, & \text{if } x - \lfloor x \rfloor < 0.5 \cr \lfloor x \rfloor, & \text{if } x - \lfloor x \rfloor = 0.5 \text{ and } \lfloor x \rfloor \text{ is even} \cr \lceil x \rceil, & \text{if } x - \lfloor x \rfloor = 0.5 \text{ and } \lfloor x \rfloor \text{ is odd} \end{cases} $$

assert_eq![Float(45_f64).scale(0., 360., 0., 1.), 0.125];
assert_eq![Float(45_f64).scale(0., 360., -1., 1.), -0.75];
assert_eq![Float(0.125_f64).scale(0., 1., 0., 360.), 45.];
assert_eq![Float(-0.75_f64).scale(-1., 1., 0., 360.), 45.];

Source

pub const fn lerp(self, u: f64, v: f64) -> Float<f64>

Calculates a linearly interpolated value between u..=v based on self as a percentage between [0..=1].

Values of self outside [0..=1] are not clamped and will result in extrapolation.

§Formulation

$$ \large \text{lerp}(x, u, v) = (1 - x) \cdot u + x \cdot v $$

§Example

assert_eq![Float(0.5_f64).lerp(40., 80.), 60.];

Source

pub const fn fisr(self) -> Float<f64>

$ 1 / \sqrt{x} $ the fast inverse square root algorithm.

Source

pub const fn sqrt_nr(self) -> Float<f64>

$ \sqrt{x} $ The square root calculated using the Newton-Raphson method.

$ \sqrt[3]{x} $ The cubic root calculated using the Newton-Raphson method.

Source

pub const fn factorial(x: u32) -> Float<f64>

The factorial of the integer value x.

The maximum values with a representable result are: 34 for f32 and 170 for f64.

Note that precision is poor for large values.

Source

pub const fn abs(self) -> Float<f64>

The absolute value of self.

Source

pub const fn neg_abs(self) -> Float<f64>

The negative absolute value of self (sets its sign to be negative).

Source

pub const fn flip_sign(self) -> Float<f64>

Flips its sign.

Source

pub const fn const_clamp(self, min: f64, max: f64) -> Float<f64>

Returns itself clamped between min and max, ignoring NaN.

§Example

assert_eq![Float(50.0_f64).clamp(40., 80.), 50.];
assert_eq![Float(100.0_f64).clamp(40., 80.), 80.];
assert_eq![Float(10.0_f64).clamp(40., 80.), 40.];

pub const fn const_max(self, other: f64) -> Float<f64>

The maximum between itself and other, ignoring NaN.

Source

pub const fn const_min(self, other: f64) -> Float<f64>

The minimum between itself and other, ignoring NaN.

Source

pub const fn clamp_total(self, min: f64, max: f64) -> Float<f64>

Available on crate feature _cmp_f64 only.

Returns itself clamped between min and max, using total order.

§Example

assert_eq![Float(50.0_f64).clamp_total(40., 80.), 50.];
assert_eq![Float(100.0_f64).clamp_total(40., 80.), 80.];
assert_eq![Float(10.0_f64).clamp_total(40., 80.), 40.];

pub const fn max_total(self, other: f64) -> Float<f64>

Available on crate feature _cmp_f64 only.

Returns the maximum between itself and other, using total order.

pub fn min_total(self, other: f64) -> Float<f64>

Available on crate feature _cmp_f64 only.

assert_eq![Float(50.0_f64).min_nan(80.), 50.];
assert_eq![Float(100.0_f64).min_nan(80.), 80.];

pub const fn const_powi(self, p: i32) -> Float<f64>

Raises itself to the p integer power.

Source

pub const fn eval_poly(self, coefficients: &[f64]) -> Float<f64>

Evaluates a polynomial at the self point value, using Horner’s method.

Expects a slice of coefficients $[a_n, a_{n-1}, …, a_1, a_0]$ representing the polynomial $ a_n * x^n + a_{n-1} * x^{(n-1)} + … + a_1 * x + a_0 $.

§Examples

let coefficients = [2.0, -6.0, 2.0, -1.0];
assert_eq![Float(3.0_f64).eval_poly(&coefficients), 5.0];
assert_eq![Float(3.0_f64).eval_poly(&[]), 0.0];

Source

pub fn derivative<F>(f: F, x: f64, h: f64) -> Float<f64>
where F: Fn(f64) -> f64,

Approximates the derivative of the 1D function f at x point using step size h.

Uses the finite difference method.

§Formulation

$$ f’(x) \approx \frac{f(x + h) - f(x)}{h} $$

See also the autodiff attr macro, enabled with the nightly_autodiff feature.

Source

pub fn integrate<F>(f: F, x: f64, y: f64, n: usize) -> Float<f64>
where F: Fn(f64) -> f64,

Approximates the integral of the 1D function f over the range [x, y] using n subdivisions.

Uses the Riemann Sum.

§Formulation

$$ \int_a^b f(x) , dx \approx \sum_{i=0}^{n-1} f(x_i) \cdot \Delta x $$ where $$ \Delta x = \frac{b-a}{n} $$

Source

pub fn partial_derivative_x<F>(f: F, x: f64, y: f64, h: f64) -> Float<f64>
where F: Fn(f64, f64) -> f64,

Approximates the partial derivative of the 2D function f at point (x, y) with step size h, differentiating over x.

§Formulation

\frac{\partial f}{\partial x} \approx \frac{f(x + h, y) - f(x, y)}{h} $$

Source

pub fn partial_derivative_y<F>(f: F, x: f64, y: f64, h: f64) -> Float<f64>
where F: Fn(f64, f64) -> f64,

Approximates the partial derivative of the 2D function f at point (x, y) with step size h, differentiating over x.

§Formulation

\frac{\partial f}{\partial x} \approx \frac{f(x + h, y) - f(x, y)}{h} $$

Source §

impl Float<f32>

Available on crate feature _float_f32 only.

§Common methods with or without `std` or `libm`.

Implemented using Taylor series.

Source

pub const fn powf_series(self, y: f32, ln_x_terms: u32) -> Float<f32>

Raises itself to the y floating point power using the Taylor series via the exp and ln functions.

§Formulation

$$ \large x^y = e^{y \cdot \ln(x)} $$

See also ln_series_terms.

The terms for the exponential function are calculated using exp_series_terms using $y\cdot\ln(x)$.

Source

pub const fn exp_series(self, terms: u32) -> Float<f32>

Computes the exponential function $e^x$ using Taylor series expansion.

§Formulation

$$ e^x = 1 + x + \frac{x^2}{2!} + \frac{x^3}{3!} + \frac{x^4}{4!} + \cdots $$ For values $ x < 0 $ it uses the identity: $$ e^x = \frac{1}{e^-x} $$

See also exp_series_terms.

Source

pub const fn exp_series_terms(self) -> u32 ⓘ

Determines the number of terms needed for exp_series to reach a stable result based on the input value. The following table shows the required number of terms needed to reach the most precise result for both f32 and f64:

  value     t_f32  t_f64
-------------------------
± 0.001 →       3     5
± 0.100 →       6     10
± 1.000 →      11     18
± 10.000 →     32     46
± 20.000 →     49     68
± 50.000 →     92    119
± 88.722 →    143    177  (max for f32 == f32::MAX.ln())
± 150.000 →   ---    261
± 300.000 →   ---    453
± 500.000 →   ---    692
± 709.782 →   ---    938  (max for f64 == f64:MAX.ln())

Source

pub const fn exp_m1_series(self, terms: u32) -> Float<f32>

Calculates $ e^x - 1 $ using the Taylor series expansion.

§Formulation

$$ e^x -1 = x + \frac{x^2}{2!} + \frac{x^3}{3!} + \frac{x^4}{4!} + \cdots $$ For values $ x < 0 $ it uses the identity: $$ e^x -1 = -\frac{1}{e^{-x}+1} $$ For values $ x > 0.001 $ it uses exp_series.

See also exp_series_terms.

Source

pub const fn exp2_series(self, terms: u32) -> Float<f32>

Calculates $ 2^x $ using the Taylor series expansion.

§Formulation

The series based on the formula $ 2^x = e^{x \ln(2)} $ is: $$ 2^x = 1 + x \ln(2) + \frac{(x \ln(2))^2}{2!} + \frac{(x \ln(2))^3}{3!} + \frac{(x \ln(2))^4}{4!} + \cdots $$

The maximum values with a representable result are: 127 for f32 and 1023 for f64.

Source

pub const fn exp2_series_terms(self) -> u32 ⓘ

Determines the number of terms needed for exp2_series to reach a stable result based on the input value. The following table shows the required number of terms needed to reach the most precise result for both f32 and f64:

  value     t_f32  t_f64
-------------------------
± 0.3 →        8     13
± 3.0 →       15     25
± 7.0 →       22     34
± 15.0 →      34     49
± 31.0 →      52     71
± 63.0 →      84    110
± 127.999 →  144    178 (max for f32)
± 255.0 →    ---    298
± 511.0 →    ---    520
± 1023.999 → ---    939 (max for f64)

Source

pub const fn ln_series(self, terms: u32) -> Float<f32>

Computes the natural logarithm of self using a Taylor-Mercator series expansion.

Determines the number of terms needed for exp2_series to reach a stable result based on the input value. The following table shows the required number of terms needed to reach the most precise result for both f32 and f64:

  value      t_f32  t_f64
--------------------------
± 0.00001 →  81181 536609
± 0.0001 →   12578  59174
± 0.001 →     1923   6639
± 0.01. →      245    720
± 0.1 →         32     80
± 0.5 →          8     17
± 1. →           1      1
± 2. →           8     17
± 10. →         32     80
± 100. →       245    720
± 1000. →     1923   6639
± 10000. →   12578  59174
± 100000. →  81181 536609
/// ```

Source

pub const fn sin_series(self, terms: u32) -> Float<f32>

The sine calculated using Taylor series expansion.

§Formulation

$$ \sin(x) = x - \frac{x^3}{3!} + \frac{x^5}{5!} - \frac{x^7}{7!} + \cdots $$

This Taylor series converges relatively quickly and uniformly over the entire domain. The following table shows the required number of terms needed to reach the most precise result for both f32 and f64:

  value     t_f32  t_f64
-------------------------
± 0.001 →      3      4
± 0.100 →      4      6
± 0.300 →      5      7
± 0.500 →      5      8
± 0.700 →      6      9
± 0.900 →      6     10
± 0.999 →      6     10

The tangent function has singularities and is not defined for cos(x) = 0. This function clamps self within an appropriate range to avoid such issues.

The Taylor series for sine and cosine converge relatively quickly and uniformly over the entire domain. The following table shows the required number of terms needed to reach the most precise result for both f32 and f64:

  value     t_f32  t_f64
-------------------------
± 0.001 →      3      4
± 0.100 →      4      6
± 0.300 →      5      8
± 0.500 →      6      9
± 0.700 →      6     10
± 0.900 →      7     10
± 0.999 →      7     11

Source

pub const fn asin_series(self, terms: u32) -> Float<f32>

Computes the arcsine using Taylor series expansion.

§Formulation

$$ \arcsin(x) = x + \left( \frac{1}{2} \right) \frac{x^3}{3} + \left( \frac{1}{2} \cdot \frac{3}{4} \right) \frac{x^5}{5} + \left( \frac{1}{2} \cdot \frac{3}{4} \cdot \frac{5}{6} \right) \frac{x^7}{7} + \cdots $$

asin is undefined for $ |x| > 1 $ and in that case returns NaN.

The series converges more slowly near the edges of the domain (i.e., as self approaches -1 or 1). For more accurate results, especially near these boundary values, a higher number of terms may be necessary.

pub const fn asin_series_terms(self) -> u32 ⓘ

Determines the number of terms needed for asin_series to reach a stable result based on the input value.

The following table shows the required number of terms needed to reach the most precise result for both f32 and f64:

  value     t_f32  t_f64
-------------------------
± 0.001 →      3      4
± 0.100 →      5      9
± 0.300 →      7     15
± 0.500 →     10     24
± 0.700 →     18     44
± 0.900 →     47    134
± 0.990 →    333   1235
± 0.999 →   1989  10768

Source

pub const fn acos_series(self, terms: u32) -> Float<f32>

Computes the arccosine using the Taylor expansion of arcsine.

§Formulation

$$ \arccos(x)=2π-arcsin(x) $$

See the asin_series_terms table for information about the number of terms needed.

Source

pub const fn acos_series_terms(self) -> u32 ⓘ

Determines the number of terms needed for acos_series to reach a stable result based on the input value.

The table is the same as asin_series_terms.

Source

pub const fn atan_series(self, terms: u32) -> Float<f32>

Computes the arctangent using Taylor series expansion.

§Formulation

$$ \arctan(x) = x - \frac{x^3}{3} + \frac{x^5}{5} - \frac{x^7}{7} + \cdots $$ For values $ |x| > 1 $ it uses the identity: $$ \arctan(x) = \frac{\pi}{2} - \arctan(\frac{1}{x}) $$

The series converges more slowly near the edges of the domain (i.e., as self approaches -1 or 1). For more accurate results, especially near these boundary values, a higher number of terms may be necessary.

See also atan_series_terms.

Source

pub const fn atan_series_terms(self) -> u32 ⓘ

Determines the number of terms needed for atan_series to reach a stable result based on the input value. The following table shows the required number of terms needed to reach the most precise result for both f32 and f64:

  value     t_f32  t_f64
-------------------------
± 0.001 →      3      4
± 0.100 →      5      9
± 0.300 →      7     15
± 0.500 →     12     26
± 0.700 →     20     47
± 0.900 →     61    152
± 0.990 →    518   1466
± 0.999 →   4151  13604

Available on crate feature _float_f64 only.

§Common methods with or without `std` or `libm`.

Implemented using Taylor series.

Source

pub const fn powf_series(self, y: f64, ln_x_terms: u32) -> Float<f64>

Raises itself to the y floating point power using the Taylor series via the exp and ln functions.

§Formulation

$$ \large x^y = e^{y \cdot \ln(x)} $$

See also ln_series_terms.

The terms for the exponential function are calculated using exp_series_terms using $y\cdot\ln(x)$.

Source

pub const fn exp_series(self, terms: u32) -> Float<f64>

Computes the exponential function $e^x$ using Taylor series expansion.

§Formulation

$$ e^x = 1 + x + \frac{x^2}{2!} + \frac{x^3}{3!} + \frac{x^4}{4!} + \cdots $$ For values $ x < 0 $ it uses the identity: $$ e^x = \frac{1}{e^-x} $$

See also exp_series_terms.

Source

pub const fn exp_series_terms(self) -> u32 ⓘ

Determines the number of terms needed for exp_series to reach a stable result based on the input value. The following table shows the required number of terms needed to reach the most precise result for both f32 and f64:

  value     t_f32  t_f64
-------------------------
± 0.001 →       3     5
± 0.100 →       6     10
± 1.000 →      11     18
± 10.000 →     32     46
± 20.000 →     49     68
± 50.000 →     92    119
± 88.722 →    143    177  (max for f32 == f32::MAX.ln())
± 150.000 →   ---    261
± 300.000 →   ---    453
± 500.000 →   ---    692
± 709.782 →   ---    938  (max for f64 == f64:MAX.ln())

Source

pub const fn exp_m1_series(self, terms: u32) -> Float<f64>

Calculates $ e^x - 1 $ using the Taylor series expansion.

§Formulation

$$ e^x -1 = x + \frac{x^2}{2!} + \frac{x^3}{3!} + \frac{x^4}{4!} + \cdots $$ For values $ x < 0 $ it uses the identity: $$ e^x -1 = -\frac{1}{e^{-x}+1} $$ For values $ x > 0.001 $ it uses exp_series.

See also exp_series_terms.

Source

pub const fn exp2_series(self, terms: u32) -> Float<f64>

Calculates $ 2^x $ using the Taylor series expansion.

§Formulation

The series based on the formula $ 2^x = e^{x \ln(2)} $ is: $$ 2^x = 1 + x \ln(2) + \frac{(x \ln(2))^2}{2!} + \frac{(x \ln(2))^3}{3!} + \frac{(x \ln(2))^4}{4!} + \cdots $$

The maximum values with a representable result are: 127 for f32 and 1023 for f64.

Source

pub const fn exp2_series_terms(self) -> u32 ⓘ

Determines the number of terms needed for exp2_series to reach a stable result based on the input value. The following table shows the required number of terms needed to reach the most precise result for both f32 and f64:

  value     t_f32  t_f64
-------------------------
± 0.3 →        8     13
± 3.0 →       15     25
± 7.0 →       22     34
± 15.0 →      34     49
± 31.0 →      52     71
± 63.0 →      84    110
± 127.999 →  144    178 (max for f32)
± 255.0 →    ---    298
± 511.0 →    ---    520
± 1023.999 → ---    939 (max for f64)

Source

pub const fn ln_series(self, terms: u32) -> Float<f64>

Computes the natural logarithm of self using a Taylor-Mercator series expansion.

Determines the number of terms needed for exp2_series to reach a stable result based on the input value. The following table shows the required number of terms needed to reach the most precise result for both f32 and f64:

  value      t_f32  t_f64
--------------------------
± 0.00001 →  81181 536609
± 0.0001 →   12578  59174
± 0.001 →     1923   6639
± 0.01. →      245    720
± 0.1 →         32     80
± 0.5 →          8     17
± 1. →           1      1
± 2. →           8     17
± 10. →         32     80
± 100. →       245    720
± 1000. →     1923   6639
± 10000. →   12578  59174
± 100000. →  81181 536609
/// ```

Source

pub const fn sin_series(self, terms: u32) -> Float<f64>

The sine calculated using Taylor series expansion.

§Formulation

$$ \sin(x) = x - \frac{x^3}{3!} + \frac{x^5}{5!} - \frac{x^7}{7!} + \cdots $$

This Taylor series converges relatively quickly and uniformly over the entire domain. The following table shows the required number of terms needed to reach the most precise result for both f32 and f64:

  value     t_f32  t_f64
-------------------------
± 0.001 →      3      4
± 0.100 →      4      6
± 0.300 →      5      7
± 0.500 →      5      8
± 0.700 →      6      9
± 0.900 →      6     10
± 0.999 →      6     10

The tangent function has singularities and is not defined for cos(x) = 0. This function clamps self within an appropriate range to avoid such issues.

The Taylor series for sine and cosine converge relatively quickly and uniformly over the entire domain. The following table shows the required number of terms needed to reach the most precise result for both f32 and f64:

  value     t_f32  t_f64
-------------------------
± 0.001 →      3      4
± 0.100 →      4      6
± 0.300 →      5      8
± 0.500 →      6      9
± 0.700 →      6     10
± 0.900 →      7     10
± 0.999 →      7     11

Source

pub const fn asin_series(self, terms: u32) -> Float<f64>

Computes the arcsine using Taylor series expansion.

§Formulation

$$ \arcsin(x) = x + \left( \frac{1}{2} \right) \frac{x^3}{3} + \left( \frac{1}{2} \cdot \frac{3}{4} \right) \frac{x^5}{5} + \left( \frac{1}{2} \cdot \frac{3}{4} \cdot \frac{5}{6} \right) \frac{x^7}{7} + \cdots $$

asin is undefined for $ |x| > 1 $ and in that case returns NaN.

The series converges more slowly near the edges of the domain (i.e., as self approaches -1 or 1). For more accurate results, especially near these boundary values, a higher number of terms may be necessary.

pub const fn asin_series_terms(self) -> u32 ⓘ

Determines the number of terms needed for asin_series to reach a stable result based on the input value.

The following table shows the required number of terms needed to reach the most precise result for both f32 and f64:

  value     t_f32  t_f64
-------------------------
± 0.001 →      3      4
± 0.100 →      5      9
± 0.300 →      7     15
± 0.500 →     10     24
± 0.700 →     18     44
± 0.900 →     47    134
± 0.990 →    333   1235
± 0.999 →   1989  10768

Source

pub const fn acos_series(self, terms: u32) -> Float<f64>

Computes the arccosine using the Taylor expansion of arcsine.

§Formulation

$$ \arccos(x)=2π-arcsin(x) $$

See the asin_series_terms table for information about the number of terms needed.

Source

pub const fn acos_series_terms(self) -> u32 ⓘ

Determines the number of terms needed for acos_series to reach a stable result based on the input value.

The table is the same as asin_series_terms.

Source

pub const fn atan_series(self, terms: u32) -> Float<f64>

Computes the arctangent using Taylor series expansion.

§Formulation

$$ \arctan(x) = x - \frac{x^3}{3} + \frac{x^5}{5} - \frac{x^7}{7} + \cdots $$ For values $ |x| > 1 $ it uses the identity: $$ \arctan(x) = \frac{\pi}{2} - \arctan(\frac{1}{x}) $$

The series converges more slowly near the edges of the domain (i.e., as self approaches -1 or 1). For more accurate results, especially near these boundary values, a higher number of terms may be necessary.

See also atan_series_terms.

Source

pub const fn atan_series_terms(self) -> u32 ⓘ

Determines the number of terms needed for atan_series to reach a stable result based on the input value. The following table shows the required number of terms needed to reach the most precise result for both f32 and f64:

  value     t_f32  t_f64
-------------------------
± 0.001 →      3      4
± 0.100 →      5      9
± 0.300 →      7     15
± 0.500 →     12     26
± 0.700 →     20     47
± 0.900 →     61    152
± 0.990 →    518   1466
± 0.999 →   4151  13604

impl<T: Clone> Clone for Float<T>

Source §

fn clone(&self) -> Self

Returns a copy of the value. Read more

Source §

fn eq(&self, other: &T) -> bool

Tests for self and other values to be equal, and is used by ==.

1.0.0 · Source§

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

Source §

impl<T: PartialEq> PartialEq for Float<T>

Source §

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

1.0.0 · Source§

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

Source §

Source §

fn byte_align(&self) -> usize ⓘ

Returns the alignment of this type in bytes.

Source §

fn byte_size(&self) -> usize ⓘ

Returns the size of this type in bytes. Read more

Source §

fn ptr_size_ratio(&self) -> [usize; 2]

Returns the size ratio between Ptr::BYTES and BYTE_SIZE. Read more

Source §

impl<T, R> Chain<R> for T
where T: ?Sized,

Source §

fn chain<F>(self, f: F) -> R
where F: FnOnce(Self) -> R, Self: Sized,

Chain a function which takes the parameter by value.

Source §

fn chain_ref<F>(&self, f: F) -> R
where F: FnOnce(&Self) -> R,

Chain a function which takes the parameter by shared reference.

Source §

fn chain_mut<F>(&mut self, f: F) -> R
where F: FnOnce(&mut Self) -> R,

Chain a function which takes the parameter by exclusive reference.

Source §

fn from(t: T) -> T

Returns the argument unchanged.

§

impl<S> FromSample<S> for S

§

fn from_sample_(s: S) -> S

Source §

impl<T> Hook for T

Source §

fn hook_ref<F>(self, f: F) -> Self
where F: FnOnce(&Self),

Applies a function which takes the parameter by shared reference, and then returns the (possibly) modified owned value. Read more

Source §

fn hook_mut<F>(self, f: F) -> Self
where F: FnOnce(&mut Self),

Applies a function which takes the parameter by exclusive reference, and then returns the (possibly) modified owned value. Read more

§

impl<T> Instrument for T

§

fn instrument(self, span: Span) -> Instrumented<Self> ⓘ

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

§

fn in_current_span(self) -> Instrumented<Self> ⓘ

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more

§