ftl_numkernel/

lib.rs

#![deny(rustdoc::broken_intra_doc_links)]
#![feature(error_generic_member_access)]

//! This library contains the structures and traits that define which ***numerical kernel*** (i.e. the representation/manipulation of floating point numbers) must be used.
//!
//! At the time of writing, you can use 2 numerical kernels:
//! - [`Native64`], is the numerical kernel in which the floating point numbers are
//!   described by the Rust's native (64bit) representation, as described by the ANSI/IEEE Std 754-1985;
//! - `Rug`, is the numerical kernel in which the floating point numbers are described with **arbitrary precision**.
//!   The precision of the number is described by the generic parameter `PRECISION`.
//!   This numerical kernel is available if the library is compiled with the optional flag `--features=rug` and uses the Rust library [`rug`](https://crates.io/crates/rug).

pub mod errors;
pub mod functions;
pub mod neumaier_compensated_sum;

use crate::{
    errors::{
        ComplexValueErrors, ComplexValueValidator, RealValueErrors, RealValueValidator,
        TryFromf64Errors,
    },
    functions::{Abs, Reciprocal, Sqrt},
};
use num::{Complex, One, Zero};
use num_traits::ops::mul_add::MulAddAssign;
use serde::{de::DeserializeOwned, Serialize};
use std::{
    backtrace::Backtrace,
    cmp::Ordering,
    fmt::{self},
    num::FpCategory,
};
use thiserror::Error;

// Conditional compilation for the `rug` feature
#[cfg(feature = "rug")]
use derive_more::{
    Add, AddAssign, AsRef, Display, Div, DivAssign, LowerExp, Mul, MulAssign, Neg, Sub, SubAssign,
};

// Conditional compilation for when the `rug` feature is not enabled
#[cfg(not(feature = "rug"))]
use std::{
    fmt::LowerExp,
    ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Sub, SubAssign},
};

// Conditional compilation for the `rug` feature
#[cfg(feature = "rug")]
use duplicate::duplicate_item;

// Conditional compilation for the `rug` feature
#[cfg(feature = "rug")]
use rug::ops::{CompleteRound, Pow as RugPow};

// Conditional compilation for the `rug` feature
#[cfg(feature = "rug")]
use serde::Deserialize;

//-------------------------------------------------------------
/// Trait representing the conversion of a type into its inner type.
pub trait IntoInner {
    /// The inner type.
    type Target;

    /// Returns the inner type consuming the original value.
    fn into_inner(self) -> Self::Target;
}
//-------------------------------------------------------------

//-------------------------------------------------------------
#[derive(Debug, Error)]
pub enum RecipErrors<ValueType: Sized> {
    /// The input value is NaN.
    #[error("the input value is NaN!")]
    NanInput { backtrace: Backtrace },

    /// The output value is NaN.
    #[error("the output value is NaN!")]
    NanOutput { backtrace: Backtrace },

    /// The input value is zero.
    #[error("the input value is zero!")]
    DivisionByZero { backtrace: Backtrace },

    /// The output value is [subnormal](https://en.wikipedia.org/wiki/Subnormal_number).
    #[error("the output value ({value:?}) is subnormal!")]
    Underflow {
        value: ValueType,
        backtrace: Backtrace,
    },

    /// The output value cannot be represented becaus an overflow has occourred.
    #[error("The output value cannot be represented becaus an overflow has occourred")]
    Overflow { backtrace: Backtrace },
}
//-------------------------------------------------------------

//-------------------------------------------------------------

/// Compound negation and assignment.
pub trait NegAssign {
    /// Performs the negation.
    fn neg_assign(&mut self);
}

#[duplicate::duplicate_item(
    T;
    [f64];
    [Complex<f64>];
)]
/// Compound negation and assignment.
impl NegAssign for T {
    /// Performs the negation of `self`.
    fn neg_assign(&mut self) {
        *self = -*self;
    }
}

// Conditional compilation for the `rug` feature
#[cfg(feature = "rug")]
#[duplicate::duplicate_item(
    T;
    [rug::Float];
    [rug::Complex];
)]
/// Compound negation and assignment.
impl NegAssign for T {
    /// Performs the negation of `self`.
    fn neg_assign(&mut self) {
        <T as rug::ops::NegAssign>::neg_assign(self);
    }
}
//-------------------------------------------------------------

//------------------------------------------------------------------
pub trait Pow<ExponentType> {
    /// Raises th number `self` to the power `exponent`.
    fn pow_(self, exponent: ExponentType) -> Self;
}

#[duplicate::duplicate_item(
    T;
    [f64];
    [Complex<f64>];
)]
impl Pow<f64> for T {
    /// Raises th number `self` to the power `exponent`.
    fn pow_(self, exponent: f64) -> Self {
        self.powf(exponent)
    }
}

#[duplicate::duplicate_item(
    T exponent_type func_name;
    [f64] [i32] [powi];
    [Complex<f64>] [i32] [powi];
    [Complex<f64>] [u32] [powu];
)]
impl Pow<exponent_type> for T {
    /// Raises th number `self` to the power `exponent`.
    fn pow_(self, exponent: exponent_type) -> Self {
        self.func_name(exponent)
    }
}

#[duplicate::duplicate_item(
    T exponent_type func_name;
    [f64] [i8]  [powi];
    [f64] [u8]  [powi];
    [f64] [i16] [powi];
    [f64] [u16] [powi];
    [Complex<f64>] [i8]  [powi];
    [Complex<f64>] [u8]  [powu];
    [Complex<f64>] [i16] [powi];
    [Complex<f64>] [u16] [powu];
)]
impl Pow<exponent_type> for T {
    /// Raises th number `self` to the power `exponent`.
    fn pow_(self, exponent: exponent_type) -> Self {
        self.func_name(exponent.into())
    }
}

#[duplicate::duplicate_item(
    T exponent_type func_name;
    [f64] [u32]   [powi];
    [f64] [i64]   [powi];
    [f64] [u64]   [powi];
    [f64] [i128]  [powi];
    [f64] [u128]  [powi];
    [f64] [usize] [powi];
    [Complex<f64>] [i64]   [powi];
    [Complex<f64>] [i128]  [powi];
    [Complex<f64>] [u64]   [powu];
    [Complex<f64>] [u128]  [powu];
    [Complex<f64>] [usize] [powu];
)]
impl Pow<exponent_type> for T {
    /// Raises th number `self` to the power `exponent`.
    fn pow_(self, exponent: exponent_type) -> Self {
        self.func_name(exponent.try_into().unwrap())
    }
}

pub trait PowTrait<T: NumKernel>:
    Pow<T::RealType>
    + Pow<i8>
    + Pow<u8>
    + Pow<i16>
    + Pow<u16>
    + Pow<i32>
    + Pow<u32>
    + Pow<i64>
    + Pow<u64>
    + Pow<i128>
    + Pow<u128>
    + Pow<usize>
{
}

impl PowTrait<Native64> for f64 {}
impl PowTrait<Native64> for Complex<f64> {}
//------------------------------------------------------------------------------------------------

//-------------------------------------------------------------
/// Trait representing the arithmetic operations (e.g. addition, subtraction, multiplication division, negation).
pub trait Arithmetic: Sized
where
    Self: Add<Self, Output = Self>
        + for<'a> Add<&'a Self, Output = Self>
        + AddAssign
        + for<'a> AddAssign<&'a Self>
        + Sub<Output = Self>
        + for<'a> Sub<&'a Self, Output = Self>
        + SubAssign
        + for<'a> SubAssign<&'a Self>
        + Mul<Output = Self>
        + for<'a> Mul<&'a Self, Output = Self>
        + MulAssign
        + for<'a> MulAssign<&'a Self>
        + Div<Output = Self>
        + for<'a> Div<&'a Self, Output = Self>
        + DivAssign
        + for<'a> DivAssign<&'a Self>
        + Neg
        + NegAssign
        + LowerExp,
{
}

/// Trait for the multiplication between a complex number (on the left hand side) and a real number (on the right hand side).
/// The result of these binary operation will be always a complex number.
///
/// # Note
///
/// We only permit multiplication between complex and real numbers.
/// Addition and subtraction of a complex number with a real number is not allowed for safety reasons.
pub trait MulComplexLeft<T: NumKernel>:
    Mul<T::RealType, Output = T::ComplexType>
    + for<'a> Mul<&'a T::RealType, Output = T::ComplexType>
    + MulAssign<T::RealType>
    + for<'a> MulAssign<&'a T::RealType>
{
}

/// Trait for the multiplication between a real number (on the left hand side) and a complex number (on the right hand side).
/// The result of these binary operation will be always a complex number.
///
/// # Note
///
/// We only permit multiplication between  real and complex numbers.
/// Addition and subtraction of a real number with a complex number is not allowed for safety reasons.
pub trait MulComplexRight<T: NumKernel>: Mul<T::ComplexType, Output = T::ComplexType> {}

impl Arithmetic for f64 {}
impl Arithmetic for Complex<f64> {}
impl MulComplexRight<Native64> for f64 {}
impl MulComplexLeft<Native64> for Complex<f64> {}

// Conditional compilation for the `rug` feature
#[cfg(feature = "rug")]
impl Arithmetic for rug::Float {}

// Conditional compilation for the `rug` feature
#[cfg(feature = "rug")]
impl Arithmetic for rug::Complex {}

//------------------------------------------------------------------------------------------------------------

//------------------------------------------------------------------------------------------------------------

/// 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>`.
#[derive(Debug, Clone, PartialEq, PartialOrd)]
pub struct Native64;

// Conditional compilation for the `rug` feature
#[cfg(feature = "rug")]
/// 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 [`rug::Float`] and/or [`rug::Complex`].
///
/// # Generic argument
/// `PRECISION` - value used to specify the precision (in bit) used in the construction of the various [`rug::Float`]/[`rug::Complex`] objects.
#[derive(Debug, Clone, PartialEq, PartialOrd)]
pub struct Rug<const PRECISION: u32>;

/// Trait used to indicate the type of floating point number that is used.
pub trait NumKernel: Clone + fmt::Debug + PartialEq + Sync {
    type RawRealType: Sized + fmt::Debug + RealValueValidator + PartialOrd<f64>;
    type RawComplexType: Sized + fmt::Debug + ComplexValueValidator<RealType = Self::RawRealType>;

    /// The type for a real scalar value in this numerical kernel.
    type RealType: FunctionsRealType<Self> + Serialize + DeserializeOwned;

    /// The type for a complex scalar value in this numerical kernel.
    type ComplexType: FunctionsComplexType<Self> + Serialize + DeserializeOwned;
}

/// Implement the [`NumKernel`] trait for [`Native64`]
impl NumKernel for Native64 {
    type RawRealType = f64;
    type RawComplexType = Complex<f64>;

    /// The type for a real scalar value in this numerical kernel.
    type RealType = f64;

    /// The type for a complex scalar value in this numerical kernel.
    type ComplexType = Complex<f64>;
}

/// Implement the [`NumKernel`] trait for Rug with arbitrary precision
#[cfg(feature = "rug")]
impl<const PRECISION: u32> NumKernel for Rug<PRECISION> {
    type RawRealType = rug::Float;
    type RawComplexType = rug::Complex;

    /// The type for a real scalar value in this numerical kernel.
    type RealType = RealRug<PRECISION>;

    /// The type for a complex scalar value in this numerical kernel.
    type ComplexType = ComplexRug<PRECISION>;
}

//------------------------------------------------------------------------------------------------

//------------------------------------------------------------------------------------------------
#[duplicate::duplicate_item(
    trait_name func_name trait_comment func_comment;
    [ACos] [acos_] ["This trait provides the interface for the *inverse cosine* function."] ["Computes the *inverse cosine* of `self`, rounding to the nearest."];
    [ASin] [asin_] ["This trait provides the interface for the *inverse sine* function."] ["Computes the *inverse sine* of `self`, rounding to the nearest."];
    [ATan] [atan_] ["This trait provides the interface for the *inverse tangent* function."] ["Computes the *inverse tangent* of `self`, rounding to the nearest."];
    [Cos] [cos_] ["This trait provides the interface for the *cosine* function."] ["Computes the *cosine* of `self`, rounding to the nearest."];
    [Sin] [sin_] ["This trait provides the interface for the *sine* function."] ["Computes the *sine* of `self`, rounding to the nearest."];
    [Tan] [tan_] ["This trait provides the interface for the *tangent* function."] ["Computes the *tangent* of `self`, rounding to the nearest."];
    [ACosH] [acosh_] ["This trait provides the interface for the *inverse hyperbolic cosine* function."] ["Computes the *inverse hyperbolic cosine* of `self`, rounding to the nearest."];
    [ASinH] [asinh_] ["This trait provides the interface for the *inverse hyperbolic* function."] ["Computes the *inverse hyperbolic sine* of `self`, rounding to the nearest."];
    [ATanH] [atanh_] ["This trait provides the interface for the *inverse hyperbolic tangent* function."] ["Computes the *inverse hyperbolic tangent* of `self`, rounding to the nearest."];
    [CosH] [cosh_] ["This trait provides the interface for the *hyperbolic cosine* function."] ["Computes the *hyperbolic cosine* of `self`, rounding to the nearest."];
    [SinH] [sinh_] ["This trait provides the interface for the *hyperbolic sine* function."] ["Computes the *hyperbolic sine* of `self`, rounding to the nearest."];
    [TanH] [tanh_] ["This trait provides the interface for the *hyperbolic tangent* function."] ["Computes the *tangent* of `self`, rounding to the nearest."];
    [Exp] [exp_] ["This trait provides the interface for the *exponential* function."] ["Computes `e^(self)`, rounding to the nearest."];
    [Ln] [ln_] ["This trait provides the interface for the [*natural logarithm*](https://en.wikipedia.org/wiki/Natural_logarithm) function."] ["Computes the [*natural logarithm*](https://en.wikipedia.org/wiki/Natural_logarithm) of `self`, rounding to the nearest."];
    [Log10] [log10_] ["This trait provides the interface for the [*common logarithm*](https://en.wikipedia.org/wiki/Common_logarithm) function."] ["Computes the [*common logarithm*](https://en.wikipedia.org/wiki/Common_logarithm) of `self`, rounding to the nearest."];
    [Log2] [log2_] ["This trait provides the interface for the *base 2 logarithm* function."] ["Computes the *base 2 logarithm* of `self`, rounding to the nearest."];
)]
#[doc = trait_comment]
pub trait trait_name {
    #[doc = func_comment]
    fn func_name(self) -> Self;
}

#[duplicate::duplicate_item(
    trait_name func_name implementation T func_comment;
    duplicate!{
        [
            T_nested; [f64]; [Complex::<f64>]
        ]
        [ACos] [acos_] [acos(self)] [T_nested] ["Computes the *inverse cosine* of `self`, rounding to the nearest."];
        [ASin] [asin_] [asin(self)] [T_nested] ["Computes the *inverse sine* of `self`, rounding to the nearest."];
        [ATan] [atan_] [atan(self)] [T_nested] ["Computes the *inverse tangent* of `self`, rounding to the nearest."];
        [Cos] [cos_] [cos(self)] [T_nested] ["Computes the *cosine* of `self`, rounding to the nearest."];
        [Sin] [sin_] [sin(self)] [T_nested] ["Computes the *sine* of `self`, rounding to the nearest."];
        [Tan] [tan_] [tan(self)] [T_nested] ["Computes the *tangent* of `self`, rounding to the nearest."];
        [ACosH] [acosh_] [acosh(self)] [T_nested] ["Computes the *inverse hyperbolic cosine* of `self`, rounding to the nearest."];
        [ASinH] [asinh_] [asinh(self)] [T_nested] ["Computes the *inverse hyperbolic sine* of `self`, rounding to the nearest."];
        [ATanH] [atanh_] [atanh(self)] [T_nested] ["Computes the *inverse hyperbolic tangent* of `self`, rounding to the nearest."];
        [CosH] [cosh_] [cosh(self)] [T_nested] ["Computes the *hyperbolic cosine* of `self`, rounding to the nearest."];
        [SinH] [sinh_] [sinh(self)] [T_nested] ["Computes the *hyperbolic sine* of `self`, rounding to the nearest."];
        [TanH] [tanh_] [tanh(self)] [T_nested] ["Computes the *hyperbolic tangent* of `self`, rounding to the nearest."];
        [Exp] [exp_] [exp(self)] [T_nested] ["Computes `e^(self)`, rounding to the nearest."];
        [Ln] [ln_] [ln(self)] [T_nested] ["Computes the [*natural logarithm*](https://en.wikipedia.org/wiki/Natural_logarithm) of `self`, rounding to the nearest."];
        [Log10] [log10_] [log10(self)] [T_nested] ["Computes the [*common logarithm*](https://en.wikipedia.org/wiki/Common_logarithm) of `self`, rounding to the nearest."];
        [Log2] [log2_] [log2(self)] [T_nested] ["Computes the *base 2 logarithm* of `self`, rounding to the nearest."];
    }
)]
impl trait_name for T {
    #[doc = func_comment]
    #[inline(always)]
    fn func_name(self) -> Self {
        T::implementation
    }
}

