Struct Native64 

pub struct Native64;

Numerical kernel specifier to be used as generic argument (or associated type) in order to indicate that the floating point values that must be used are the Rust’s native f64 and/or Complex<f64>.

Trait Implementations

impl Clone for Native64

fn clone(&self) -> Native64

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Native64

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl FunctionsComplexType<Native64> for Complex<f64>

Implement the FunctionsComplexType trait for the Complex<f64> type.

fn arg_(self) -> f64

Computes the principal Arg of self.

fn new_(real_part: f64, imag_part: f64) -> Self

Creates a complex number of type T::ComplexType from its real and imaginary parts.

Panics

In debug mode a panic! will be emitted if the real_part or the imag_part is not finite.

fn real_(&self) -> f64

Get the real part of the complex number.

fn imag_(&self) -> f64

Get the imaginary part of the complex number.

fn set_real_(&mut self, real_part: f64)

Set the value of the real part.

Panics

In debug mode a panic! will be emitted if real_part is not finite.

fn set_imag_(&mut self, imag_part: f64)

Set the value of the imaginary part.

Panics

In debug mode a panic! will be emitted if imaginary_part is not finite.

fn add_real_(&mut self, c: &f64)

Add the value of the the real coefficient c to real part of self.

fn add_imag_(&mut self, c: &f64)

Add the value of the the real coefficient c to imaginary part of self.

fn multiply_real_(&mut self, c: &f64)

Multiply the value of the real part by the real coefficient c.

fn multiply_imag_(&mut self, c: &f64)

Multiply the value of the imaginary part by the real coefficient c.

fn conj_(self) -> Self

Computes the complex conjugate.

fn try_from_f64_( real_part: f64, imag_part: f64, ) -> Result<Self, TryFromf64Errors>

Try to build a Self from real and imaginary parts as f64 values. The returned value is Ok if the input real_part and imag_part are finite and can be exactly represented by T::RealType, otherwise the returned value is TryFromf64Errors.

impl FunctionsRealType<Native64> for f64

fn atan2_(self, other: &Self) -> Self

Computes the four quadrant arctangent of self (y) and other (x) in radians.

• x = 0, y = 0: 0
• x >= 0: arctan(y/x) -> [-pi/2, pi/2]
• y >= 0: arctan(y/x) + pi -> (pi/2, pi]
• y < 0: arctan(y/x) - pi -> (-pi, -pi/2)

use ftl_numkernel::{FunctionsGeneralType, FunctionsRealType};

let y = 3.0_f64;
let x = -4.0_f64;
let atan2 = y.atan2_(&x);
let expected = 2.4981_f64;
assert!((atan2 - expected).abs() < 0.0001);

fn ceil_(self) -> Self

Returns the smallest integer greater than or equal to self.

fn clamp_(self, min: &Self, max: &Self) -> Self

Clamp the value within the specified bounds.

Returns max if self is greater than max, and min if self is less than min. Otherwise this returns self.

Note that this function returns NaN if the initial value was NaN as well.

Panics

Panics if min > max, min is NaN, or max is NaN.

use ftl_numkernel::{FunctionsRealType, IsNaN};

assert!((-3.0f64).clamp_(&-2.0, &1.0) == -2.0);
assert!((0.0f64).clamp_(&-2.0, &1.0) == 0.0);
assert!((2.0f64).clamp_(&-2.0, &1.0) == 1.0);
assert!((f64::NAN).clamp_(&-2.0, &1.0).is_nan_());

fn classify_(&self) -> FpCategory

Returns the floating point category of the number. If only one property is going to be tested, it is generally faster to use the specific predicate instead.

use ftl_numkernel::FunctionsRealType;
use std::num::FpCategory;

let num = 12.4_f64;
let inf = f64::INFINITY;

assert_eq!(num.classify_(), FpCategory::Normal);
assert_eq!(inf.classify_(), FpCategory::Infinite);

fn copysign_(self, sign: &Self) -> Self

Returns a number with the magnitude of self and the sign of sign.

fn epsilon_() -> Self

Machine epsilon value for f64.

This is the difference between 1.0 and the next larger representable number.

fn exp_m1_(self) -> Self

