Struct LogDomain

pub struct LogDomain<F: Float>(/* private fields */);

A struct that represents positive floats by their natural logarithm.

Examples

use log_domain::LogDomain;
use num_traits::{One, Zero};

match (LogDomain::new(0.5), LogDomain::new(0.25), LogDomain::new(0.75)) {
    (Ok(x), Ok(y), Ok(z)) => {
        assert_eq!(x.value(), 0.5);            // 0.5         = 0.5
        assert_eq!(x.ln(), f64::ln(0.5));      // ln(0.5)     = ln(0.5)

        // Operations `+`, `-`, `*`, `/`, and `pow`
        assert_eq!(x + y, z);                  // 0.5  + 0.25 = 0.75
        assert_eq!(z - x, y);                  // 0.75 - 0.5  = 0.25
        assert_eq!(x * x, y);                  // 0.5  ⋅ 0.5  = 0.25
        assert_eq!(y / x, x);                  // 0.25 / 0.5  = 0.5
        assert_eq!(x.pow(2.0), y);             // 0.5²        = 0.25
        assert_eq!(y.pow(1.0 / 2.0), x);       // √0.25       = 0.5

        // Assignment operators `+=`, `-=`, `*=`, and `/=`
        let mut a = x;
        a += y;                                // a = 0.5  + 0.25 = 0.75
        assert_eq!(a, z);                      // a = 0.75 = z
        a = z;
        a -= x;                                // a = 0.75 - 0.5  = 0.25
        assert_eq!(a, y);                      // a = 0.25 = y
        a = x;
        a *= a;                                // a = 0.5  * 0.5  = 0.25
        assert_eq!(a, y);                      // a = 0.25 = y
        a = y;
        a /= x;                                // a = 0.25 / 0.5  = 0.5
        assert_eq!(a, x);                      // a = 0.5 = x

        // Neutral elements `LogDomain::zero()` and `LogDomain::one()`
        assert_eq!(z + LogDomain::zero(), z);  // 0.75 + 0    = 0.75
        assert_eq!(z - z, LogDomain::zero());  // 0.75 - 0.75 = 0
        assert_eq!(z * LogDomain::one(), z);   // 0.75 * 1    = 0.75
        assert_eq!(z / z, LogDomain::one());   // 0.75 / 0.75 = 1
        assert_eq!(z * LogDomain::zero(), LogDomain::zero());
                                               // 0.75 * 0    = 0
        assert_eq!(z.pow(0.0), LogDomain::one());
                                               // 0.75⁰       = 1

        // Comparison
        assert!(z > y);                        // 0.75 > 0.25
        assert!(y < z);                        // 0.25 < 0.75
    },
    _ => panic!(),
}

Implementations

impl<F: Float + Debug> LogDomain<F>

pub fn new(value: F) -> Result<Self, String>

Creates a new LogDomain from a given value in the interval [0,∞).

impl<F: Float> LogDomain<F>

pub fn ln(&self) -> F

Logarithm of the value that is represented by the given LogDomain.

pub fn value(&self) -> F

Value that is represented by the given LogDomain.

pub fn pow(&self, power: F) -> Self

Raise the represented probability to the power of a Float value.

Trait Implementations

impl<F: Float> Add for LogDomain<F>

An impl of Add that uses only two applications of transcendental functions (exp and ln_1p) to increase precision.

type Output = LogDomain<F>

The resulting type after applying the + operator.

fn add(self, other: Self) -> Self

Performs the + operation.

impl<F: Float> AddAssign for LogDomain<F>

fn add_assign(&mut self, other: Self)

Performs the += operation.

impl<F: Clone + Float> Clone for LogDomain<F>

fn clone(&self) -> LogDomain<F>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<F: Debug + Float> Debug for LogDomain<F>

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

Formats the value using the given formatter.

impl<'de, F: Float + Deserialize<'de>> Deserialize<'de> for LogDomain<F>

fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

impl<F: Float + Display> Display for LogDomain<F>

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

Formats the value using the given formatter.

impl<F: Float> Div for LogDomain<F>

type Output = LogDomain<F>

The resulting type after applying the / operator.

fn div(self, other: Self) -> Self

Performs the / operation.

impl<F: Float> DivAssign for LogDomain<F>

fn div_assign(&mut self, other: Self)

Performs the /= operation.

impl<F: Debug + Float + FromStr<Err = E>, E: ToString> FromStr for LogDomain<F>

type Err = String

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl<F: Float> Mul for LogDomain<F>

type Output = LogDomain<F>

The resulting type after applying the * operator.

fn mul(self, other: Self) -> Self

Performs the * operation.

impl<F: Float> MulAssign for LogDomain<F>

fn mul_assign(&mut self, other: Self)

Performs the *= operation.

impl<F: Float> One for LogDomain<F>

fn one() -> Self

Returns the multiplicative identity element of Self, 1.

fn set_one(&mut self)

Sets self to the multiplicative identity element of Self, 1.

fn is_one(&self) -> bool

where Self: PartialEq,

Returns true if self is equal to the multiplicative identity.

impl<F: Float> Ord for LogDomain<F>

An impl of Ord that defines Exp(NaN) = Exp(NaN), Exp(NaN) < Exp(y), and Exp(x) < Exp(y) for x < y.

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

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<F: Float> PartialEq for LogDomain<F>

An impl of PartialEq that defines Exp(NaN) = Exp(NaN) and Exp(x) = Exp(y) for x - y < F::EPSILON.

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

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

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

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

impl<F: PartialOrd + Float> PartialOrd for LogDomain<F>

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

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

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

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

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

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

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

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

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

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

impl<F: Float + Serialize> Serialize for LogDomain<F>

fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.

impl<F: Float + Debug> Sub for LogDomain<F>

An impl of Sub that uses only two applications of transcendental functions (exp_m1 and ln) to increase precision.

type Output = LogDomain<F>

The resulting type after applying the - operator.

fn sub(self, other: Self) -> Self

Performs the - operation.

impl<F: Float + Debug> SubAssign for LogDomain<F>

fn sub_assign(&mut self, other: Self)

Performs the -= operation.

impl<F: Float> Zero for LogDomain<F>

fn zero() -> Self

Returns the additive identity element of Self, 0.

fn is_zero(&self) -> bool

Returns true if self is equal to the additive identity.

fn set_zero(&mut self)

Sets self to the additive identity element of Self, 0.

impl<F: Copy + Float> Copy for LogDomain<F>

impl<F: Float> Eq for LogDomain<F>