#[cfg(feature = "rug")]
#[duplicate_item(
    trait_name func_name implementation T func_comment;
    duplicate!{
        [
            T_nested; [RealRug<PRECISION>]; [ComplexRug<PRECISION>]
        ]
        [ACos] [acos_] [self.0.acos()] [T_nested] ["Computes the *inverse cosine* of `self`, rounding to the nearest."];
        [ASin] [asin_] [self.0.asin()] [T_nested] ["Computes the *inverse sine* of `self`, rounding to the nearest."];
        [ATan] [atan_] [self.0.atan()] [T_nested] ["Computes the *inverse tangent* of `self`, rounding to the nearest."];
        [Cos] [cos_] [self.0.cos()] [T_nested] ["Computes the *cosine* of `self`, rounding to the nearest."];
        [Sin] [sin_] [self.0.sin()] [T_nested] ["Computes the *sine* of `self`, rounding to the nearest."];
        [Tan] [tan_] [self.0.tan()] [T_nested] ["Computes the *tangent* of `self`, rounding to the nearest."];
        [ACosH] [acosh_] [self.0.acosh()] [T_nested] ["Computes the *inverse hyperbolic cosine* of `self`, rounding to the nearest."];
        [ASinH] [asinh_] [self.0.asinh()] [T_nested] ["Computes the *inverse hyperbolic sine* of `self`, rounding to the nearest."];
        [ATanH] [atanh_] [self.0.atanh()] [T_nested] ["Computes the *inverse hyperbolic tangent* of `self`, rounding to the nearest."];
        [CosH] [cosh_] [self.0.cosh()] [T_nested] ["Computes the *hyperbolic cosine* of `self`, rounding to the nearest."];
        [SinH] [sinh_] [self.0.sinh()] [T_nested] ["Computes the *hyperbolic sine* of `self`, rounding to the nearest."];
        [TanH] [tanh_] [self.0.tanh()] [T_nested] ["Computes the *hyperbolic tangent* of `self`, rounding to the nearest."];
        [Exp] [exp_] [self.0.exp()] [T_nested] ["Computes `e^(self)`, rounding to the nearest."];
        [Ln] [ln_] [self.0.ln()]  [T_nested] ["Computes the [*natural logarithm*](https://en.wikipedia.org/wiki/Natural_logarithm) of `self`, rounding to the nearest."];
        [Log10] [log10_] [self.0.log10()] [T_nested] ["Computes the [*common logarithm*](https://en.wikipedia.org/wiki/Common_logarithm) of `self`, rounding to the nearest."];
    }
)]
impl<const PRECISION: u32> trait_name for T {
    #[doc = func_comment]
    #[inline(always)]
    fn func_name(self) -> Self {
        Self(implementation)
    }
}

#[cfg(feature = "rug")]
impl<const PRECISION: u32> Log2 for RealRug<PRECISION> {
    /// Computes the *base 2 logarithm* of `self`, rounding to the nearest.
    #[inline(always)]
    fn log2_(self) -> Self {
        Self(self.0.log2())
    }
}

#[cfg(feature = "rug")]
impl<const PRECISION: u32> Log2 for ComplexRug<PRECISION> {
    /// Computes the *base 2 logarithm* of `self`, rounding to the nearest.
    #[inline(always)]
    fn log2_(self) -> Self {
        Self(rug::Complex::with_val(
            PRECISION,
            self.0.log10() / rug::Float::with_val(PRECISION, 2.).log10(),
        ))
    }
}
//------------------------------------------------------------------------------------------------

//------------------------------------------------------------------------------------------------
pub trait TrigonometricFunctions: ACos + ASin + ATan + Sin + Cos + Tan {}
impl TrigonometricFunctions for f64 {}
impl TrigonometricFunctions for Complex<f64> {}

#[cfg(feature = "rug")]
impl<const PRECISION: u32> TrigonometricFunctions for RealRug<PRECISION> {}

#[cfg(feature = "rug")]
impl<const PRECISION: u32> TrigonometricFunctions for ComplexRug<PRECISION> {}
//------------------------------------------------------------------------------------------------

//------------------------------------------------------------------------------------------------
pub trait HyperbolicFunctions: ACosH + ASinH + ATanH + SinH + CosH + TanH {}
impl HyperbolicFunctions for f64 {}
impl HyperbolicFunctions for Complex<f64> {}

#[cfg(feature = "rug")]
impl<const PRECISION: u32> HyperbolicFunctions for RealRug<PRECISION> {}

#[cfg(feature = "rug")]
impl<const PRECISION: u32> HyperbolicFunctions for ComplexRug<PRECISION> {}
//------------------------------------------------------------------------------------------------

//------------------------------------------------------------------------------------------------
#[duplicate::duplicate_item(
    trait_name func_name trait_comment func_comment;
    [IsFinite] [is_finite_] ["This trait provides the interface for the function used to check if a number is finite (i.e. neither infinite or NaN)."] ["Returns `true` if `self` is neither infinite nor NaN."];
    [IsInfinite] [is_infinite_] ["This trait provides the interface for the function used to check if a number is infinite."] ["Returns `true` if `self` is positive infinity or negative infinity."];
    [IsNaN] [is_nan_] ["This trait provides the interface for the function used to check if a value is NaN."] ["Returns `true` if `self` is NaN."];
    [IsNormal] [is_normal_] ["This trait provides the interface for the function used to check if a number is *normal* (i.e. neither zero, infinite, subnormal, or NaN)."] ["Returns `true` if `self` is *normal* (i.e. neither zero, infinite, subnormal, or NaN)."];
    [IsSubnormal] [is_subnormal_] ["This trait provides the interface for the function used to check if a number is *sub-normal*."] ["Returns `true` if `self` is *sub-normal*."];
)]
#[doc = trait_comment]
pub trait trait_name {
    #[doc = func_comment]
    fn func_name(&self) -> bool;
}

#[duplicate::duplicate_item(
    trait_name func_name implementation T func_comment;
    duplicate!{
        [
            T_nested; [f64]; [Complex<f64>]
        ]
        [IsFinite] [is_finite_] [self.is_finite()] [T_nested] ["Returns `true` if `self` is neither infinite nor NaN."];
        [IsInfinite] [is_infinite_] [self.is_infinite()] [T_nested] ["Returns `true` if `self` is positive infinity or negative infinity, and `false` otherwise."];
        [IsNaN] [is_nan_] [self.is_nan()] [T_nested] ["Returns `true` if `self` is NaN."];
        [IsNormal] [is_normal_] [self.is_normal()] [T_nested] ["Returns `true` if `self` is *normal* (i.e. neither zero, infinite, subnormal, or NaN)."];
    }
)]
impl trait_name for T {
    #[doc = func_comment]
    #[inline(always)]
    fn func_name(&self) -> bool {
        implementation
    }
}

impl IsSubnormal for f64 {
    /// Returns `true` if `self` is *sub-normal*
    #[inline(always)]
    fn is_subnormal_(&self) -> bool {
        self.classify() == FpCategory::Subnormal
    }
}

impl IsSubnormal for Complex<f64> {
    /// Returns `true` if `self` is *sub-normal*
    #[inline(always)]
    fn is_subnormal_(&self) -> bool {
        self.re.classify() == FpCategory::Subnormal || self.im.classify() == FpCategory::Subnormal
    }
}

#[cfg(feature = "rug")]
#[duplicate::duplicate_item(
    trait_name func_name implementation func_comment;
    [IsFinite] [is_finite_] [self.0.is_finite()] ["Returns `true` if `self` is neither infinite nor NaN."];
    [IsInfinite] [is_infinite_] [self.0.is_infinite()] ["Returns `true` if `self` is positive infinity or negative infinity, and `false` otherwise."];
    [IsNaN] [is_nan_] [self.0.is_nan()] ["Returns `true` if `self` is NaN."];
    [IsNormal] [is_normal_] [self.0.is_normal()] ["Returns `true` if `self` is *normal* (i.e. neither zero, infinite, subnormal, or NaN)."];
    [IsSubnormal] [is_subnormal_] [self.0.classify() == FpCategory::Subnormal] ["Returns `true` if `self` is *sub-normal*."];
)]
impl<const PRECISION: u32> trait_name for RealRug<PRECISION> {
    #[doc = func_comment]
    #[inline(always)]
    fn func_name(&self) -> bool {
        implementation
    }
}

#[cfg(feature = "rug")]
impl<const PRECISION: u32> IsFinite for ComplexRug<PRECISION> {
    /// Returns `true` if the real and imaginary parts of `self` are neither infinite nor NaN.
    #[inline(always)]
    fn is_finite_(&self) -> bool {
        self.0.real().is_finite() && self.0.imag().is_finite()
    }
}

#[cfg(feature = "rug")]
impl<const PRECISION: u32> IsInfinite for ComplexRug<PRECISION> {
    /// Returns `true` if the real or the imaginary part of `self` are positive infinity or negative infinity.
    #[inline(always)]
    fn is_infinite_(&self) -> bool {
        self.0.real().is_infinite() || self.0.imag().is_infinite()
    }
}

#[cfg(feature = "rug")]
impl<const PRECISION: u32> IsNaN for ComplexRug<PRECISION> {
    /// Returns `true` if the real or the imaginary part of `self` are NaN.
    #[inline(always)]
    fn is_nan_(&self) -> bool {
        self.0.real().is_nan() || self.0.imag().is_nan()
    }
}

#[cfg(feature = "rug")]
impl<const PRECISION: u32> IsNormal for ComplexRug<PRECISION> {
    /// Returns `true` if the real and the imaginary part of `self` are *normal* (i.e. neither zero, infinite, subnormal, or NaN).
    #[inline(always)]
    fn is_normal_(&self) -> bool {
        self.0.real().is_normal() && self.0.imag().is_normal()
    }
}

#[cfg(feature = "rug")]
impl<const PRECISION: u32> IsSubnormal for ComplexRug<PRECISION> {
    /// Returns `true` if the real and the imaginary part of `self` are *normal* (i.e. neither zero, infinite, subnormal, or NaN).
    #[inline(always)]
    fn is_subnormal_(&self) -> bool {
        self.0.real().classify() == FpCategory::Subnormal
            || self.0.imag().classify() == FpCategory::Subnormal
    }
}
//------------------------------------------------------------------------------------------------

//------------------------------------------------------------------------------------------------
pub trait FpChecks: IsFinite + IsInfinite + IsNaN + IsNormal + IsSubnormal {}
impl FpChecks for f64 {}
impl FpChecks for Complex<f64> {}

#[cfg(feature = "rug")]
impl<const PRECISION: u32> FpChecks for RealRug<PRECISION> {}

#[cfg(feature = "rug")]
impl<const PRECISION: u32> FpChecks for ComplexRug<PRECISION> {}
//------------------------------------------------------------------------------------------------

//------------------------------------------------------------------------------------------------
#[cfg(feature = "rug")]
impl<const PRECISION: u32> Zero for RealRug<PRECISION> {
    /// Returns the value `zero`.
    fn zero() -> Self {
        Self(rug::Float::with_val(PRECISION, 0.))
    }

    /// Returns `true` if `self` is `+0.0` or `-0.0`.
    fn is_zero(&self) -> bool {
        self.0.is_zero()
    }
}

#[cfg(feature = "rug")]
impl<const PRECISION: u32> Zero for ComplexRug<PRECISION> {
    /// Returns the value `zero`.
    fn zero() -> Self {
        Self(rug::Complex::with_val(PRECISION, (0., 0.)))
    }

    /// Returns `true` if `self` is zero.
    fn is_zero(&self) -> bool {
        self.0.is_zero()
    }
}
//------------------------------------------------------------------------------------------------

//------------------------------------------------------------------------------------------------
#[cfg(feature = "rug")]
impl<const PRECISION: u32> One for RealRug<PRECISION> {
    /// Returns the value `1`.
    fn one() -> Self {
        Self(rug::Float::with_val(PRECISION, 1.))
    }
}
//------------------------------------------------------------------------------------------------

//------------------------------------------------------------------------------------------------
/// This trait provide the interface of the function for performing a multiplication and an addition in one fused operation.
///
/// # Note
/// The difference between this trait and [`num::traits::MulAdd`] is that this trait uses references as input arguments
/// instead of values as used by the function [`num::traits::MulAdd::mul_add()`].
pub trait MulAdd {
    /// Multiplies and adds in one fused operation, rounding to the nearest with only one rounding error.
    ///
    /// `a.mul_add(b, c)` produces a result like `a * &b + &c`.
    fn mul_add(self, b: &Self, c: &Self) -> Self;
}

#[duplicate::duplicate_item(
    T trait_comment;
    [f64] ["Implementation of the [`MulAdd`] trait for `f64`."];
    [Complex<f64>] ["Implementation of the [`MulAdd`] trait for `Complex<f64>`."];
)]
#[doc = trait_comment]
impl MulAdd for T {
    /// Multiplies and adds in one fused operation, rounding to the nearest with only one rounding error.
    ///
    /// `a.mul_add(b, c)` produces a result like `a * &b + &c`.
    #[inline(always)]
    fn mul_add(self, b: &Self, c: &Self) -> Self {
        <Self as num::traits::MulAdd>::mul_add(self, *b, *c)
    }
}

#[cfg(feature = "rug")]
#[duplicate::duplicate_item(
    T trait_comment;
    [RealRug<PRECISION>] ["Implementation of the [`MulAdd`] trait for [`RealRug`]."];
    [ComplexRug<PRECISION>] ["Implementation of the [`MulAdd`] trait for [`ComplexRug`]."];
)]
#[doc = trait_comment]
impl<const PRECISION: u32> MulAdd for T {
    /// Multiplies and adds in one fused operation, rounding to the nearest with only one rounding error.
    ///
    /// `a.mul_add(b, c)` produces a result like `a * &b + &c`.
    #[inline(always)]
    fn mul_add(self, b: &Self, c: &Self) -> Self {
        Self(self.0.mul_add(&b.0, &c.0))
    }
}
//------------------------------------------------------------------------------------------------

//------------------------------------------------------------------------------------------------
/// This trait represents the functions that can be applied on real and complex numbers.
pub trait FunctionsGeneralType<T: NumKernel>:
    Clone
    + fmt::Debug
    + fmt::Display
    + Arithmetic
    + Sqrt
    + PowTrait<T>
    + TrigonometricFunctions
    + HyperbolicFunctions
    + Exp
    + Ln
    + Log10
    + Log2
    + Zero
    + Abs<Output = T::RealType>
    + FpChecks
    + Neg<Output = Self>
    + MulAdd
    + Reciprocal
    + Send
    + Sync
{
}
//-------------------------------------------------------------------------------------------------------------

//-------------------------------------------------------------------------------------------------------------
pub trait TryNew: Sized {
    type ValueType;
    type Error;

    fn try_new(value: Self::ValueType) -> Result<Self, Self::Error>;

    fn new(value: Self::ValueType) -> Self;
}

impl TryNew for f64 {
    type ValueType = f64;
    type Error = RealValueErrors<f64>;

    #[inline(always)]
    fn try_new(value: Self::ValueType) -> Result<Self, Self::Error> {
        value.validate()
    }

    #[inline(always)]
    fn new(value: Self::ValueType) -> Self {
        if cfg!(debug_assertions) {
            Self::try_new(value).unwrap()
        } else {
            value
        }
    }
}

impl TryNew for Complex<f64> {
    type ValueType = Complex<f64>;
    type Error = ComplexValueErrors<f64, Complex<f64>>;

    #[inline(always)]
    fn try_new(value: Self::ValueType) -> Result<Self, Self::Error> {
        value.validate()
    }

    #[inline(always)]
    fn new(value: Self::ValueType) -> Self {
        if cfg!(debug_assertions) {
            Self::try_new(value).unwrap()
        } else {
            value
        }
    }
}

#[cfg(feature = "rug")]
impl<const PRECISION: u32> TryNew for RealRug<PRECISION> {
    type ValueType = rug::Float;
    type Error = RealValueErrors<rug::Float>;

    #[inline(always)]
    fn try_new(value: Self::ValueType) -> Result<Self, Self::Error> {
        assert_eq!(value.prec(), PRECISION,
            "The precision of the numerical kernel ({PRECISION}) and is different from the precision of the input value ({})!",value.prec());

        let value = value.validate()?;
        Ok(Self(value))
    }

    #[inline(always)]
    fn new(value: Self::ValueType) -> Self {
        if cfg!(debug_assertions) {
            Self::try_new(value).unwrap()
        } else {
            Self(value)
        }
    }
}

#[cfg(feature = "rug")]
impl<const PRECISION: u32> TryNew for ComplexRug<PRECISION> {
    type ValueType = rug::Complex;
    type Error = ComplexValueErrors<rug::Float, rug::Complex>;

    #[inline(always)]
    fn try_new(value: Self::ValueType) -> Result<Self, Self::Error> {
        assert_eq!(value.prec(), (PRECISION, PRECISION),
            "The precision of the numerical kernel ({PRECISION}) and is different from the precision of the input value ({:?})!",value.prec());

        let value = value.validate()?;
        Ok(Self(value))
    }

    #[inline(always)]
    fn new(value: Self::ValueType) -> Self {
        if cfg!(debug_assertions) {
            Self::try_new(value).unwrap()
        } else {
            Self(value)
        }
    }
}

//-------------------------------------------------------------------------------------------------------------