Returns `e^(self) - 1`` in a way that is accurate even if the number is close to zero.

fn floor_(self) -> Self

Returns the largest integer smaller than or equal to self.

fn fract_(self) -> Self

Returns the fractional part of self.

fn hypot_(self, other: &Self) -> Self

Compute the distance between the origin and a point (self, other) on the Euclidean plane. Equivalently, compute the length of the hypotenuse of a right-angle triangle with other sides having length self.abs() and other.abs().

fn infinity_() -> Self

Returns the special value representing the positive infinity.

fn is_sign_negative_(&self) -> bool

Returns true if the value is negative, −0 or NaN with a negative sign.

fn is_sign_positive_(&self) -> bool

Returns true if the value is positive, +0 or NaN with a positive sign.

fn ln_1p_(self) -> Self

Returns ln(1. + self) (natural logarithm) more accurately than if the operations were performed separately.

fn neg_infinity_() -> Self

Returns the special value representing the negative infinity.

fn max_(self, other: &Self) -> Self

Computes the maximum between self and other.

fn min_(self, other: &Self) -> Self

Computes the minimum between self and other.

fn mul_add_mul_mut_(&mut self, mul: &Self, add_mul1: &Self, add_mul2: &Self)

Multiplies two products and adds them in one fused operation, rounding to the nearest with only one rounding error. a.mul_add_mul_mut_(&b, &c, &d) produces a result like &a * &b + &c * &d, but stores the result in a using its precision.

fn mul_sub_mul_mut_(&mut self, mul: &Self, sub_mul1: &Self, sub_mul2: &Self)

Multiplies two products and subtracts them in one fused operation, rounding to the nearest with only one rounding error. a.mul_sub_mul_mut_(&b, &c, &d) produces a result like &a * &b - &c * &d, but stores the result in a using its precision.

fn negative_one_() -> Self

Build and return the (floating point) value -1. represented by a f64.

fn one_div_2_() -> Self

Build and return the (floating point) value 0.5 represented by the proper type.

fn round_(self) -> Self

Rounds self to the nearest integer, rounding half-way cases away from zero.

fn round_ties_even_(self) -> Self

Returns the nearest integer to a number. Rounds half-way cases to the number with an even least significant digit.

This function always returns the precise result.

Examples

use ftl_numkernel::FunctionsRealType;

let f = 3.3_f64;
let g = -3.3_f64;
let h = 3.5_f64;
let i = 4.5_f64;

assert_eq!(f.round_ties_even_(), 3.0);
assert_eq!(g.round_ties_even_(), -3.0);
assert_eq!(h.round_ties_even_(), 4.0);
assert_eq!(i.round_ties_even_(), 4.0);

fn signum_(self) -> Self

Computes the signum.

The returned value is:

• 1.0 if the value is positive, +0.0 or +∞
• −1.0 if the value is negative, −0.0 or −∞
• NaN if the value is NaN

fn try_from_f64_(value: f64) -> Result<Self, TryFromf64Errors>

Try to build a f64 instance from a f64. The returned value is Ok if the input value is finite, otherwise the returned value is TryFromf64Errors.

fn trunc_(self) -> Self

Returns the integer part of self. This means that non-integer numbers are always truncated towards zero.

Examples

use ftl_numkernel::FunctionsRealType;

let f = 3.7_f64;
let g = 3.0_f64;
let h = -3.7_f64;

assert_eq!(f.trunc_(), 3.0);
assert_eq!(g.trunc_(), 3.0);
assert_eq!(h.trunc_(), -3.0);

fn two_() -> Self

Build and return the (floating point) value 2. represented by a f64.

fn total_cmp_(&self, other: &Self) -> Ordering

fn pi_() -> Self

Build and return the (floating point) value π represented by the proper type.

fn pi_div_2_() -> Self

Build and return the (floating point) value π/2 represented by the proper type.

impl NumKernel for Native64

Implement the NumKernel trait for Native64

type RealType = f64

The type for a real scalar value in this numerical kernel.

type ComplexType = Complex<f64>

The type for a complex scalar value in this numerical kernel.

type RawRealType = f64

type RawComplexType = Complex<f64>

impl PartialEq for Native64

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

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

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

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

impl PartialOrd for Native64

fn partial_cmp(&self, other: &Native64) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl FunctionsGeneralType<Native64> for Complex<f64>

impl FunctionsGeneralType<Native64> for f64

impl MulComplexLeft<Native64> for Complex<f64>

impl MulComplexRight<Native64> for f64

impl PowTrait<Native64> for Complex<f64>

impl PowTrait<Native64> for f64

impl StructuralPartialEq for Native64