//-------------------------------------------------------------------------------------------------------------
/// This trait represents the functions that can be applied on real numbers.
pub trait FunctionsRealType<T: NumKernel>:
    FunctionsGeneralType<T>
    + PartialEq
    + PartialEq<f64>
    + PartialOrd
    + PartialOrd<f64>
    + MulComplexRight<T>
    + One
{
    /// 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)`
    fn atan2_(self, other: &Self) -> Self;

    /// Returns the smallest integer greater than or equal to `self`.
    fn ceil_(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::{FunctionsGeneralType, 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 clamp_(self, min: &Self, max: &Self) -> Self;

    /// 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 classify_(&self) -> FpCategory;

    /// Returns a number with the magnitude of `self` and the sign of `sign`.
    fn copysign_(self, sign: &Self) -> Self;

    /// [Machine epsilon] value for `Self`.
    ///
    /// This is the difference between `1.0` and the next larger representable number.
    ///
    /// [Machine epsilon]: https://en.wikipedia.org/wiki/Machine_epsilon
    fn epsilon_() -> Self;

    /// Returns `e^(self) - 1`` in a way that is accurate even if the number is close to zero.
    fn exp_m1_(self) -> Self;

    /// Returns the largest integer smaller than or equal to `self`.
    fn floor_(self) -> Self;

    /// Returns the fractional part of `self`.
    fn fract_(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 hypot_(self, other: &Self) -> Self;

    /// Returns the special value representing the *positive infinity*.
    fn infinity_() -> Self;

    /// Returns `true` if the value is negative, −0 or NaN with a negative sign.
    fn is_sign_negative_(&self) -> bool;

    /// Returns `true` if the value is positive, +0 or NaN with a positive sign.
    fn is_sign_positive_(&self) -> bool;

    /// Returns `ln(1. + self)` (natural logarithm) more accurately than if the operations were performed separately.
    fn ln_1p_(self) -> Self;

    /// Returns the special value representing the *negative infinity*.
    fn neg_infinity_() -> Self;

    /// Computes the maximum between `self` and `other`.
    fn max_(self, other: &Self) -> Self;

    /// Computes the minimum between `self` and `other`.
    fn min_(self, other: &Self) -> 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_add_mul_mut_(&mut self, mul: &Self, add_mul1: &Self, add_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 mul_sub_mul_mut_(&mut self, mul: &Self, sub_mul1: &Self, sub_mul2: &Self);

    /// Build and return the (floating point) value -1. represented by the proper type.
    fn negative_one_() -> Self;

    /// Build and return the (floating point) value 0.5 represented by the proper type.
    fn one_div_2_() -> Self;

    /// Build and return the (floating point) value π represented by the proper type.
    fn pi_() -> Self {
        Self::negative_one_().acos_()
    }

    /// Build and return the (floating point) value π/2 represented by the proper type.
    fn pi_div_2_() -> Self {
        Self::one().asin_()
    }

    /// Rounds `self` to the nearest integer, rounding half-way cases away from zero.
    fn round_(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 round_ties_even_(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 signum_(self) -> Self;

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

    /// Try to build a `Self` from a [`f64`].
    /// The returned value is `Ok` if the input `value` is finite and can be exactly represented by `T::RealType`,
    /// otherwise the returned value is `TryFromf64Errors`.
    fn try_from_f64_(value: f64) -> Result<Self, TryFromf64Errors>;

    /// 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 trunc_(self) -> Self;

    /// Build and return the (floating point) value 1. represented by the proper type.
    fn two_() -> Self;
}

/// This trait represents the functions that can be applied on complex numbers.
pub trait FunctionsComplexType<T: NumKernel>:
    FunctionsGeneralType<T> + PartialEq + MulComplexLeft<T>
{
    /// Computes the principal Arg of `self`.
    fn arg_(self) -> T::RealType;

    /// Creates a complex number of type `T::ComplexType` from its real and imaginary parts.
    fn new_(real_part: T::RealType, imag_part: T::RealType) -> Self;

    /// Get the real part of the complex number.
    fn real_(&self) -> T::RealType;

    /// Get the imaginary part of the complex number.
    fn imag_(&self) -> T::RealType;

    /// Set the value of the real part.
    fn set_real_(&mut self, real_part: T::RealType);

    /// Set the value of the imaginary part.
    fn set_imag_(&mut self, imag_part: T::RealType);

    /// Add the value of the the real coefficient `c` to real part of `self`.
    fn add_real_(&mut self, c: &T::RealType);

    /// Add the value of the the real coefficient `c` to imaginary part of `self`.
    fn add_imag_(&mut self, c: &T::RealType);

    /// Multiply the value of the real part by the real coefficient `c`.
    fn multiply_real_(&mut self, c: &T::RealType);

    /// Multiply the value of the imaginary part by the real coefficient `c`.
    fn multiply_imag_(&mut self, c: &T::RealType);

    /// Computes the complex conjugate.
    fn conj_(self) -> Self;

    /// 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`.
    fn try_from_f64_(real_part: f64, imag_part: f64) -> Result<Self, TryFromf64Errors>;
}

impl FunctionsGeneralType<Native64> for f64 {}

impl FunctionsGeneralType<Native64> for Complex<f64> {}

impl FunctionsRealType<Native64> for f64 {
    /// 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);
    /// ```
    #[inline(always)]
    fn atan2_(self, other: &Self) -> Self {
        self.atan2(*other)
    }

    /// Returns the smallest integer greater than or equal to `self`.
    #[inline(always)]
    fn ceil_(self) -> Self {
        self.ceil()
    }

    /// 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_());
    /// ```
    #[inline(always)]
    fn clamp_(self, min: &Self, max: &Self) -> Self {
        self.clamp(*min, *max)
    }

    /// 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);
    /// ```
    #[inline(always)]
    fn classify_(&self) -> FpCategory {
        self.classify()
    }

    /// Returns a number with the magnitude of `self` and the sign of `sign`.
    #[inline(always)]
    fn copysign_(self, sign: &Self) -> Self {
        self.copysign(*sign)
    }

    /// [Machine epsilon] value for `f64`.
    ///
    /// This is the difference between `1.0` and the next larger representable number.
    ///
    /// [Machine epsilon]: https://en.wikipedia.org/wiki/Machine_epsilon
    #[inline(always)]
    fn epsilon_() -> Self {
        f64::EPSILON
    }

    /// Returns `e^(self) - 1`` in a way that is accurate even if the number is close to zero.
    #[inline(always)]
    fn exp_m1_(self) -> Self {
        self.exp_m1()
    }

    /// Returns the largest integer smaller than or equal to `self`.
    #[inline(always)]
    fn floor_(self) -> Self {
        self.floor()
    }

    /// Returns the fractional part of `self`.
    #[inline(always)]
    fn fract_(self) -> Self {
        self.fract()
    }

    /// 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()`.
    #[inline(always)]
    fn hypot_(self, other: &Self) -> Self {
        self.hypot(*other)
    }

    /// Returns the special value representing the *positive infinity*.
    #[inline(always)]
    fn infinity_() -> Self {
        f64::INFINITY
    }

    /// Returns `true` if the value is negative, −0 or NaN with a negative sign.
    #[inline(always)]
    fn is_sign_negative_(&self) -> bool {
        self.is_sign_negative()
    }

    /// Returns `true` if the value is positive, +0 or NaN with a positive sign.
    #[inline(always)]
    fn is_sign_positive_(&self) -> bool {
        self.is_sign_positive()
    }

    /// Returns `ln(1. + self)` (natural logarithm) more accurately than if the operations were performed separately.
    #[inline(always)]
    fn ln_1p_(self) -> Self {
        self.ln_1p()
    }

    /// Returns the special value representing the *negative infinity*.
    #[inline(always)]
    fn neg_infinity_() -> Self {
        f64::NEG_INFINITY
    }

    /// Computes the maximum between `self` and `other`.
    #[inline(always)]
    fn max_(self, other: &Self) -> Self {
        self.max(*other)
    }

    /// Computes the minimum between `self` and `other`.
    #[inline(always)]
    fn min_(self, other: &Self) -> Self {
        self.min(*other)
    }

    /// 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.
    #[inline(always)]
    fn mul_add_mul_mut_(&mut self, mul: &Self, add_mul1: &Self, add_mul2: &Self) {
        self.mul_add_assign(*mul, add_mul1 * add_mul2);
    }

    /// 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.
    #[inline(always)]
    fn mul_sub_mul_mut_(&mut self, mul: &Self, sub_mul1: &Self, sub_mul2: &Self) {
        self.mul_add_assign(*mul, -sub_mul1 * sub_mul2);
    }

    /// Build and return the (floating point) value -1. represented by a `f64`.
    #[inline(always)]
    fn negative_one_() -> Self {
        -1.
    }

    /// Build and return the (floating point) value 0.5 represented by the proper type.
    #[inline(always)]
    fn one_div_2_() -> Self {
        0.5
    }

    /// Rounds `self` to the nearest integer, rounding half-way cases away from zero.
    #[inline(always)]
    fn round_(self) -> Self {
        self.round()
    }

    /// 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);
    /// ```
    #[inline(always)]
    fn round_ties_even_(self) -> Self {
        self.round_ties_even()
    }

    /// 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
    #[inline(always)]
    fn signum_(self) -> Self {
        self.signum()
    }

    #[inline(always)]
    fn total_cmp_(&self, other: &Self) -> Ordering {
        self.total_cmp(other)
    }

    /// 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`.
    #[inline(always)]
    fn try_from_f64_(value: f64) -> Result<Self, TryFromf64Errors> {
        match value.validate() {
            Ok(value) => Ok(value),
            Err(e) => Err(TryFromf64Errors::ValidationError { source: e }),
        }
    }

    /// 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);
    /// ```
    #[inline(always)]
    fn trunc_(self) -> Self {
        self.trunc()
    }

    /// Build and return the (floating point) value 2. represented by a `f64`.
    #[inline(always)]
    fn two_() -> Self {
        2.
    }
}

/// Implement the `IntoInner` trait for the `Complex<f64>` type.
impl IntoInner for Complex<f64> {
    /// The inner type of the `Complex<f64>` type.
    type Target = (f64, f64);

    /// Convert the `Complex<f64>` type into its inner type `(f64, f64)` corresponding to the real and imaginary part.
    #[inline(always)]
    fn into_inner(self) -> Self::Target {
        (self.re, self.im)
    }
}

/// Implement the `FunctionsComplexType` trait for the `Complex<f64>` type.
impl FunctionsComplexType<Native64> for Complex<f64> {
    /// Computes the principal Arg of `self`.
    #[inline(always)]
    fn arg_(self) -> f64 {
        self.arg()
    }

    /// 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.
    #[inline(always)]
    fn new_(real_part: f64, imag_part: f64) -> Self {
        debug_assert!(
            real_part.is_finite(),
            "The real part is not finite (i.e. is infinite or NaN)."
        );
        debug_assert!(
            imag_part.is_finite(),
            "The imaginary part is not finite (i.e. is infinite or NaN)."
        );
        Complex::new(real_part, imag_part)
    }

    /// Get the real part of the complex number.
    #[inline(always)]
    fn real_(&self) -> f64 {
        self.re
    }

    /// Get the imaginary part of the complex number.
    #[inline(always)]
    fn imag_(&self) -> f64 {
        self.im
    }

    /// Set the value of the real part.
    ///
    /// # Panics
    /// In debug mode a `panic!` will be emitted if `real_part` is not finite.
    #[inline(always)]
    fn set_real_(&mut self, real_part: f64) {
        debug_assert!(
            real_part.is_finite(),
            "The real part is not finite (i.e. is infinite or NaN)."
        );
        self.re = real_part;
    }

    /// Set the value of the imaginary part.
    ///
    /// # Panics
    /// In debug mode a `panic!` will be emitted if `imaginary_part` is not finite.
    #[inline(always)]
    fn set_imag_(&mut self, imag_part: f64) {
        debug_assert!(
            imag_part.is_finite(),
            "The imaginary part is not finite (i.e. is infinite or NaN)."
        );
        self.im = imag_part;
    }

    /// Add the value of the the real coefficient `c` to real part of `self`.
    #[inline(always)]
    fn add_real_(&mut self, c: &f64) {
        self.re += c;

        debug_assert!(
            self.re.is_finite(),
            "The real part is not finite (i.e. is infinite or NaN)."
        );
    }

    /// Add the value of the the real coefficient `c` to imaginary part of `self`.
    #[inline(always)]
    fn add_imag_(&mut self, c: &f64) {
        self.im += c;

        debug_assert!(
            self.im.is_finite(),
            "The imaginary part is not finite (i.e. is infinite or NaN)."
        );
    }

    /// Multiply the value of the real part by the real coefficient `c`.
    #[inline(always)]
    fn multiply_real_(&mut self, c: &f64) {
        self.re *= c;

        debug_assert!(
            self.re.is_finite(),
            "The real part is not finite (i.e. is infinite or NaN)."
        );
    }

    /// Multiply the value of the imaginary part by the real coefficient `c`.
    #[inline(always)]
    fn multiply_imag_(&mut self, c: &f64) {
        self.im *= c;

        debug_assert!(
            self.im.is_finite(),
            "The imaginary part is not finite (i.e. is infinite or NaN)."
        );
    }

    /// Computes the complex conjugate.
    #[inline(always)]
    fn conj_(self) -> Self {
        self.conj()
    }

    /// 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`.
    #[inline(always)]
    fn try_from_f64_(real_part: f64, imag_part: f64) -> Result<Self, TryFromf64Errors> {
        let real_part = <f64 as FunctionsRealType<Native64>>::try_from_f64_(real_part)?;
        let imag_part = <f64 as FunctionsRealType<Native64>>::try_from_f64_(imag_part)?;

        Ok(Complex::new(real_part, imag_part))
    }
}

//------------------------------------------------------------------------------------------------------------

//------------------------------------------------------------------------------------------------------------
// Conditional compilation for the `rug` feature
#[cfg(feature = "rug")]
#[derive(
    Add,
    AddAssign,
    AsRef,
    Clone,
    Debug,
    Deserialize,
    Display,
    Div,
    DivAssign,
    LowerExp,
    Mul,
    MulAssign,
    Neg,
    PartialEq,
    PartialOrd,
    Serialize,
    Sub,
    SubAssign,
)]
#[mul(forward)]
#[mul_assign(forward)]
#[div(forward)]
#[div_assign(forward)]
pub struct RealRug<const PRECISION: u32>(rug::Float);

// Conditional compilation for the `rug` feature
#[cfg(feature = "rug")]
impl<const PRECISION: u32> RealRug<PRECISION> {
    #[inline(always)]
    pub fn new(value: rug::Float) -> Self {
        debug_assert!(value.is_finite(), "Not a finite number!");
        debug_assert_eq!(
            value.prec(),
            PRECISION,
            "The input value must have a precision = {PRECISION}, but actually has precision = {}",
            value.prec()
        );
        Self(value)
    }
}

// Conditional compilation for the `rug` feature
#[cfg(feature = "rug")]
#[derive(
    Add,
    AddAssign,
    AsRef,
    Clone,
    Debug,
    Deserialize,
    Display,
    Div,
    DivAssign,
    LowerExp,
    Mul,
    MulAssign,
    Neg,
    PartialEq,
    Serialize,
    Sub,
    SubAssign,
)]
#[mul(forward)]
#[mul_assign(forward)]
#[div(forward)]
#[div_assign(forward)]
pub struct ComplexRug<const PRECISION: u32>(rug::Complex);

// Conditional compilation for the `rug` feature
#[cfg(feature = "rug")]
impl<const PRECISION: u32> ComplexRug<PRECISION> {
    #[inline(always)]
    pub fn new(value: rug::Complex) -> Self {
        debug_assert!(
            value.real().is_finite() && value.imag().is_finite(),
            "Not a finite number!"
        );
        debug_assert_eq!(
            value.prec(),
            (PRECISION, PRECISION),
            "The input value must have a precision = {:?}, but actually has precision = {:?}",
            (PRECISION, PRECISION),
            value.prec()
        );
        Self(value)
    }
}

#[cfg(feature = "rug")]
impl<const PRECISION: u32> IntoInner for ComplexRug<PRECISION> {
    type Target = (RealRug<PRECISION>, RealRug<PRECISION>);

    #[inline(always)]
    fn into_inner(self) -> Self::Target {
        (
            RealRug::new(self.0.real().clone()),
            RealRug::new(self.0.imag().clone()),
        )
    }
}

// Conditional compilation for the `rug` feature
#[cfg(feature = "rug")]
#[duplicate_item(
    T;
    [RealRug<PRECISION>];
    [ComplexRug<PRECISION>];
)]
impl<const PRECISION: u32> NegAssign for T {
    /// Performs the negation of `self`.
    #[inline(always)]
    fn neg_assign(&mut self) {
        rug::ops::NegAssign::neg_assign(&mut self.0);
    }
}

// Conditional compilation for the `rug` feature
#[cfg(feature = "rug")]
#[duplicate_item(
    trait_name method T;
    duplicate!{
        [
            rug_type;[RealRug];[ComplexRug]
        ]
        [Add] [add] [rug_type];
        [Sub] [sub] [rug_type];
        [Mul] [mul] [rug_type];
    }
)]
impl<'a, const PRECISION: u32> trait_name<&'a T<PRECISION>> for T<PRECISION> {
    type Output = T<PRECISION>;

    #[inline(always)]
    fn method(self, rhs: &'a T<PRECISION>) -> Self::Output {
        T(self.0.method(&rhs.0))
    }
}

// Conditional compilation for the `rug` feature
#[cfg(feature = "rug")]
#[duplicate_item(
    trait_name method T;
    duplicate!{
        [
            rug_type;[RealRug];[ComplexRug]
        ]
        [Add] [add] [rug_type];
        [Sub] [sub] [rug_type];
        [Mul] [mul] [rug_type];
    }
)]
impl<'a, const PRECISION: u32> trait_name<T<PRECISION>> for &T<PRECISION> {
    type Output = T<PRECISION>;

    #[inline(always)]
    fn method(self, rhs: T<PRECISION>) -> Self::Output {
        let lhs = &self.0;
        T(lhs.method(rhs.0))
    }
}

// Conditional compilation for the `rug` feature
#[cfg(feature = "rug")]
#[duplicate_item(
    T;
    [RealRug];
    [ComplexRug];
)]
impl<'a, const PRECISION: u32> Div<&'a T<PRECISION>> for T<PRECISION> {
    type Output = T<PRECISION>;

    #[inline(always)]
    fn div(self, rhs: &'a T<PRECISION>) -> Self::Output {
        debug_assert!(!rhs.0.is_zero(), "Division by zero!");
        T(self.0.div(&rhs.0))
    }
}

// Conditional compilation for the `rug` feature
#[cfg(feature = "rug")]
#[duplicate_item(
    T;
    [RealRug];
    [ComplexRug];
)]
impl<'a, const PRECISION: u32> Div<T<PRECISION>> for &T<PRECISION> {
    type Output = T<PRECISION>;

    #[inline(always)]
    fn div(self, rhs: T<PRECISION>) -> Self::Output {
        debug_assert!(!rhs.0.is_zero(), "Division by zero!");
        let lhs = &self.0;
        T(lhs.div(rhs.0))
    }
}

// Conditional compilation for the `rug` feature
#[cfg(feature = "rug")]
#[duplicate_item(
    trait_name method T;
    duplicate!{
        [
            rug_type;[RealRug];[ComplexRug]
        ]
        [AddAssign] [add_assign] [rug_type];
        [SubAssign] [sub_assign] [rug_type];
        [MulAssign] [mul_assign] [rug_type];
    }
)]
impl<'a, const PRECISION: u32> trait_name<&'a T<PRECISION>> for T<PRECISION> {
    #[inline(always)]
    fn method(&mut self, rhs: &'a T<PRECISION>) {
        self.0.method(&rhs.0);
    }
}

// Conditional compilation for the `rug` feature
#[cfg(feature = "rug")]
impl<'a, const PRECISION: u32> Mul<RealRug<PRECISION>> for ComplexRug<PRECISION> {
    type Output = ComplexRug<PRECISION>;

    #[inline(always)]
    fn mul(self, rhs: RealRug<PRECISION>) -> ComplexRug<PRECISION> {
        Self(self.0.mul(rhs.0))
    }
}

// Conditional compilation for the `rug` feature
#[cfg(feature = "rug")]
impl<'a, const PRECISION: u32> Mul<&'a RealRug<PRECISION>> for ComplexRug<PRECISION> {
    type Output = ComplexRug<PRECISION>;

    #[inline(always)]
    fn mul(self, rhs: &'a RealRug<PRECISION>) -> ComplexRug<PRECISION> {
        Self(self.0.mul(&rhs.0))
    }
}

// Conditional compilation for the `rug` feature
#[cfg(feature = "rug")]
impl<'a, const PRECISION: u32> MulAssign<RealRug<PRECISION>> for ComplexRug<PRECISION> {
    #[inline(always)]
    fn mul_assign(&mut self, rhs: RealRug<PRECISION>) {
        self.0.mul_assign(rhs.0);
    }
}

// Conditional compilation for the `rug` feature
#[cfg(feature = "rug")]
impl<'a, const PRECISION: u32> MulAssign<&'a RealRug<PRECISION>> for ComplexRug<PRECISION> {
    #[inline(always)]
    fn mul_assign(&mut self, rhs: &'a RealRug<PRECISION>) {
        self.0.mul_assign(&rhs.0);
    }
}

// Conditional compilation for the `rug` feature
#[cfg(feature = "rug")]
#[duplicate_item(
    T;
    [RealRug<PRECISION>];
    [ComplexRug<PRECISION>];
)]
impl<'a, const PRECISION: u32> DivAssign<&'a T> for T {
    #[inline(always)]
    fn div_assign(&mut self, rhs: &'a T) {
        debug_assert!(!rhs.0.is_zero(), "Division by zero!");
        self.0.div_assign(&rhs.0);
    }
}

// Conditional compilation for the `rug` feature
#[cfg(feature = "rug")]
impl<const PRECISION: u32> Arithmetic for RealRug<PRECISION> {}

// Conditional compilation for the `rug` feature
#[cfg(feature = "rug")]
impl<const PRECISION: u32> Arithmetic for ComplexRug<PRECISION> {}

// Conditional compilation for the `rug` feature
#[cfg(feature = "rug")]
#[duplicate::duplicate_item(
    exponent_type T;
    duplicate!{
        [
            rug_type;[RealRug<PRECISION>];[ComplexRug<PRECISION>]
        ]
    [i8]          [rug_type];
    [u8]          [rug_type];
    [i16]         [rug_type];
    [u16]         [rug_type];
    [i32]         [rug_type];
    [u32]         [rug_type];
    [i64]         [rug_type];
    [u64]         [rug_type];
    [i128]        [rug_type];
    [u128]        [rug_type];
    [usize]       [rug_type];
    }
)]
impl<const PRECISION: u32> Pow<exponent_type> for T {
    /// Raises th number `self` to the power `exponent`.
    #[inline(always)]
    fn pow_(self, exponent: exponent_type) -> Self {
        Self(self.0.pow(exponent))
    }
}

// Conditional compilation for the `rug` feature
#[cfg(feature = "rug")]
#[duplicate::duplicate_item(
    T;
    [RealRug<PRECISION>];
    [ComplexRug<PRECISION>];
)]
impl<const PRECISION: u32> Pow<RealRug<PRECISION>> for T {
    /// Raises th number `self` to the power `exponent`.
    #[inline(always)]
    fn pow_(self, exponent: RealRug<PRECISION>) -> Self {
        Self(self.0.pow(exponent.0))
    }
}

// Conditional compilation for the `rug` feature
#[cfg(feature = "rug")]
impl<const PRECISION: u32> PowTrait<Rug<PRECISION>> for RealRug<PRECISION> {}

// Conditional compilation for the `rug` feature
#[cfg(feature = "rug")]
impl<const PRECISION: u32> PowTrait<Rug<PRECISION>> for ComplexRug<PRECISION> {}

// Conditional compilation for the `rug` feature
#[cfg(feature = "rug")]
impl<const PRECISION: u32> PartialEq<f64> for RealRug<PRECISION> {
    #[inline(always)]
    fn eq(&self, other: &f64) -> bool {
        self.0.eq(other)
    }
}

// Conditional compilation for the `rug` feature
#[cfg(feature = "rug")]
impl<const PRECISION: u32> PartialOrd<f64> for RealRug<PRECISION> {
    #[inline(always)]
    fn partial_cmp(&self, other: &f64) -> Option<Ordering> {
        self.0.partial_cmp(other)
    }
}

// Conditional compilation for the `rug` feature
#[cfg(feature = "rug")]
impl<const PRECISION: u32> FunctionsGeneralType<Rug<PRECISION>> for RealRug<PRECISION> {}

// Conditional compilation for the `rug` feature
#[cfg(feature = "rug")]
impl<const PRECISION: u32> FunctionsRealType<Rug<PRECISION>> for RealRug<PRECISION> {
    /// 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::{
    ///     FunctionsRealType, RealRug,
    ///     functions::Abs,
    /// };
    ///
    /// const PRECISION: u32 = 100;
    ///
    /// let y = RealRug::<PRECISION>::try_from_f64_(3.).unwrap();
    /// let x = RealRug::<PRECISION>::try_from_f64_(-4.).unwrap();
    /// let atan2 = y.clone().atan2_(&x);
    /// let expected = RealRug::<PRECISION>::try_from_f64_(2.4981).unwrap();
    /// assert!((atan2 - expected).abs() < 0.0001);
    /// ```
    #[inline(always)]
    fn atan2_(self, other: &Self) -> Self {
        Self(self.0.atan2(&other.0))
    }

    /// Returns the smallest integer greater than or equal to `self`.
    #[inline(always)]
    fn ceil_(self) -> Self {
        Self(self.0.ceil())
    }

    /// Clamps the value within the specified bounds.
    #[inline(always)]
    fn clamp_(self, min: &Self, max: &Self) -> Self {
        Self(self.0.clamp(&min.0, &max.0))
    }

    /// 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, RealRug};
    /// use std::num::FpCategory;
    ///
    /// const PRECISION: u32 = 100;
    ///
    /// let num = RealRug::<PRECISION>::try_from_f64_(12.4).unwrap();
    /// let inf = RealRug::<PRECISION>::infinity_();
    ///
    /// assert_eq!(num.classify_(), FpCategory::Normal);
    /// assert_eq!(inf.classify_(), FpCategory::Infinite);
    /// ```
    #[inline(always)]
    fn classify_(&self) -> FpCategory {
        self.0.classify()
    }

    /// Returns a number with the magnitude of `self` and the sign of `sign`.
    #[inline(always)]
    fn copysign_(self, sign: &Self) -> Self {
        Self(self.0.copysign(&sign.0))
    }

    /// [Machine epsilon] value for `rug::Float` with the given `PRECISION` (in bits).
    ///
    /// It is equal to `2^(1-PRECISION)` and it is the difference between `1.0` and the next larger representable number.
    ///
    /// [Machine epsilon]: https://en.wikipedia.org/wiki/Machine_epsilon
    #[inline(always)]
    fn epsilon_() -> Self {
        Self(
            rug::Float::u_pow_u(2, PRECISION - 1)
                .complete(PRECISION.into())
                .recip(),
        )
    }

    /// Returns `e^(self) - 1`` in a way that is accurate even if the number is close to zero.
    #[inline(always)]
    fn exp_m1_(self) -> Self {
        Self(self.0.exp_m1())
    }

    /// Returns the largest integer smaller than or equal to `self`.
    #[inline(always)]
    fn floor_(self) -> Self {
        Self(self.0.floor())
    }

    /// Returns the fractional part of `self`.
    #[inline(always)]
    fn fract_(self) -> Self {
        Self(self.0.fract())
    }

    /// 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()`.
    #[inline(always)]
    fn hypot_(self, other: &Self) -> Self {
        Self(self.0.hypot(&other.0))
    }

    /// Returns the special value representing the *positive infinity*.
    #[inline(always)]
    fn infinity_() -> Self {
        Self(rug::Float::with_val(
            PRECISION,
            rug::float::Special::Infinity,
        ))
    }

    /// Returns `true` if the value is negative, −0 or NaN with a negative sign.
    #[inline(always)]
    fn is_sign_negative_(&self) -> bool {
        self.0.is_sign_negative()
    }

    /// Returns `true` if the value is positive, +0 or NaN with a positive sign.
    #[inline(always)]
    fn is_sign_positive_(&self) -> bool {
        self.0.is_sign_positive()
    }

    /// Returns `ln(1. + self)` (natural logarithm) more accurately than if the operations were performed separately.
    #[inline(always)]
    fn ln_1p_(self) -> Self {
        Self(self.0.ln_1p())
    }

    /// Returns the special value representing the *negative infinity*.
    #[inline(always)]
    fn neg_infinity_() -> Self {
        Self(rug::Float::with_val(
            PRECISION,
            rug::float::Special::NegInfinity,
        ))
    }

    /// Computes the maximum between `self` and `other`.
    #[inline(always)]
    fn max_(self, other: &Self) -> Self {
        Self(self.0.max(&other.0))
    }

    /// Computes the minimum between `self` and `other`.
    #[inline(always)]
    fn min_(self, other: &Self) -> Self {
        Self(self.0.min(&other.0))
    }

    /// 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.
    #[inline(always)]
    fn mul_add_mul_mut_(&mut self, mul: &Self, add_mul1: &Self, add_mul2: &Self) {
        self.0.mul_add_mul_mut(&mul.0, &add_mul1.0, &add_mul2.0);
    }

    /// 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.
    #[inline(always)]
    fn mul_sub_mul_mut_(&mut self, mul: &Self, sub_mul1: &Self, sub_mul2: &Self) {
        self.0.mul_sub_mul_mut(&mul.0, &sub_mul1.0, &sub_mul2.0);
    }

    /// Build and return the (floating point) value -1. represented by a `rug::Float` with the given `PRECISION`.
    #[inline(always)]
    fn negative_one_() -> Self {
        Self(rug::Float::with_val(PRECISION, -1.))
    }

    /// Build and return the (floating point) value 0.5 represented by the proper type.
    #[inline(always)]
    fn one_div_2_() -> Self {
        Self(rug::Float::with_val(PRECISION, 0.5))
    }

    /// Rounds `self` to the nearest integer, rounding half-way cases away from zero.
    #[inline(always)]
    fn round_(self) -> Self {
        Self(self.0.round())
    }

    /// 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, NumKernel, RealRug};
    ///
    /// const PRECISION: u32 = 100;
    ///
    /// let f = RealRug::<PRECISION>::try_from_f64_(3.3).unwrap();
    /// let g = RealRug::<PRECISION>::try_from_f64_(-3.3).unwrap();
    /// let h = RealRug::<PRECISION>::try_from_f64_(3.5).unwrap();
    /// let i = RealRug::<PRECISION>::try_from_f64_(-4.5).unwrap();
    ///
    /// assert_eq!(f.round_ties_even_(), RealRug::<PRECISION>::try_from_f64_(3.).unwrap());
    /// assert_eq!(g.round_ties_even_(), RealRug::<PRECISION>::try_from_f64_(-3.).unwrap());
    /// assert_eq!(h.round_ties_even_(), RealRug::<PRECISION>::try_from_f64_(4.).unwrap());
    /// assert_eq!(i.round_ties_even_(), RealRug::<PRECISION>::try_from_f64_(-4.).unwrap());
    /// ```
    #[inline(always)]
    fn round_ties_even_(self) -> Self {
        Self(self.0.round_even())
    }

    /// 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
    #[inline(always)]
    fn signum_(self) -> Self {
        Self(self.0.signum())
    }

    #[inline(always)]
    fn total_cmp_(&self, other: &Self) -> Ordering {
        self.0.total_cmp(&other.0)
    }

    /// Try to build a [`rug::Float`] instance (with the given `PRECISION`) from a [`f64`].
    /// The returned value is `Ok` if the input `value` is finite and can be exactly represented with the given `PRECISION`,
    /// otherwise the returned value is `TryFromf64Errors`.
    #[inline(always)]
    fn try_from_f64_(value: f64) -> Result<Self, TryFromf64Errors> {
        match value.validate() {
            Ok(value) => {
                let value_rug = rug::Float::with_val(PRECISION, value);
                if value_rug == value {
                    Ok(Self(value_rug))
                } else {
                    Err(TryFromf64Errors::NonRepresentableExactly {
                        value,
                        precision: PRECISION,
                        backtrace: Backtrace::force_capture(),
                    })
                }
            }
            Err(e) => Err(TryFromf64Errors::ValidationError { source: e }),
        }
    }

    /// Returns the integer part of `self`. This means that non-integer numbers are always truncated towards zero.
    ///    
    /// # Examples
    /// ```
    /// use ftl_numkernel::{FunctionsRealType, NumKernel, RealRug};
    ///
    /// const PRECISION: u32 = 100;
    ///
    /// let f = RealRug::<PRECISION>::try_from_f64_(3.7).unwrap();
    /// let g = RealRug::<PRECISION>::try_from_f64_(3.).unwrap();
    /// let h = RealRug::<PRECISION>::try_from_f64_(-3.7).unwrap();
    ///
    /// assert_eq!(f.trunc_(), RealRug::<PRECISION>::try_from_f64_(3.).unwrap());
    /// assert_eq!(g.trunc_(), RealRug::<PRECISION>::try_from_f64_(3.).unwrap());
    /// assert_eq!(h.trunc_(), RealRug::<PRECISION>::try_from_f64_(-3.).unwrap());
    /// ```
    #[inline(always)]
    fn trunc_(self) -> Self {
        Self(self.0.trunc())
    }

    /// Build and return the (floating point) value 2. represented by a `rug::Float` with the given `PRECISION`.
    #[inline(always)]
    fn two_() -> Self {
        Self(rug::Float::with_val(PRECISION, 2.))
    }
}

// Conditional compilation for the `rug` feature
#[cfg(feature = "rug")]
impl<const PRECISION: u32> Mul<ComplexRug<PRECISION>> for RealRug<PRECISION> {
    type Output = ComplexRug<PRECISION>;

    #[inline(always)]
    fn mul(self, other: ComplexRug<PRECISION>) -> Self::Output {
        ComplexRug(self.0 * other.0)
    }
}

// Conditional compilation for the `rug` feature
#[cfg(feature = "rug")]
impl<const PRECISION: u32> MulComplexRight<Rug<PRECISION>> for RealRug<PRECISION> {}

// Conditional compilation for the `rug` feature
#[cfg(feature = "rug")]
impl<const PRECISION: u32> FunctionsGeneralType<Rug<PRECISION>> for ComplexRug<PRECISION> {}

// Conditional compilation for the `rug` feature
#[cfg(feature = "rug")]
impl<const PRECISION: u32> FunctionsComplexType<Rug<PRECISION>> for ComplexRug<PRECISION> {
    /// Computes the principal Arg of `self`.
    #[inline(always)]
    fn arg_(self) -> RealRug<PRECISION> {
        RealRug(self.0.arg().real().clone())
    }

    /// 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.
    /// - the precision of `real part` or of `imag_part` is not equal to `PRECISION`;
    #[inline(always)]
    fn new_(real_part: RealRug<PRECISION>, imag_part: RealRug<PRECISION>) -> Self {
        debug_assert!(
            real_part.0.is_finite(),
            "The real part is not finite (i.e. is infinite or NaN)."
        );
        debug_assert!(
            imag_part.0.is_finite(),
            "The imaginary part is not finite (i.e. is infinite or NaN)."
        );

        Self(rug::Complex::with_val(
            PRECISION,
            (real_part.0, imag_part.0),
        ))
    }

    /// Get the real part of the complex number.
    #[inline(always)]
    fn real_(&self) -> RealRug<PRECISION> {
        RealRug(self.0.real().clone())
    }

    /// Get the imaginary part of the complex number.
    #[inline(always)]
    fn imag_(&self) -> RealRug<PRECISION> {
        RealRug(self.0.imag().clone())
    }

    /// Set the value of the real part.
    ///
    /// # Panics
    /// In debug mode a `panic!` will be emitted if `real_part` is not finite
    /// or if the precision of `real_part` is different from `PRECISION`.
    #[inline(always)]
    fn set_real_(&mut self, real_part: RealRug<PRECISION>) {
        debug_assert!(
            real_part.0.is_finite(),
            "The real part is not finite (i.e. is infinite or NaN)."
        );

        *self.0.mut_real() = real_part.0;
    }

    /// Set the value of the imaginary part.
    ///
    /// # Panics
    /// In debug mode a `panic!` will be emitted if `imaginary_part` is not finite.
    /// or if the precision of `imaginary_part` is different from `PRECISION`.
    #[inline(always)]
    fn set_imag_(&mut self, imag_part: RealRug<PRECISION>) {
        debug_assert!(
            imag_part.0.is_finite(),
            "The imaginary part is not finite (i.e. is infinite or NaN)."
        );
        //        debug_assert_eq!(imag_part.prec(), PRECISION, "Different precisions!");

        *self.0.mut_imag() = imag_part.0;
    }

    /// Add the value of the the real coefficient `c` to real part of `self`.
    #[inline(always)]
    fn add_real_(&mut self, c: &RealRug<PRECISION>) {
        *self.0.mut_real() += c.as_ref();

        debug_assert!(
            self.0.real().is_finite(),
            "The real part is not finite (i.e. is infinite or NaN)."
        );
    }

    /// Add the value of the the real coefficient `c` to imaginary part of `self`.
    #[inline(always)]
    fn add_imag_(&mut self, c: &RealRug<PRECISION>) {
        *self.0.mut_imag() += c.as_ref();

        debug_assert!(
            self.0.imag().is_finite(),
            "The imaginary part is not finite (i.e. is infinite or NaN)."
        );
    }

    /// Multiply the value of the real part by the real coefficient `c`.
    #[inline(always)]
    fn multiply_real_(&mut self, c: &RealRug<PRECISION>) {
        *self.0.mut_real() *= c.as_ref();

        debug_assert!(
            self.0.real().is_finite(),
            "The real part is not finite (i.e. is infinite or NaN)."
        );
    }

    /// Multiply the value of the imaginary part by the real coefficient `c`.
    #[inline(always)]
    fn multiply_imag_(&mut self, c: &RealRug<PRECISION>) {
        *self.0.mut_imag() *= c.as_ref();

        debug_assert!(
            self.0.imag().is_finite(),
            "The imaginary part is not finite (i.e. is infinite or NaN)."
        );
    }

    /// Computes the complex conjugate.
    #[inline(always)]
    fn conj_(self) -> Self {
        Self(self.0.conj())
    }

    /// Try to build a `Self` from real and imaginary parts as [`rug::Float`] 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`.
    #[inline(always)]
    fn try_from_f64_(real_part: f64, imag_part: f64) -> Result<Self, TryFromf64Errors> {
        let real_part = RealRug::<PRECISION>::try_from_f64_(real_part)?;
        let imag_part = RealRug::<PRECISION>::try_from_f64_(imag_part)?;

        Ok(Self(rug::Complex::with_val(
            PRECISION,
            (real_part.0, imag_part.0),
        )))
    }
}

// Conditional compilation for the `rug` feature
#[cfg(feature = "rug")]
impl<const PRECISION: u32> MulComplexLeft<Rug<PRECISION>> for ComplexRug<PRECISION> {}
//------------------------------------------------------------------------------------------------------------

//------------------------------------------------------------------------------------------------------------
// Conditional compilation for the `rug` feature
#[cfg(feature = "rug")]
impl<const PRECISION: u32> Mul<ComplexRug<PRECISION>> for &RealRug<PRECISION> {
    type Output = ComplexRug<PRECISION>;

    fn mul(self, rhs: ComplexRug<PRECISION>) -> ComplexRug<PRECISION> {
        ComplexRug(rhs.0.mul(&self.0))
    }
}
//------------------------------------------------------------------------------------------------------------

//------------------------------------------------------------------------------------------------------------
/// Converts the input `vec` of [`f64`] values into a vector of floating point number, as described by the generic numerical kernel `T`.
///
/// # Panics
/// In debug and release mode a `panic!` will be emitted if the conversion from `f64` to `T::RealType` causes
/// some loss of information (e.g. if the type `T` has less precision of `f64` then there is the possbility
/// that some `f64` values cannot be exactly represented by a `T::RealType`).
/// # Example
/// ```
/// use ftl_numkernel::{Native64, vec_f64_into_vec_float};
///
/// // Conditional compilation for the `rug` feature
/// #[cfg(feature = "rug")]
/// use ftl_numkernel::Rug;
///
/// // vector of f64 values
/// let a = vec![0., 1.];
///
/// let b = vec_f64_into_vec_float::<Native64>(a.clone());
/// assert_eq!(b[0], 0.);
/// assert_eq!(b[1], 1.);
///
///
/// // Conditional compilation for the `rug` feature
/// #[cfg(feature = "rug")]
/// {
///     const PRECISION: u32 = 100;
///
///      // vector of rug::Float values with PRECISION = 100
///     let b = vec_f64_into_vec_float::<Rug<PRECISION>>(a);
///     assert_eq!(b[0].as_ref(), &rug::Float::with_val(PRECISION, 0.));
///     assert_eq!(b[1].as_ref(), &rug::Float::with_val(PRECISION, 1.));
/// }
/// ```
#[inline(always)]
pub fn vec_f64_into_vec_float<T: NumKernel>(vec: Vec<f64>) -> Vec<T::RealType> {
    vec.into_iter()
        .map(|v| T::RealType::try_from_f64_(v).unwrap())
        .collect()
}
//------------------------------------------------------------------------------------------------------------

//------------------------------------------------------------------------------------------------------------
#[cfg(test)]
mod tests {
    use super::*;
    use core::ops::{Add, Div, Mul, Sub};

    fn test_add_real<T>()
    where
        T: NumKernel,
        for<'a> &'a T::RealType: Add<T::RealType, Output = T::RealType>,
    {
        let a = T::RealType::one();
        let b = T::RealType::try_from_f64_(2.).unwrap();

        let c_expected = T::RealType::try_from_f64_(3.0).unwrap();

        let c = a.clone() + &b;
        assert_eq!(c, c_expected);

        let c = &a + b.clone();
        assert_eq!(c, c_expected);

        let c = a.clone() + b.clone();
        assert_eq!(c, c_expected);
    }

    fn test_add_complex<T>()
    where
        T: NumKernel,
        for<'a> &'a T::ComplexType: Add<T::ComplexType, Output = T::ComplexType>,
    {
        let a = T::ComplexType::try_from_f64_(1., 2.).unwrap();
        let b = T::ComplexType::try_from_f64_(3., 4.).unwrap();

        let c_expected = T::ComplexType::try_from_f64_(4., 6.).unwrap();

        let c = a.clone() + &b;
        assert_eq!(c, c_expected);

        let c = &a + b.clone();
        assert_eq!(c, c_expected);

        let c = a.clone() + b.clone();
        assert_eq!(c, c_expected);
    }

    fn test_sub_real<T>()
    where
        T: NumKernel,
        for<'a> &'a T::RealType: Sub<T::RealType, Output = T::RealType>,
    {
        let a = T::RealType::one();
        let b = T::RealType::try_from_f64_(2.).unwrap();

        let c_expected = T::RealType::try_from_f64_(-1.0).unwrap();

        let c = a.clone() - &b;
        assert_eq!(c, c_expected);

        let c = &a - b.clone();
        assert_eq!(c, c_expected);

        let c = a.clone() - b.clone();
        assert_eq!(c, c_expected);
    }

    fn test_sub_complex<T>()
    where
        T: NumKernel,
        for<'a> &'a T::ComplexType: Sub<T::ComplexType, Output = T::ComplexType>,
    {
        let a = T::ComplexType::try_from_f64_(3., 2.).unwrap();
        let b = T::ComplexType::try_from_f64_(1., 4.).unwrap();

        let c_expected = T::ComplexType::try_from_f64_(2., -2.).unwrap();

        let c = a.clone() - &b;
        assert_eq!(c, c_expected);

        let c = &a - b.clone();
        assert_eq!(c, c_expected);

        let c = a.clone() - b.clone();
        assert_eq!(c, c_expected);
    }

    fn test_mul_real<T>()
    where
        T: NumKernel,
        for<'a> &'a T::RealType: Mul<T::RealType, Output = T::RealType>,
    {
        let a = T::RealType::try_from_f64_(2.).unwrap();
        let b = T::RealType::try_from_f64_(3.).unwrap();

        let c_expected = T::RealType::try_from_f64_(6.0).unwrap();

        let c = a.clone() * &b;
        assert_eq!(c, c_expected);

        let c = &a * b.clone();
        assert_eq!(c, c_expected);

        let c = a.clone() * b.clone();
        assert_eq!(c, c_expected);
    }

    fn test_mul_complex<T>()
    where
        T: NumKernel,
        for<'a> &'a T::ComplexType: Mul<T::ComplexType, Output = T::ComplexType>,
    {
        let a = T::ComplexType::try_from_f64_(3., 2.).unwrap();
        let b = T::ComplexType::try_from_f64_(1., 4.).unwrap();

        let c_expected = T::ComplexType::try_from_f64_(-5., 14.).unwrap();

        let c = a.clone() * &b;
        assert_eq!(c, c_expected);

        let c = &a * b.clone();
        assert_eq!(c, c_expected);

        let c = a.clone() * b.clone();
        assert_eq!(c, c_expected);
    }

    fn test_div_real<T>()
    where
        T: NumKernel,
        for<'a> &'a T::RealType: Div<T::RealType, Output = T::RealType>,
    {
        let a = T::RealType::try_from_f64_(6.).unwrap();
        let b = T::RealType::try_from_f64_(2.).unwrap();

        let c_expected = T::RealType::try_from_f64_(3.0).unwrap();

        let c = a.clone() / &b;
        assert_eq!(c, c_expected);

        let c = &a / b.clone();
        assert_eq!(c, c_expected);

        let c = a.clone() / b.clone();
        assert_eq!(c, c_expected);
    }

    fn test_div_complex<T>()
    where
        T: NumKernel,
        for<'a> &'a T::ComplexType: Div<T::ComplexType, Output = T::ComplexType>,
    {
        let a = T::ComplexType::try_from_f64_(-5., 14.).unwrap();
        let b = T::ComplexType::try_from_f64_(1., 4.).unwrap();

        let c_expected = T::ComplexType::try_from_f64_(3., 2.).unwrap();

        let c = a.clone() / &b;
        assert_eq!(c, c_expected);

        let c = &a / b.clone();
        assert_eq!(c, c_expected);

        let c = a.clone() / b.clone();
        assert_eq!(c, c_expected);
    }

    fn test_neg_assign_real<T: NumKernel>() {
        let mut a = T::RealType::try_from_f64_(1.).unwrap();
        a.neg_assign();

        let a_expected = T::RealType::try_from_f64_(-1.).unwrap();
        assert_eq!(a, a_expected);
    }

    fn test_neg_assign_complex<T: NumKernel>() {
        let mut a = T::ComplexType::try_from_f64_(1., 2.).unwrap();
        a.neg_assign();

        let a_expected = T::ComplexType::try_from_f64_(-1., -2.).unwrap();
        assert_eq!(a, a_expected);
    }

    fn test_add_assign_real<T: NumKernel>() {
        let mut a = T::RealType::try_from_f64_(1.0).unwrap();
        let b = T::RealType::try_from_f64_(2.0).unwrap();

        a += &b;
        let a_expected = T::RealType::try_from_f64_(3.0).unwrap();
        assert_eq!(a, a_expected);

        a += b;
        let a_expected = T::RealType::try_from_f64_(5.0).unwrap();
        assert_eq!(a, a_expected);
    }

    fn test_add_assign_complex<T: NumKernel>() {
        let mut a = T::ComplexType::try_from_f64_(1., 2.).unwrap();
        let b = T::ComplexType::try_from_f64_(3., 4.).unwrap();

        a += &b;
        let a_expected = T::ComplexType::try_from_f64_(4., 6.).unwrap();
        assert_eq!(a, a_expected);

        a += b;
        let a_expected = T::ComplexType::try_from_f64_(7., 10.).unwrap();
        assert_eq!(a, a_expected);
    }

    fn test_sub_assign_real<T: NumKernel>() {
        let mut a = T::RealType::try_from_f64_(1.0).unwrap();
        let b = T::RealType::try_from_f64_(2.0).unwrap();

        a -= &b;
        let a_expected = T::RealType::try_from_f64_(-1.0).unwrap();
        assert_eq!(a, a_expected);

        a -= b;
        let a_expected = T::RealType::try_from_f64_(-3.0).unwrap();
        assert_eq!(a, a_expected);
    }

    fn test_sub_assign_complex<T: NumKernel>() {
        let mut a = T::ComplexType::try_from_f64_(3., 2.).unwrap();
        let b = T::ComplexType::try_from_f64_(2., 4.).unwrap();

        a -= &b;
        let a_expected = T::ComplexType::try_from_f64_(1., -2.).unwrap();
        assert_eq!(a, a_expected);

        a -= b;
        let a_expected = T::ComplexType::try_from_f64_(-1., -6.).unwrap();
        assert_eq!(a, a_expected);
    }

    fn test_mul_assign_real<T: NumKernel>() {
        let mut a = T::RealType::try_from_f64_(1.0).unwrap();
        let b = T::RealType::try_from_f64_(2.0).unwrap();

        a *= &b;
        let a_expected = T::RealType::try_from_f64_(2.0).unwrap();
        assert_eq!(a, a_expected);

        a *= b;
        let a_expected = T::RealType::try_from_f64_(4.0).unwrap();
        assert_eq!(a, a_expected);
    }

    fn test_mul_assign_complex<T: NumKernel>() {
        let mut a = T::ComplexType::try_from_f64_(3., 2.).unwrap();
        let b = T::ComplexType::try_from_f64_(2., 4.).unwrap();

        a *= &b;
        let a_expected = T::ComplexType::try_from_f64_(-2., 16.).unwrap();
        assert_eq!(a, a_expected);

        a *= b;
        let a_expected = T::ComplexType::try_from_f64_(-68., 24.).unwrap();
        assert_eq!(a, a_expected);
    }

    fn test_div_assign_real<T: NumKernel>() {
        let mut a = T::RealType::try_from_f64_(4.0).unwrap();
        let b = T::RealType::try_from_f64_(2.0).unwrap();

        a /= &b;
        let a_expected = T::RealType::try_from_f64_(2.0).unwrap();
        assert_eq!(a, a_expected);

        a /= b;
        let a_expected = T::RealType::try_from_f64_(1.0).unwrap();
        assert_eq!(a, a_expected);
    }

    fn test_div_assign_complex<T: NumKernel>() {
        let mut a = T::ComplexType::try_from_f64_(-68., 24.).unwrap();
        let b = T::ComplexType::try_from_f64_(2., 4.).unwrap();

        a /= &b;
        let a_expected = T::ComplexType::try_from_f64_(-2., 16.).unwrap();
        assert_eq!(a, a_expected);

        a /= b;
        let a_expected = T::ComplexType::try_from_f64_(3., 2.).unwrap();
        assert_eq!(a, a_expected);
    }

    fn test_abs_real<T: NumKernel>() {
        let a = T::RealType::try_from_f64_(-1.).unwrap();

        let abs = a.abs();
        let expected = T::RealType::try_from_f64_(1.).unwrap();
        assert_eq!(abs, expected);
    }

    fn test_abs_complex<T: NumKernel>() {
        let a = T::ComplexType::try_from_f64_(-3., 4.).unwrap();

        let abs = a.abs();
        let expected = T::RealType::try_from_f64_(5.).unwrap();
        assert_eq!(abs, expected);
    }

    fn test_mul_add_real<T: NumKernel>() {
        let a = T::RealType::try_from_f64_(2.0).unwrap();
        let b = T::RealType::try_from_f64_(3.0).unwrap();
        let c = T::RealType::try_from_f64_(1.0).unwrap();

        let d_expected = T::RealType::try_from_f64_(7.0).unwrap();

        let d = a.mul_add(&b, &c);
        assert_eq!(d, d_expected);
    }

    fn test_mul_add_complex<T: NumKernel>() {
        let a = T::ComplexType::try_from_f64_(2., -3.).unwrap();
        let b = T::ComplexType::try_from_f64_(3., 1.).unwrap();
        let c = T::ComplexType::try_from_f64_(1., -4.).unwrap();

        let d_expected = T::ComplexType::try_from_f64_(10., -11.).unwrap();

        let d = a.mul_add(&b, &c);
        assert_eq!(d, d_expected);
    }

    /*
    fn test_add_complex_with_real<T>()
    where
        T: NumKernel,
        for<'a> &'a T::RealType: Add<T::ComplexType, Output = T::ComplexType>,
    {
        let a = T::ComplexType::try_from_f64_(1., 2.).unwrap();
        let b = T::RealType::try_from_f64_(3.).unwrap();

        let c_expected = T::ComplexType::try_from_f64_(4., 2.).unwrap();

        let c = a.clone() + &b;
        assert_eq!(c, c_expected);

        //        let c = &a + b.clone();
        //        assert_eq!(c, c_expected);

        let c = a.clone() + b.clone();
        assert_eq!(c, c_expected);

        //        let c = b.clone() + &a;
        //        assert_eq!(c, c_expected);

        let c = &b + a.clone();
        assert_eq!(c, c_expected);

        let c = b.clone() + a.clone();
        assert_eq!(c, c_expected);
    }

    fn test_sub_complex_with_real<T>()
    where
        T: NumKernel,
        for<'a> &'a T::RealType: Sub<T::ComplexType, Output = T::ComplexType>,
    {
        let a = T::ComplexType::try_from_f64_(1., 2.).unwrap();
        let b = T::RealType::try_from_f64_(3.).unwrap();

        let a_minus_b_expected = T::ComplexType::try_from_f64_(-2., 2.).unwrap();
        let b_minus_a_expected = T::ComplexType::try_from_f64_(2., -2.).unwrap();

        let a_minus_b = a.clone() - &b;
        assert_eq!(a_minus_b, a_minus_b_expected);

        //        let a_minus_b = &a_minus_b - b.clone();
        //        assert_eq!(a_minus_b, a_minus_b_expected);

        let a_minus_b = a.clone() - b.clone();
        assert_eq!(a_minus_b, a_minus_b_expected);

        //        let c = b.clone() - &a;
        //        assert_eq!(c, b_minus_a_expected);

        let b_minus_a = &b - a.clone();
        assert_eq!(b_minus_a, b_minus_a_expected);

        let b_minus_a = b.clone() - a.clone();
        assert_eq!(b_minus_a, b_minus_a_expected);
    }
    */

    fn test_mul_complex_with_real<T>()
    where
        T: NumKernel,
        for<'a> &'a T::RealType: Mul<T::ComplexType, Output = T::ComplexType>,
    {
        let a = T::ComplexType::try_from_f64_(1., 2.).unwrap();
        let b = T::RealType::try_from_f64_(3.).unwrap();

        let a_times_b_expected = T::ComplexType::try_from_f64_(3., 6.).unwrap();
        let b_times_a_expected = a_times_b_expected.clone();

        let a_times_b = a.clone() * &b;
        assert_eq!(a_times_b, a_times_b_expected);

        //        let a_times_b = &a_minus_b * b.clone();
        //        assert_eq!(a_times_b, a_times_b_expected);

        let a_times_b = a.clone() * b.clone();
        assert_eq!(a_times_b, a_times_b_expected);

        //        let c = b.clone() - &a;
        //        assert_eq!(c, b_minus_a_expected);

        let b_times_a = &b * a.clone();
        assert_eq!(b_times_a, b_times_a_expected);

        let b_times_a = b.clone() * a.clone();
        assert_eq!(b_times_a, b_times_a_expected);
    }

    fn test_mul_assign_complex_with_real<T>()
    where
        T: NumKernel,
    {
        let a = T::ComplexType::try_from_f64_(1., 2.).unwrap();
        let b = T::RealType::try_from_f64_(3.).unwrap();

        let a_times_b_expected = T::ComplexType::try_from_f64_(3., 6.).unwrap();

        let mut a_times_b = a.clone();
        a_times_b *= &b;
        assert_eq!(a_times_b, a_times_b_expected);

        let mut a_times_b = a.clone();
        a_times_b *= b;
        assert_eq!(a_times_b, a_times_b_expected);
    }

    mod native64 {
        use super::*;

        mod real {
            use super::*;

            #[test]
            fn from_f64() {
                let v_native64 =
                    <f64 as FunctionsRealType<Native64>>::try_from_f64_(16.25).unwrap();
                assert_eq!(v_native64, 16.25);
            }

            #[test]
            fn zero() {
                test_zero::<Native64>();
            }

            #[test]
            fn one() {
                test_one::<Native64>();
            }

            #[test]
            fn add() {
                test_add_real::<Native64>();
            }

            #[test]
            fn sub() {
                test_sub_real::<Native64>();
            }

            #[test]
            fn mul() {
                test_mul_real::<Native64>();
            }

            #[test]
            fn div() {
                test_div_real::<Native64>();
            }

            #[test]
            fn neg_assign() {
                test_neg_assign_real::<Native64>();
            }

            #[test]
            fn add_assign() {
                test_add_assign_real::<Native64>();
            }

            #[test]
            fn sub_assign() {
                test_sub_assign_real::<Native64>();
            }

            #[test]
            fn mul_assign() {
                test_mul_assign_real::<Native64>();
            }

            #[test]
            fn div_assign() {
                test_div_assign_real::<Native64>();
            }

            #[test]
            fn abs() {
                test_abs_real::<Native64>();
            }

            #[test]
            fn mul_add() {
                test_mul_add_real::<Native64>();
            }

            #[test]
            fn recip() {
                test_recip::<Native64>();
            }

            #[test]
            fn acos() {
                let a = 0.;

                let pi_over_2 = a.acos_();
                let expected = 1.5707963267948966;
                assert_eq!(pi_over_2, expected);
            }

            #[test]
            fn asin() {
                let a = 1.;

                let pi_over_2 = a.asin_();
                let expected = 1.5707963267948966;
                assert_eq!(pi_over_2, expected);
            }

            #[test]
            fn cos() {
                test_cos::<Native64>();
            }

            #[test]
            fn sin() {
                test_sin::<Native64>();
            }
        }

        mod complex {
            use super::*;
            use num::Complex;

            #[test]
            fn from_f64() {
                let v = <Complex<f64> as FunctionsComplexType<Native64>>::try_from_f64_(16.25, 2.)
                    .unwrap();
                assert_eq!(v.real_(), 16.25);
                assert_eq!(v.imag_(), 2.);
            }

            #[test]
            fn conj() {
                let v = <Complex<f64> as FunctionsComplexType<Native64>>::try_from_f64_(16.25, 2.)
                    .unwrap();

                let v_conj = v.conj_();
                assert_eq!(v_conj.real_(), 16.25);
                assert_eq!(v_conj.imag_(), -2.);
            }

            #[test]
            fn add() {
                test_add_complex::<Native64>();
            }

            #[test]
            fn sub() {
                test_sub_complex::<Native64>();
            }

            #[test]
            fn mul() {
                test_mul_complex::<Native64>();
            }

            #[test]
            fn div() {
                test_div_complex::<Native64>();
            }

            #[test]
            fn neg_assign() {
                test_neg_assign_complex::<Native64>();
            }

            #[test]
            fn add_assign() {
                test_add_assign_complex::<Native64>();
            }

            #[test]
            fn sub_assign() {
                test_sub_assign_complex::<Native64>();
            }

            #[test]
            fn mul_assign() {
                test_mul_assign_complex::<Native64>();
            }

            #[test]
            fn div_assign() {
                test_div_assign_complex::<Native64>();
            }

            #[test]
            fn abs() {
                test_abs_complex::<Native64>();
            }

            #[test]
            fn mul_add() {
                test_mul_add_complex::<Native64>();
            }

            /*
                        #[test]
                        fn add_complex_with_real() {
                            test_add_complex_with_real::<Native64>();
                        }

                        #[test]
                        fn sub_complex_with_real() {
                            test_sub_complex_with_real::<Native64>();
                        }
            */

            #[test]
            fn mul_complex_with_real() {
                test_mul_complex_with_real::<Native64>();
            }

            #[test]
            fn mul_assign_complex_with_real() {
                test_mul_assign_complex_with_real::<Native64>();
            }
        }
    }

    // Conditional compilation for the `rug` feature
    #[cfg(feature = "rug")]
    mod rug_ {
        use super::*;

        mod real {
            use super::*;

            #[test]
            fn from_f64() {
                let v_100bits = RealRug::<100>::try_from_f64_(16.25).unwrap();

                assert_eq!(v_100bits, 16.25);

                let v_53bits = RealRug::<53>::try_from_f64_(16.25).unwrap();
                assert_eq!(v_53bits, 16.25);

                // 16.25 has seven significant bits (binary 10000.01)
                let v_7bits = RealRug::<7>::try_from_f64_(16.25).unwrap();
                assert_eq!(v_7bits, 16.25);
            }

            #[test]
            #[should_panic]
            fn from_f64_failing() {
                // this should fail because 16.25 has seven significant bits (binary 10000.01) and we ask a float with 6 significant bits
                let _v_6bits = RealRug::<6>::try_from_f64_(16.25).unwrap();
            }

            #[test]
            fn zero() {
                test_zero::<Rug<64>>();
                test_zero::<Rug<100>>();
            }

            #[test]
            fn one() {
                test_one::<Rug<64>>();
                test_one::<Rug<100>>();
            }

            #[test]
            fn add() {
                test_add_real::<Rug<100>>();
            }

            #[test]
            fn sub() {
                test_sub_real::<Rug<100>>();
            }

            #[test]
            fn mul() {
                test_mul_real::<Rug<100>>();
            }

            #[test]
            fn div() {
                test_div_real::<Rug<100>>();
            }

            #[test]
            fn neg_assign() {
                test_neg_assign_real::<Rug<100>>();
            }

            #[test]
            fn add_assign() {
                test_add_assign_real::<Rug<100>>();
            }

            #[test]
            fn sub_assign() {
                test_sub_assign_real::<Rug<100>>();
            }

            #[test]
            fn mul_assign() {
                test_mul_assign_real::<Rug<100>>();
            }

            #[test]
            fn div_assign() {
                test_div_assign_real::<Rug<100>>();
            }

            #[test]
            fn abs() {
                test_abs_real::<Rug<100>>();
            }

            #[test]
            fn mul_add() {
                test_mul_add_real::<Rug<100>>();
            }

            #[test]
            fn recip() {
                test_recip::<Rug<64>>();
                test_recip::<Rug<100>>();
            }

            #[test]
            fn acos() {
                {
                    let a = RealRug::<53>::zero();
                    let pi_over_2 = RealRug::<53>::acos_(a);
                    let expected = rug::Float::with_val(53, 1.5707963267948966);
                    assert_eq!(pi_over_2.as_ref(), &expected);
                }
                {
                    let a = RealRug::<100>::zero();
                    let pi_over_2 = RealRug::<100>::acos_(a);
                    let expected = rug::Float::with_val(
                        100,
                        rug::Float::parse("1.5707963267948966192313216916397e0").unwrap(),
                    );
                    assert_eq!(pi_over_2.as_ref(), &expected);
                }
            }

            #[test]
            fn asin() {
                {
                    let a = RealRug::<53>::one();
                    let pi_over_2 = RealRug::<53>::asin_(a);
                    let expected = rug::Float::with_val(53, 1.5707963267948966);
                    assert_eq!(pi_over_2.as_ref(), &expected);
                }
                {
                    let a = RealRug::<100>::one();
                    let pi_over_2 = RealRug::<100>::asin_(a);
                    let expected = rug::Float::with_val(
                        100,
                        rug::Float::parse("1.5707963267948966192313216916397e0").unwrap(),
                    );
                    assert_eq!(pi_over_2.as_ref(), &expected);
                }
            }

            #[test]
            fn cos() {
                test_cos::<Rug<64>>();
                test_cos::<Rug<100>>();
            }

            #[test]
            fn sin() {
                test_sin::<Rug<64>>();
                test_sin::<Rug<100>>();
            }

            #[test]
            fn dot_product() {
                let a = &[
                    RealRug::<100>::try_from_f64_(1.).unwrap(),
                    RealRug::<100>::try_from_f64_(2.).unwrap(),
                ];

                let b = &[
                    RealRug::<100>::try_from_f64_(2.).unwrap(),
                    RealRug::<100>::try_from_f64_(-1.).unwrap(),
                ];

                let a: Vec<_> = a.iter().map(|a_i| a_i.as_ref()).collect();
                let b: Vec<_> = b.iter().map(|b_i| b_i.as_ref()).collect();

                let value =
                    RealRug::<100>(rug::Float::dot(a.into_iter().zip(b.into_iter())).complete(100));

                assert_eq!(value.as_ref(), &rug::Float::with_val(100, 0.));
            }
        }

        mod complex {
            use super::*;

            #[test]
            fn from_f64() {
                let v_100bits = ComplexRug::<100>::try_from_f64_(16.25, 2.).unwrap();
                assert_eq!(ComplexRug::<100>::real_(&v_100bits), 16.25);
                assert_eq!(ComplexRug::<100>::imag_(&v_100bits), 2.);

                let v_53bits = ComplexRug::<53>::try_from_f64_(16.25, 2.).unwrap();
                assert_eq!(ComplexRug::<53>::real_(&v_53bits), 16.25);
                assert_eq!(ComplexRug::<53>::imag_(&v_53bits), 2.);

                // 16.25 has seven significant bits (binary 10000.01)
                let v_7bits = ComplexRug::<7>::try_from_f64_(16.25, 2.).unwrap();
                assert_eq!(ComplexRug::<7>::real_(&v_7bits), 16.25);
                assert_eq!(ComplexRug::<7>::imag_(&v_7bits), 2.);
            }

            #[test]
            #[should_panic]
            fn from_f64_failing() {
                // this should fail because 16.25 has seven significant bits (binary 10000.01) and we ask a float with 6 significant bits
                let _v_6bits = ComplexRug::<6>::try_from_f64_(16.25, 2.).unwrap();
            }

            #[test]
            fn conj() {
                let v = ComplexRug::<100>::try_from_f64_(16.25, 2.).unwrap();

                let v_conj = ComplexRug::<100>::conj_(v);
                assert_eq!(ComplexRug::<100>::real_(&v_conj), 16.25);
                assert_eq!(ComplexRug::<100>::imag_(&v_conj), -2.);
            }

            #[test]
            fn add() {
                test_add_complex::<Rug<100>>();
            }

            #[test]
            fn sub() {
                test_sub_complex::<Rug<100>>();
            }

            #[test]
            fn mul() {
                test_mul_complex::<Rug<100>>();
            }

            #[test]
            fn div() {
                test_div_complex::<Rug<100>>();
            }

            #[test]
            fn neg_assign() {
                test_neg_assign_complex::<Rug<100>>();
            }

            #[test]
            fn add_assign() {
                test_add_assign_complex::<Rug<100>>();
            }

            #[test]
            fn sub_assign() {
                test_sub_assign_complex::<Rug<100>>();
            }

            #[test]
            fn mul_assign() {
                test_mul_assign_complex::<Rug<100>>();
            }

            #[test]
            fn div_assign() {
                test_div_assign_complex::<Rug<100>>();
            }

            #[test]
            fn abs() {
                test_abs_complex::<Rug<100>>();
            }

            #[test]
            fn mul_add() {
                test_mul_add_complex::<Rug<100>>();
            }
            /*
                        #[test]
                        fn add_complex_with_real() {
                            test_add_complex_with_real::<Rug<100>>();
                        }

                        #[test]
                        fn sub_complex_with_real() {
                            test_sub_complex_with_real::<Rug<100>>();
                        }
            */
            #[test]
            fn mul_complex_with_real() {
                test_mul_complex_with_real::<Rug<100>>();
            }

            #[test]
            fn mul_assign_complex_with_real() {
                test_mul_assign_complex_with_real::<Rug<100>>();
            }

            #[test]
            fn dot_product() {
                let a = &[
                    ComplexRug::<100>::try_from_f64_(1., 3.).unwrap(),
                    ComplexRug::<100>::try_from_f64_(2., 4.).unwrap(),
                ];

                let b = &[
                    ComplexRug::<100>::try_from_f64_(-2., -5.).unwrap(),
                    ComplexRug::<100>::try_from_f64_(-1., 6.).unwrap(),
                ];

                let a: Vec<_> = a.iter().map(|a_i| a_i.as_ref()).collect();
                let b: Vec<_> = b.iter().map(|b_i| b_i.as_ref()).collect();

                // computes a * a^T
                let a_times_a = ComplexRug::<100>(
                    rug::Complex::dot(a.clone().into_iter().zip(a.clone().into_iter()))
                        .complete((100, 100)),
                );
                assert_eq!(
                    a_times_a.as_ref(),
                    &rug::Complex::with_val(100, (-20., 22.))
                );

                // computes a * b^T
                let a_times_b = ComplexRug::<100>(
                    rug::Complex::dot(a.clone().into_iter().zip(b.clone().into_iter()))
                        .complete((100, 100)),
                );
                assert_eq!(
                    a_times_b.as_ref(),
                    &rug::Complex::with_val(100, (-13., -3.))
                );

                // computes b * a^T
                let b_times_a = ComplexRug::<100>(
                    rug::Complex::dot(b.into_iter().zip(a.into_iter())).complete((100, 100)),
                );
                assert_eq!(
                    b_times_a.as_ref(),
                    &rug::Complex::with_val(100, (-13., -3.))
                );
            }
        }
    }

    fn test_sin<T: NumKernel>() {
        let a = T::RealType::zero();

        let a = a.sin_();
        let expected = T::RealType::zero();
        assert_eq!(a, expected);
    }

    fn test_cos<T: NumKernel>() {
        let a = T::RealType::zero();

        let a = a.cos_();
        let expected = T::RealType::one();
        assert_eq!(a, expected);
    }

    fn test_recip<T: NumKernel>() {
        let a = T::RealType::two_();

        let a = a.try_reciprocal().unwrap();
        let expected = T::RealType::one_div_2_();
        assert_eq!(a, expected);
    }

    fn test_zero<T: NumKernel>() {
        let a = T::RealType::zero();

        assert_eq!(a, 0.0);
    }

    fn test_one<T: NumKernel>() {
        let a = T::RealType::one();

        assert_eq!(a, 1.0);
    }
}

#[cfg(test)]
mod tests_new {
    use super::*;

    mod functions_general_type {
        use super::*;

        mod native64 {
            use super::*;

            mod real {
                use super::*;

                #[test]
                fn test_acos_() {
                    let value: f64 = 0.5;
                    let result = value.acos_();
                    assert_eq!(result, value.acos());
                }

                #[test]
                fn test_acosh_() {
                    let value: f64 = 1.5;
                    let result = value.acosh_();
                    assert_eq!(result, value.acosh());
                }

                #[test]
                fn test_asin_() {
                    let value: f64 = 0.5;
                    let result = value.asin_();
                    assert_eq!(result, value.asin());
                }

                #[test]
                fn test_asinh_() {
                    let value: f64 = 0.5;
                    let result = value.asinh_();
                    assert_eq!(result, value.asinh());
                }

                #[test]
                fn test_atan_() {
                    let value: f64 = 0.5;
                    let result = value.atan_();
                    assert_eq!(result, value.atan());
                }

                #[test]
                fn test_atanh_() {
                    let value: f64 = 0.5;
                    let result = value.atanh_();
                    assert_eq!(result, value.atanh());
                }

                #[test]
                fn test_cos_() {
                    let value: f64 = 0.5;
                    let result = value.cos_();
                    assert_eq!(result, value.cos());
                }

                #[test]
                fn test_cosh_() {
                    let value: f64 = 0.5;
                    let result = value.cosh_();
                    assert_eq!(result, value.cosh());
                }

                #[test]
                fn test_exp_() {
                    let value: f64 = 0.5;
                    let result = value.exp_();
                    print!("result = {:?}", result);

                    assert_eq!(result, value.exp());
                }

                #[test]
                fn test_is_finite_() {
                    let value: f64 = 0.5;
                    assert!(value.is_finite_());

                    let value: f64 = f64::INFINITY;
                    assert!(!value.is_finite_());
                }

                #[test]
                fn test_is_infinite_() {
                    let value: f64 = f64::INFINITY;
                    assert!(value.is_infinite_());

                    let value: f64 = 0.5;
                    assert!(!value.is_infinite_());
                }

                #[test]
                fn test_ln_() {
                    let value: f64 = 2.718281828459045;
                    let result = value.ln_();
                    println!("result = {:?}", result);
                    assert_eq!(result, value.ln());
                }

                #[test]
                fn test_log10_() {
                    let value: f64 = 10.0;
                    let result = value.log10_();
                    println!("result = {:?}", result);
                    assert_eq!(result, value.log10());
                }

                #[test]
                fn test_log2_() {
                    let value: f64 = 8.0;
                    let result = value.log2_();
                    println!("result = {:?}", result);
                    assert_eq!(result, value.log2());
                }

                #[test]
                fn test_recip_() {
                    let value: f64 = 2.0;
                    let result = value.try_reciprocal().unwrap();
                    assert_eq!(result, value.recip());
                }

                #[test]
                fn test_sin_() {
                    let value: f64 = 0.5;
                    let result = value.sin_();
                    assert_eq!(result, value.sin());
                }

                #[test]
                fn test_sinh_() {
                    let value: f64 = 0.5;
                    let result = value.sinh_();
                    assert_eq!(result, value.sinh());
                }

                #[test]
                fn sqrt() {
                    let value: f64 = 4.0;
                    let result = value.sqrt();
                    assert_eq!(result, value.sqrt());
                }

                #[test]
                fn try_sqrt() {
                    let value: f64 = 4.0;
                    let result = value.try_sqrt().unwrap();
                    assert_eq!(result, value.sqrt());

                    assert!((-1.0).try_sqrt().is_err());
                }

                #[test]
                fn test_tan_() {
                    let value: f64 = 0.5;
                    let result = value.tan_();
                    assert_eq!(result, value.tan());
                }

                #[test]
                fn test_tanh_() {
                    let value: f64 = 0.5;
                    let result = value.tanh_();
                    assert_eq!(result, value.tanh());
                }
            }

            mod complex {
                use super::*;

                #[test]
                fn test_acos_() {
                    let value: Complex<f64> = Complex::new(0.5, 0.5);
                    let result = value.acos_();
                    assert_eq!(result, value.acos());
                }

                #[test]
                fn test_acosh_() {
                    let value: Complex<f64> = Complex::new(1.5, 0.5);
                    let result = value.acosh_();
                    assert_eq!(result, value.acosh());
                }

                #[test]
                fn test_asin_() {
                    let value: Complex<f64> = Complex::new(0.5, 0.5);
                    let result = value.asin_();
                    assert_eq!(result, value.asin());
                }

                #[test]
                fn test_asinh_() {
                    let value: Complex<f64> = Complex::new(0.5, 0.5);
                    let result = value.asinh_();
                    assert_eq!(result, value.asinh());
                }

                #[test]
                fn test_atan_() {
                    let value: Complex<f64> = Complex::new(0.5, 0.5);
                    let result = value.atan_();
                    assert_eq!(result, value.atan());
                }

                #[test]
                fn test_atanh_() {
                    let value: Complex<f64> = Complex::new(0.5, 0.5);
                    let result = value.atanh_();
                    assert_eq!(result, value.atanh());
                }

                #[test]
                fn test_cos_() {
                    let value: Complex<f64> = Complex::new(0.5, 0.5);
                    let result = value.cos_();
                    assert_eq!(result, value.cos());
                }

                #[test]
                fn test_cosh_() {
                    let value: Complex<f64> = Complex::new(0.5, 0.5);
                    let result = value.cosh_();
                    assert_eq!(result, value.cosh());
                }

                #[test]
                fn test_exp_() {
                    let value: Complex<f64> = Complex::new(0.5, 0.5);
                    let result = value.exp_();
                    print!("result = {:?}", result);
                    assert_eq!(result, value.exp());
                }

                #[test]
                fn test_is_finite_() {
                    let value: Complex<f64> = Complex::new(0.5, 0.5);
                    assert!(value.is_finite_());

                    let value: Complex<f64> = Complex::new(f64::INFINITY, 0.5);
                    assert!(!value.is_finite_());
                }

                #[test]
                fn test_is_infinite_() {
                    let value: Complex<f64> = Complex::new(f64::INFINITY, 0.5);
                    assert!(value.is_infinite_());

                    let value: Complex<f64> = Complex::new(0.5, 0.5);
                    assert!(!value.is_infinite_());
                }

                #[test]
                fn test_ln_() {
                    let value: Complex<f64> = Complex::new(2.718281828459045, 1.0);
                    let result = value.ln_();
                    println!("result = {:?}", result);
                    assert_eq!(result, value.ln());
                }

                #[test]
                fn test_log10_() {
                    let value: Complex<f64> = Complex::new(10.0, 1.0);
                    let result = value.log10_();
                    println!("result = {:?}", result);
                    assert_eq!(result, value.log10());
                }

                #[test]
                fn test_log2_() {
                    let value: Complex<f64> = Complex::new(8.0, 1.0);
                    let result = value.log2_();
                    println!("result = {:?}", result);
                    assert_eq!(result, value.log2());
                }

                #[test]
                fn test_recip_() {
                    let value: Complex<f64> = Complex::new(2.0, 0.0);
                    let result = value.try_reciprocal().unwrap();
                    assert_eq!(result, value.finv());
                }

                #[test]
                fn test_sin_() {
                    let value: Complex<f64> = Complex::new(0.5, 0.5);
                    let result = value.sin_();
                    assert_eq!(result, value.sin());
                }

                #[test]
                fn test_sinh_() {
                    let value: Complex<f64> = Complex::new(0.5, 0.5);
                    let result = value.sinh_();
                    assert_eq!(result, value.sinh());
                }

                #[test]
                fn sqrt() {
                    let value: Complex<f64> = Complex::new(4.0, 1.0);
                    let result = value.sqrt();
                    assert_eq!(result, value.sqrt());
                }

                #[test]
                fn try_sqrt() {
                    let value: Complex<f64> = Complex::new(4.0, 1.0);
                    let result = value.try_sqrt().unwrap();
                    assert_eq!(result, value.sqrt());
                }

                #[test]
                fn test_tan_() {
                    let value: Complex<f64> = Complex::new(0.5, 0.5);
                    let result = value.tan_();
                    assert_eq!(result, value.tan());
                }

                #[test]
                fn test_tanh_() {
                    let value: Complex<f64> = Complex::new(0.5, 0.5);
                    let result = value.tanh_();
                    assert_eq!(result, value.tanh());
                }
            }
        }

        #[cfg(feature = "rug")]
        mod rug100 {
            use super::*;

            const PRECISION: u32 = 100;

            mod real {
                use super::*;
                use rug::Float;

                #[test]
                fn test_acos_() {
                    let value = RealRug::<PRECISION>(Float::with_val(PRECISION, 0.5));
                    let result = value.clone().acos_();
                    assert_eq!(
                        result,
                        RealRug::<PRECISION>(Float::with_val(PRECISION, value.0.acos()))
                    );
                }

                #[test]
                fn test_acosh_() {
                    let value = RealRug::<PRECISION>(Float::with_val(PRECISION, 1.5));
                    let result = value.clone().acosh_();
                    assert_eq!(
                        result,
                        RealRug::<PRECISION>(Float::with_val(PRECISION, value.0.acosh()))
                    );
                }

                #[test]
                fn test_asin_() {
                    let value = RealRug::<PRECISION>(Float::with_val(PRECISION, 0.5));
                    let result = value.clone().asin_();
                    assert_eq!(
                        result,
                        RealRug::<PRECISION>(Float::with_val(PRECISION, value.0.asin()))
                    );
                }

                #[test]
                fn test_asinh_() {
                    let value = RealRug::<PRECISION>(Float::with_val(PRECISION, 0.5));
                    let result = value.clone().asinh_();
                    assert_eq!(
                        result,
                        RealRug::<PRECISION>(Float::with_val(PRECISION, value.0.asinh()))
                    );
                }

                #[test]
                fn test_atan_() {
                    let value = RealRug::<PRECISION>(Float::with_val(PRECISION, 0.5));
                    let result = value.clone().atan_();
                    assert_eq!(
                        result,
                        RealRug::<PRECISION>(Float::with_val(PRECISION, value.0.atan()))
                    );
                }

                #[test]
                fn test_atanh_() {
                    let value = RealRug::<PRECISION>(Float::with_val(PRECISION, 0.5));
                    let result = value.clone().atanh_();
                    assert_eq!(
                        result,
                        RealRug::<PRECISION>(Float::with_val(PRECISION, value.0.atanh()))
                    );
                }

                #[test]
                fn test_cos_() {
                    let value = RealRug::<PRECISION>(Float::with_val(PRECISION, 0.5));
                    let result = value.clone().cos_();
                    assert_eq!(
                        result,
                        RealRug::<PRECISION>(Float::with_val(PRECISION, value.0.cos()))
                    );
                }

                #[test]
                fn test_cosh_() {
                    let value = RealRug::<PRECISION>(Float::with_val(PRECISION, 0.5));
                    let result = value.clone().cosh_();
                    assert_eq!(
                        result,
                        RealRug::<PRECISION>(Float::with_val(PRECISION, value.0.cosh()))
                    );
                }

                #[test]
                fn test_exp_() {
                    let value = RealRug::<PRECISION>(Float::with_val(PRECISION, 0.5));
                    let result = value.clone().exp_();
                    print!("result = {:?}", result);
                    assert_eq!(
                        result,
                        RealRug::<PRECISION>(Float::with_val(PRECISION, value.0.exp()))
                    );
                }

                #[test]
                fn test_is_finite_() {
                    let value = RealRug::<PRECISION>(Float::with_val(PRECISION, 0.5));
                    assert!(value.is_finite_());

                    let value = RealRug::<PRECISION>(Float::with_val(PRECISION, f64::INFINITY));
                    assert!(!value.is_finite_());
                }

                #[test]
                fn test_is_infinite_() {
                    let value = RealRug::<PRECISION>(Float::with_val(PRECISION, f64::INFINITY));
                    assert!(value.is_infinite_());

                    let value = RealRug::<PRECISION>(Float::with_val(PRECISION, 0.5));
                    assert!(!value.is_infinite_());
                }

                #[test]
                fn test_ln_() {
                    let value = RealRug::<PRECISION>(Float::with_val(PRECISION, 2.718281828459045));
                    let result = value.clone().ln_();
                    println!("result = {:?}", result);
                    assert_eq!(
                        result,
                        RealRug::<PRECISION>(Float::with_val(PRECISION, value.0.ln()))
                    );
                }

                #[test]
                fn test_log10_() {
                    let value = RealRug::<PRECISION>(Float::with_val(PRECISION, 10.0));
                    let result = value.clone().log10_();
                    println!("result = {:?}", result);
                    assert_eq!(
                        result,
                        RealRug::<PRECISION>(Float::with_val(PRECISION, value.0.log10()))
                    );
                }

                #[test]
                fn test_log2_() {
                    let value = RealRug::<PRECISION>(Float::with_val(PRECISION, 8.0));
                    let result = value.clone().log2_();
                    println!("result = {:?}", result);
                    assert_eq!(
                        result,
                        RealRug::<PRECISION>(Float::with_val(PRECISION, value.0.log2()))
                    );
                }

                #[test]
                fn test_recip_() {
                    let value = RealRug::<PRECISION>(Float::with_val(PRECISION, 2.0));
                    let result = value.clone().try_reciprocal().unwrap();
                    assert_eq!(
                        result,
                        RealRug::<PRECISION>(Float::with_val(PRECISION, value.0.recip()))
                    );
                }

                #[test]
                fn test_sin_() {
                    let value = RealRug::<PRECISION>(Float::with_val(PRECISION, 0.5));
                    let result = value.clone().sin_();
                    assert_eq!(
                        result,
                        RealRug::<PRECISION>(Float::with_val(PRECISION, value.0.sin()))
                    );
                }

                #[test]
                fn test_sinh_() {
                    let value = RealRug::<PRECISION>(Float::with_val(PRECISION, 0.5));
                    let result = value.clone().sinh_();
                    assert_eq!(
                        result,
                        RealRug::<PRECISION>(Float::with_val(PRECISION, value.0.sinh()))
                    );
                }

                #[test]
                fn sqrt() {
                    let value = RealRug::<PRECISION>(Float::with_val(PRECISION, 4.0));
                    let result = value.clone().sqrt();
                    assert_eq!(
                        result,
                        RealRug::<PRECISION>(Float::with_val(PRECISION, value.0.sqrt()))
                    );
                }

                #[test]
                fn try_sqrt() {
                    let value = RealRug::<PRECISION>(Float::with_val(PRECISION, 4.0));
                    let result = value.clone().try_sqrt().unwrap();
                    assert_eq!(
                        result,
                        RealRug::<PRECISION>(Float::with_val(PRECISION, value.0.sqrt()))
                    );

                    assert!(RealRug::<PRECISION>(Float::with_val(PRECISION, -4.0))
                        .try_sqrt()
                        .is_err())
                }

                #[test]
                fn test_tan_() {
                    let value = RealRug::<PRECISION>(Float::with_val(PRECISION, 0.5));
                    let result = value.clone().tan_();
                    assert_eq!(
                        result,
                        RealRug::<PRECISION>(Float::with_val(PRECISION, value.0.tan()))
                    );
                }

                #[test]
                fn test_tanh_() {
                    let value = RealRug::<PRECISION>(Float::with_val(PRECISION, 0.5));
                    let result = value.clone().tanh_();
                    assert_eq!(
                        result,
                        RealRug::<PRECISION>(Float::with_val(PRECISION, value.0.tanh()))
                    );
                }

                #[test]
                fn test_mul_add_() {
                    let a = RealRug::<PRECISION>(Float::with_val(PRECISION, 2.0));
                    let b = RealRug::<PRECISION>(Float::with_val(PRECISION, 3.0));
                    let c = RealRug::<PRECISION>(Float::with_val(PRECISION, 4.0));
                    let result = a.clone().mul_add(&b, &c);
                    assert_eq!(result, RealRug::<PRECISION>(a.0.clone() * b.0 + c.0));
                }
            }

            mod complex {
                use super::*;
                use rug::Complex;
                use rug::Float;

                #[test]
                fn test_acos_() {
                    let value = ComplexRug::<PRECISION>(Complex::with_val(PRECISION, (0.5, 0.5)));
                    let result = value.clone().acos_();
                    assert_eq!(
                        result,
                        ComplexRug::<PRECISION>(Complex::with_val(PRECISION, value.0.acos()))
                    );
                }

                #[test]
                fn test_acosh_() {
                    let value = ComplexRug::<PRECISION>(Complex::with_val(PRECISION, (1.5, 0.5)));
                    let result = value.clone().acosh_();
                    assert_eq!(
                        result,
                        ComplexRug::<PRECISION>(Complex::with_val(PRECISION, value.0.acosh()))
                    );
                }

                #[test]
                fn test_asin_() {
                    let value = ComplexRug::<PRECISION>(Complex::with_val(PRECISION, (0.5, 0.5)));
                    let result = value.clone().asin_();
                    assert_eq!(
                        result,
                        ComplexRug::<PRECISION>(Complex::with_val(PRECISION, value.0.asin()))
                    );
                }

                #[test]
                fn test_asinh_() {
                    let value = ComplexRug::<PRECISION>(Complex::with_val(PRECISION, (0.5, 0.5)));
                    let result = value.clone().asinh_();
                    assert_eq!(
                        result,
                        ComplexRug::<PRECISION>(Complex::with_val(PRECISION, value.0.asinh()))
                    );
                }

                #[test]
                fn test_atan_() {
                    let value = ComplexRug::<PRECISION>(Complex::with_val(PRECISION, (0.5, 0.5)));
                    let result = value.clone().atan_();
                    assert_eq!(
                        result,
                        ComplexRug::<PRECISION>(Complex::with_val(PRECISION, value.0.atan()))
                    );
                }

                #[test]
                fn test_atanh_() {
                    let value = ComplexRug::<PRECISION>(Complex::with_val(PRECISION, (0.5, 0.5)));
                    let result = value.clone().atanh_();
                    assert_eq!(
                        result,
                        ComplexRug::<PRECISION>(Complex::with_val(PRECISION, value.0.atanh()))
                    );
                }

                #[test]
                fn test_cos_() {
                    let value = ComplexRug::<PRECISION>(Complex::with_val(PRECISION, (0.5, 0.5)));
                    let result = value.clone().cos_();
                    assert_eq!(
                        result,
                        ComplexRug::<PRECISION>(Complex::with_val(PRECISION, value.0.cos()))
                    );
                }

                #[test]
                fn test_cosh_() {
                    let value = ComplexRug::<PRECISION>(Complex::with_val(PRECISION, (0.5, 0.5)));
                    let result = value.clone().cosh_();
                    assert_eq!(
                        result,
                        ComplexRug::<PRECISION>(Complex::with_val(PRECISION, value.0.cosh()))
                    );
                }

                #[test]
                fn test_exp_() {
                    let value = ComplexRug::<PRECISION>(Complex::with_val(PRECISION, (0.5, 0.5)));
                    let result = value.clone().exp_();
                    print!("result = {:?}", result);
                    assert_eq!(
                        result,
                        ComplexRug::<PRECISION>(Complex::with_val(PRECISION, value.0.exp()))
                    );
                }

                #[test]
                fn test_is_finite_() {
                    let value = ComplexRug::<PRECISION>(Complex::with_val(PRECISION, (0.5, 0.5)));
                    assert!(value.is_finite_());

                    let value = ComplexRug::<PRECISION>(Complex::with_val(
                        100,
                        (Float::with_val(PRECISION, f64::INFINITY), 0.5),
                    ));
                    assert!(!value.is_finite_());
                }

                #[test]
                fn test_is_infinite_() {
                    let value = ComplexRug::<PRECISION>(Complex::with_val(
                        100,
                        (Float::with_val(PRECISION, f64::INFINITY), 0.5),
                    ));
                    assert!(value.is_infinite_());

                    let value = ComplexRug::<PRECISION>(Complex::with_val(PRECISION, (0.5, 0.5)));
                    assert!(!value.is_infinite_());
                }

                #[test]
                fn test_ln_() {
                    let value = ComplexRug::<PRECISION>(Complex::with_val(
                        PRECISION,
                        (2.718281828459045, 1.0),
                    ));
                    let result = value.clone().ln_();
                    println!("result = {:?}", result);
                    assert_eq!(
                        result,
                        ComplexRug::<PRECISION>(Complex::with_val(PRECISION, value.0.ln()))
                    );
                }

                #[test]
                fn test_log10_() {
                    let value = ComplexRug::<PRECISION>(Complex::with_val(PRECISION, (10.0, 1.0)));
                    let result = value.clone().log10_();
                    println!("result = {:?}", result);
                    assert_eq!(
                        result,
                        ComplexRug::<PRECISION>(Complex::with_val(PRECISION, value.0.log10()))
                    );
                }

                #[test]
                fn test_log2_() {
                    let value = ComplexRug::<PRECISION>(Complex::with_val(PRECISION, (8.0, 1.0)));
                    let result = value.clone().log2_();
                    println!("result = {:?}", result);
                    assert_eq!(
                        result,
                        ComplexRug::<PRECISION>(Complex::with_val(
                            PRECISION,
                            value.0.log10() / rug::Float::with_val(PRECISION, 2.).log10()
                        ))
                    );
                }

                #[test]
                fn test_recip_() {
                    let value = ComplexRug::<PRECISION>(Complex::with_val(PRECISION, (2.0, 0.0)));
                    let result = value.clone().try_reciprocal().unwrap();
                    assert_eq!(
                        result,
                        ComplexRug::<PRECISION>(Complex::with_val(PRECISION, value.0.recip()))
                    );
                }

                #[test]
                fn test_sin_() {
                    let value = ComplexRug::<PRECISION>(Complex::with_val(PRECISION, (0.5, 0.5)));
                    let result = value.clone().sin_();
                    assert_eq!(
                        result,
                        ComplexRug::<PRECISION>(Complex::with_val(PRECISION, value.0.sin()))
                    );
                }

                #[test]
                fn test_sinh_() {
                    let value = ComplexRug::<PRECISION>(Complex::with_val(PRECISION, (0.5, 0.5)));
                    let result = value.clone().sinh_();
                    assert_eq!(
                        result,
                        ComplexRug::<PRECISION>(Complex::with_val(PRECISION, value.0.sinh()))
                    );
                }

                #[test]
                fn sqrt() {
                    let value = ComplexRug::<PRECISION>(Complex::with_val(PRECISION, (4.0, 1.0)));
                    let result = value.clone().sqrt();
                    assert_eq!(
                        result,
                        ComplexRug::<PRECISION>(Complex::with_val(PRECISION, value.0.sqrt()))
                    );
                }

                #[test]
                fn try_sqrt() {
                    let value = ComplexRug::<PRECISION>(Complex::with_val(PRECISION, (4.0, 1.0)));
                    let result = value.clone().try_sqrt().unwrap();
                    assert_eq!(
                        result,
                        ComplexRug::<PRECISION>(Complex::with_val(PRECISION, value.0.sqrt()))
                    );
                }

                #[test]
                fn test_tan_() {
                    let value = ComplexRug::<PRECISION>(Complex::with_val(PRECISION, (0.5, 0.5)));
                    let result = value.clone().tan_();
                    assert_eq!(
                        result,
                        ComplexRug::<PRECISION>(Complex::with_val(PRECISION, value.0.tan()))
                    );
                }

                #[test]
                fn test_tanh_() {
                    let value = ComplexRug::<PRECISION>(Complex::with_val(PRECISION, (0.5, 0.5)));
                    let result = value.clone().tanh_();
                    assert_eq!(
                        result,
                        ComplexRug::<PRECISION>(Complex::with_val(PRECISION, value.0.tanh()))
                    );
                }

                #[test]
                fn test_mul_add_() {
                    let a = ComplexRug::<PRECISION>(Complex::with_val(PRECISION, (2.0, 1.0)));
                    let b = ComplexRug::<PRECISION>(Complex::with_val(PRECISION, (3.0, 1.0)));
                    let c = ComplexRug::<PRECISION>(Complex::with_val(PRECISION, (4.0, 1.0)));
                    let result = a.clone().mul_add(&b, &c);
                    assert_eq!(
                        result,
                        ComplexRug::<PRECISION>(Complex::with_val(PRECISION, a.0 * b.0 + c.0))
                    );
                }
            }
        }
    }

    mod functions_real_type {
        use super::*;

        mod native64 {
            use super::*;

            #[test]
            fn test_atan2_() {
                let a: f64 = 27.0;
                let b: f64 = 13.0;

                let result = a.atan2_(&b);
                assert_eq!(result, a.atan2(b));
            }

            #[test]
            fn test_ceil_() {
                let value: f64 = 3.7;
                let result = value.ceil_();
                assert_eq!(result, value.ceil());
            }

            #[test]
            fn test_clamp_() {
                let value: f64 = 5.0;
                let min: f64 = 3.0;
                let max: f64 = 7.0;
                let result = value.clamp_(&min, &max);
                assert_eq!(result, value.clamp(min, max));
            }

            #[test]
            fn test_classify_() {
                let value: f64 = 3.7;
                let result = value.classify_();
                assert_eq!(result, value.classify());
            }

            #[test]
            fn test_copysign_() {
                let value: f64 = 3.5;
                let sign: f64 = -1.0;
                let result = value.copysign_(&sign);
                assert_eq!(result, value.copysign(sign));
            }

            #[test]
            fn test_epsilon_() {
                let eps = f64::epsilon_();
                assert_eq!(eps, f64::EPSILON);
            }

            #[test]
            fn test_exp_m1_() {
                let value: f64 = 0.5;
                let result = value.exp_m1_();
                assert_eq!(result, value.exp_m1());
            }

            #[test]
            fn test_floor_() {
                let value: f64 = 3.7;
                let result = value.floor_();
                assert_eq!(result, value.floor());
            }

            #[test]
            fn test_fract_() {
                let value: f64 = 3.7;
                let result = value.fract_();
                assert_eq!(result, value.fract());
            }

            #[test]
            fn test_hypot_() {
                let a: f64 = 3.0;
                let b: f64 = 4.0;
                let result = a.hypot_(&b);
                assert_eq!(result, a.hypot(b));
            }

            #[test]
            fn test_infinity_() {
                let inf = f64::infinity_();
                assert_eq!(inf, f64::INFINITY);
            }

            #[test]
            fn test_is_sign_negative_() {
                let value: f64 = -1.0;
                assert!(value.is_sign_negative_());

                let value: f64 = -0.0;
                assert!(value.is_sign_negative_());

                let value: f64 = 0.0;
                assert!(!value.is_sign_negative_());

                let value: f64 = 1.0;
                assert!(!value.is_sign_negative_());
            }

            #[test]
            fn test_is_sign_positive_() {
                let value: f64 = -1.0;
                assert!(!value.is_sign_positive_());

                let value: f64 = -0.0;
                assert!(!value.is_sign_positive_());

                let value: f64 = 0.0;
                assert!(value.is_sign_positive_());

                let value: f64 = 1.0;
                assert!(value.is_sign_positive_());
            }

            #[test]
            fn test_ln_1p_() {
                let value: f64 = 0.5;
                let result = value.ln_1p_();
                assert_eq!(result, value.ln_1p());
            }

            #[test]
            fn test_neg_infinity_() {
                let inf = f64::neg_infinity_();
                assert_eq!(inf, f64::NEG_INFINITY);
            }

            #[test]
            fn test_max_() {
                let a: f64 = 3.0;
                let b: f64 = 4.0;
                let result = a.max_(&b);
                assert_eq!(result, a.max(b));
            }

            #[test]
            fn test_min_() {
                let a: f64 = 3.0;
                let b: f64 = 4.0;
                let result = a.min_(&b);
                assert_eq!(result, a.min(b));
            }

            #[test]
            fn test_mul_add_mul_mut() {
                let mut a: f64 = 2.0;
                let b: f64 = 3.0;
                let c: f64 = 4.0;
                let d: f64 = -1.0;
                let result = a.mul_add_mul_mut_(&b, &c, &d);
                assert_eq!(result, a.mul_add_assign(b, c * d));
            }

            #[test]
            fn test_mul_sub_mul_mut() {
                let mut a: f64 = 2.0;
                let b: f64 = 3.0;
                let c: f64 = 4.0;
                let d: f64 = -1.0;
                let result = a.mul_sub_mul_mut_(&b, &c, &d);
                assert_eq!(result, a.mul_add_assign(b, -c * d));
            }

            #[test]
            fn test_negative_one_() {
                let value = f64::negative_one_();
                assert_eq!(value, -1.0);
            }

            #[test]
            fn test_one_() {
                let value = f64::one();
                assert_eq!(value, 1.0);
            }

            #[test]
            fn test_round_() {
                let value: f64 = 3.5;
                let result = value.round_();
                assert_eq!(result, value.round());
            }

            #[test]
            fn test_round_ties_even_() {
                let value: f64 = 3.5;
                let result = value.round_ties_even_();
                assert_eq!(result, value.round_ties_even());
            }

            #[test]
            fn test_signum_() {
                let value: f64 = -3.5;
                let result = value.signum_();
                assert_eq!(result, value.signum());
            }

            #[test]
            fn test_total_cmp_() {
                let a: f64 = 3.0;
                let b: f64 = 4.0;
                let result = a.total_cmp_(&b);
                assert_eq!(result, a.total_cmp(&b));
            }

            #[test]
            fn test_try_from_64_() {
                let result = f64::try_from_f64_(3.7);
                assert!(result.is_ok());
            }

            #[test]
            fn test_try_from_64_error_infinite() {
                let result = f64::try_from_f64_(f64::INFINITY);
                assert!(result.is_err());
            }

            #[test]
            fn test_try_from_64_error_nan() {
                let result = f64::try_from_f64_(f64::NAN);
                assert!(result.is_err());
            }

            #[test]
            fn test_trunc_() {
                let value: f64 = 3.7;
                let result = value.trunc_();
                assert_eq!(result, value.trunc());
            }

            #[test]
            fn test_two_() {
                let value = f64::two_();
                assert_eq!(value, 2.0);
            }
        }

        #[cfg(feature = "rug")]
        mod rug100 {
            use super::*;
            use rug::{float, Float};

            const PRECISION: u32 = 100;

            #[test]
            fn test_atan2_() {
                let a = RealRug::<PRECISION>(Float::with_val(PRECISION, 27.0));
                let b = RealRug::<PRECISION>(Float::with_val(PRECISION, 13.0));
                let result = a.clone().atan2_(&b);
                assert_eq!(
                    result,
                    RealRug::<PRECISION>(Float::with_val(PRECISION, a.0.atan2(&b.0)))
                );
            }

            #[test]
            fn test_ceil_() {
                let value = RealRug::<PRECISION>(Float::with_val(PRECISION, 3.7));
                let result = value.clone().ceil_();
                assert_eq!(
                    result,
                    RealRug::<PRECISION>(Float::with_val(PRECISION, value.0.ceil()))
                );
            }

            #[test]
            fn test_clamp_() {
                let value = RealRug::<PRECISION>(Float::with_val(PRECISION, 5.0));
                let min = RealRug::<PRECISION>(Float::with_val(PRECISION, 3.0));
                let max = RealRug::<PRECISION>(Float::with_val(PRECISION, 7.0));
                let result = value.clone().clamp_(&min, &max);
                assert_eq!(
                    result,
                    RealRug::<PRECISION>(Float::with_val(PRECISION, value.0.clamp(&min.0, &max.0)))
                );
            }

            #[test]
            fn test_classify_() {
                let value = RealRug::<PRECISION>(Float::with_val(PRECISION, 3.7));
                let result = value.classify_();
                assert_eq!(result, value.0.classify());
            }

            #[test]
            fn test_copysign_() {
                let value = RealRug::<PRECISION>(Float::with_val(PRECISION, 3.5));
                let sign = RealRug::<PRECISION>(Float::with_val(PRECISION, -1.0));
                let result = value.clone().copysign_(&sign);
                assert_eq!(
                    result,
                    RealRug::<PRECISION>(Float::with_val(PRECISION, value.0.copysign(&sign.0)))
                );
            }

            #[test]
            fn test_epsilon_() {
                let rug_eps = rug::Float::u_pow_u(2, PRECISION - 1)
                    .complete(PRECISION.into())
                    .recip();
                println!("eps: {}", rug_eps);

                let eps = RealRug::<PRECISION>::epsilon_();
                assert_eq!(eps, RealRug::<PRECISION>(rug_eps.clone()));

                // here we compute new_eps as the difference between 1 and the next larger floating point number
                let mut new_eps = Float::with_val(PRECISION, 1.);
                new_eps.next_up();
                new_eps -= Float::with_val(PRECISION, 1.);
                assert_eq!(new_eps, rug_eps.clone());

                println!("new_eps: {}", new_eps);

                let one = RealRug::<PRECISION>::one();
                let result = RealRug::<PRECISION>(new_eps / Float::with_val(PRECISION, 2.)) + &one;
                assert_eq!(result, one);
            }

            #[test]
            fn test_exp_m1_() {
                let value = RealRug::<PRECISION>(Float::with_val(PRECISION, 0.5));
                let result = value.clone().exp_m1_();
                assert_eq!(
                    result,
                    RealRug::<PRECISION>(Float::with_val(PRECISION, value.0.exp_m1()))
                );
            }

            #[test]
            fn test_floor_() {
                let value = RealRug::<PRECISION>(Float::with_val(PRECISION, 3.7));
                let result = value.clone().floor_();
                assert_eq!(
                    result,
                    RealRug::<PRECISION>(Float::with_val(PRECISION, value.0.floor()))
                );
            }

            #[test]
            fn test_fract_() {
                let value = RealRug::<PRECISION>(Float::with_val(PRECISION, 3.7));
                let result = value.clone().fract_();
                assert_eq!(
                    result,
                    RealRug::<PRECISION>(Float::with_val(PRECISION, value.0.fract()))
                );
            }

            #[test]
            fn test_hypot_() {
                let a = RealRug::<PRECISION>(Float::with_val(PRECISION, 3.0));
                let b = RealRug::<PRECISION>(Float::with_val(PRECISION, 4.0));
                let result = a.clone().hypot_(&b);
                assert_eq!(
                    result,
                    RealRug::<PRECISION>(Float::with_val(PRECISION, a.0.hypot(&b.0)))
                );
            }

            #[test]
            fn test_infinity_() {
                let inf = RealRug::<PRECISION>::infinity_();
                assert_eq!(
                    inf,
                    RealRug::<PRECISION>(Float::with_val(PRECISION, float::Special::Infinity))
                );
            }

            #[test]
            fn test_is_sign_negative_() {
                let value = RealRug::<PRECISION>(Float::with_val(PRECISION, -1.0));
                assert!(value.is_sign_negative_());

                let value = RealRug::<PRECISION>(Float::with_val(PRECISION, -0.0));
                assert!(value.is_sign_negative_());

                let value = RealRug::<PRECISION>(Float::with_val(PRECISION, 0.0));
                assert!(!value.is_sign_negative_());

                let value = RealRug::<PRECISION>(Float::with_val(PRECISION, 1.0));
                assert!(!value.is_sign_negative_());
            }

            #[test]
            fn test_is_sign_positive_() {
                let value = RealRug::<PRECISION>(Float::with_val(PRECISION, -1.0));
                assert!(!value.is_sign_positive_());

                let value = RealRug::<PRECISION>(Float::with_val(PRECISION, -0.0));
                assert!(!value.is_sign_positive_());

                let value = RealRug::<PRECISION>(Float::with_val(PRECISION, 0.0));
                assert!(value.is_sign_positive_());

                let value = RealRug::<PRECISION>(Float::with_val(PRECISION, 1.0));
                assert!(value.is_sign_positive_());
            }

            #[test]
            fn test_ln_1p_() {
                let value = RealRug::<PRECISION>(Float::with_val(PRECISION, 0.5));
                let result = value.clone().ln_1p_();
                assert_eq!(
                    result,
                    RealRug::<PRECISION>(Float::with_val(PRECISION, value.0.ln_1p()))
                );
            }

            #[test]
            fn test_neg_infinity_() {
                let inf = RealRug::<PRECISION>::neg_infinity_();
                assert_eq!(
                    inf,
                    RealRug::<PRECISION>(Float::with_val(PRECISION, float::Special::NegInfinity))
                );
            }

            #[test]
            fn test_max_() {
                let a = RealRug::<PRECISION>(Float::with_val(PRECISION, 3.0));
                let b = RealRug::<PRECISION>(Float::with_val(PRECISION, 4.0));
                let result = a.clone().max_(&b);
                assert_eq!(
                    result,
                    RealRug::<PRECISION>(Float::with_val(PRECISION, a.0.max(&b.0)))
                );
            }

            #[test]
            fn test_min_() {
                let a = RealRug::<PRECISION>(Float::with_val(PRECISION, 3.0));
                let b = RealRug::<PRECISION>(Float::with_val(PRECISION, 4.0));
                let result = a.clone().min_(&b);
                assert_eq!(
                    result,
                    RealRug::<PRECISION>(Float::with_val(PRECISION, a.0.min(&b.0)))
                );
            }

            #[test]
            fn test_mul_add_mul_mut() {
                let a = RealRug::<PRECISION>(Float::with_val(PRECISION, 2.0));
                let b = RealRug::<PRECISION>(Float::with_val(PRECISION, 3.0));
                let c = RealRug::<PRECISION>(Float::with_val(PRECISION, 4.0));
                let d = RealRug::<PRECISION>(Float::with_val(PRECISION, -1.0));
                let mut result = a.clone();
                result.mul_add_mul_mut_(&b, &c, &d);
                assert_eq!(
                    result,
                    RealRug::<PRECISION>(Float::with_val(
                        PRECISION,
                        a.0.mul_add(&b.0, &(c.0 * &d.0))
                    ))
                );
            }

            #[test]
            fn test_mul_sub_mul_mut() {
                let a = RealRug::<PRECISION>(Float::with_val(PRECISION, 2.0));
                let b = RealRug::<PRECISION>(Float::with_val(PRECISION, 3.0));
                let c = RealRug::<PRECISION>(Float::with_val(PRECISION, 4.0));
                let d = RealRug::<PRECISION>(Float::with_val(PRECISION, -1.0));
                let mut result = a.clone();
                result.mul_sub_mul_mut_(&b, &c, &d);
                assert_eq!(
                    result,
                    RealRug::<PRECISION>(Float::with_val(
                        PRECISION,
                        a.0.mul_add(&b.0, &(-c.0 * &d.0))
                    ))
                );
            }

            #[test]
            fn test_negative_one_() {
                let value = RealRug::<PRECISION>::negative_one_();
                assert_eq!(
                    value,
                    RealRug::<PRECISION>(Float::with_val(PRECISION, -1.0))
                );
            }

            #[test]
            fn test_one_() {
                let value = RealRug::<PRECISION>::one();
                assert_eq!(value, RealRug::<PRECISION>(Float::with_val(PRECISION, 1.0)));
            }

            #[test]
            fn test_round_() {
                let value = RealRug::<PRECISION>(Float::with_val(PRECISION, 3.5));
                let result = value.clone().round_();
                assert_eq!(
                    result,
                    RealRug::<PRECISION>(Float::with_val(PRECISION, value.0.round()))
                );
            }

            #[test]
            fn test_round_ties_even_() {
                let value = RealRug::<PRECISION>(Float::with_val(PRECISION, 3.5));
                let result = value.clone().round_ties_even_();
                assert_eq!(
                    result,
                    RealRug::<PRECISION>(Float::with_val(PRECISION, value.0.round_even()))
                );
            }

            #[test]
            fn test_signum_() {
                let value = RealRug::<PRECISION>(Float::with_val(PRECISION, -3.5));
                let result = value.clone().signum_();
                assert_eq!(
                    result,
                    RealRug::<PRECISION>(Float::with_val(PRECISION, value.0.signum()))
                );
            }

            #[test]
            fn test_total_cmp_() {
                let a = RealRug::<PRECISION>(Float::with_val(PRECISION, 3.0));
                let b = RealRug::<PRECISION>(Float::with_val(PRECISION, 4.0));
                let result = a.total_cmp_(&b);
                assert_eq!(result, a.0.total_cmp(&b.0));
            }

            #[test]
            fn test_try_from_64_() {
                let result = RealRug::<PRECISION>::try_from_f64_(3.7);
                assert!(result.is_ok());
            }

            #[test]
            fn test_try_from_64_error_infinite() {
                let result = RealRug::<PRECISION>::try_from_f64_(f64::INFINITY);
                assert!(result.is_err());
            }

            #[test]
            fn test_try_from_64_error_nan() {
                let result = RealRug::<PRECISION>::try_from_f64_(f64::NAN);
                assert!(result.is_err());
            }

            #[test]
            fn test_trunc_() {
                let value = RealRug::<PRECISION>(Float::with_val(PRECISION, 3.7));
                let result = value.clone().trunc_();
                assert_eq!(
                    result,
                    RealRug::<PRECISION>(Float::with_val(PRECISION, value.0.trunc()))
                );
            }

            #[test]
            fn test_two_() {
                let value = RealRug::<PRECISION>::two_();
                assert_eq!(value, RealRug::<PRECISION>(Float::with_val(PRECISION, 2.0)));
            }
        }
    }
}