# Struct inari::Interval[−][src]

#[repr(C)]pub struct Interval { /* fields omitted */ }
Expand description

An interval with f64 bounds.

It is sometimes referred to as a bare interval in contrast to a decorated interval (DecInterval).

## Implementations

Returns the absolute value of self.

Tightness: tightest

Returns $[\max(a, c), \max(b, d)]$ if both $\self = [a, b]$ and $\rhs = [c, d]$ are nonempty; otherwise, $∅$.

Tightness: tightest

Returns $[\min(a, c), \min(b, d)]$ if both $\self = [a, b]$ and $\rhs = [c, d]$ are nonempty; otherwise $∅$.

Tightness: tightest

Returns $(\self × \rhs) + \addend$.

Tightness: tightest

Returns the multiplicative inverse of self.

Tightness: tightest

Returns the square of self.

Tightness: tightest

Returns the principal square root of self.

Tightness: tightest

Returns true if rhs is a member of self ($\rhs ∈ \self$).

If rhs is not a real number, false is returned.

# Examples

use inari::*;
assert!(const_interval!(1.0, 2.0).contains(1.0));
assert!(!Interval::EMPTY.contains(1.0));
assert!(Interval::ENTIRE.contains(1.0));

$±∞$ and NaN are not real numbers, thus do not belong to any interval:

use inari::*;
assert!(!Interval::ENTIRE.contains(f64::INFINITY));
assert!(!Interval::ENTIRE.contains(f64::NEG_INFINITY));
assert!(!Interval::ENTIRE.contains(f64::NAN));

Returns true if self and rhs are disjoint ($\self ∩ \rhs = ∅$).

The formal definition is:

$$∀x ∈ \self, ∀y ∈ \rhs : x ≠ y.$$

# Examples

use inari::*;
assert!(const_interval!(1.0, 2.0).disjoint(const_interval!(3.0, 4.0)));
assert!(!const_interval!(1.0, 3.0).disjoint(const_interval!(3.0, 4.0)));
assert!(!const_interval!(1.0, 5.0).disjoint(const_interval!(3.0, 4.0)));
assert!(Interval::EMPTY.disjoint(Interval::EMPTY));
assert!(Interval::EMPTY.disjoint(Interval::ENTIRE));

Returns true if self is interior to rhs.

The formal definition is:

$$(∀x ∈ \self, ∃y ∈ \rhs : x < y) ∧ (∀x ∈ \self, ∃y ∈ \rhs : y < x).$$

# Examples

use inari::*;
assert!(const_interval!(1.1, 1.9).interior(const_interval!(1.0, 2.0)));
assert!(!const_interval!(1.1, 2.0).interior(const_interval!(1.0, 2.0)));
assert!(Interval::EMPTY.interior(Interval::EMPTY));
assert!(Interval::ENTIRE.interior(Interval::ENTIRE));

Returns true if self is nonempty and bounded.

# Examples

use inari::*;
assert!(const_interval!(1.0, 2.0).is_common_interval());
assert!(!const_interval!(1.0, f64::INFINITY).is_common_interval());
assert!(!Interval::EMPTY.is_common_interval());
assert!(!Interval::ENTIRE.is_common_interval());

Returns true if self is empty ($\self = ∅$).

# Examples

use inari::*;
assert!(!const_interval!(1.0, 1.0).is_empty());
assert!(Interval::EMPTY.is_empty());
assert!(!Interval::ENTIRE.is_empty());

Returns true if $\self = [-∞, +∞]$.

# Examples

use inari::*;
assert!(!const_interval!(1.0, f64::INFINITY).is_entire());
assert!(!Interval::EMPTY.is_entire());
assert!(Interval::ENTIRE.is_entire());

Returns true if self consists of a single real number.

# Examples

use inari::*;
assert!(const_interval!(1.0, 1.0).is_singleton());
assert!(!const_interval!(1.0, 2.0).is_singleton());
assert!(!Interval::EMPTY.is_singleton());
assert!(!Interval::ENTIRE.is_singleton());

0.1 is not a member of f64:

use inari::*;
// The singleton set that consists of the nearest f64 number to 0.1.
assert!(const_interval!(0.1, 0.1).is_singleton());
// The tightest interval that encloses 0.1.
#[cfg(feature = "gmp")]
assert!(!interval!("[0.1, 0.1]").unwrap().is_singleton());

Returns true if self is weakly less than rhs.

The formal definition is:

$$(∀x ∈ \self, ∃y ∈ \rhs : x ≤ y) ∧ (∀y ∈ \rhs, ∃x ∈ \self : x ≤ y).$$

# Examples

use inari::*;
assert!(const_interval!(1.0, 2.0).less(const_interval!(3.0, 4.0)));
assert!(const_interval!(1.0, 3.0).less(const_interval!(2.0, 4.0)));
assert!(const_interval!(1.0, 4.0).less(const_interval!(1.0, 4.0)));
assert!(Interval::EMPTY.less(Interval::EMPTY));
assert!(!Interval::EMPTY.less(Interval::ENTIRE));
assert!(!Interval::ENTIRE.less(Interval::EMPTY));
assert!(Interval::ENTIRE.less(Interval::ENTIRE));

Returns true if self is to the left of but may touch rhs.

The formal definition is:

$$∀x ∈ \self, ∀y ∈ \rhs : x ≤ y.$$

# Examples

use inari::*;
assert!(const_interval!(1.0, 2.0).precedes(const_interval!(3.0, 4.0)));
assert!(const_interval!(1.0, 3.0).precedes(const_interval!(3.0, 4.0)));
assert!(!const_interval!(1.0, 3.0).precedes(const_interval!(2.0, 4.0)));
assert!(Interval::EMPTY.precedes(Interval::EMPTY));
assert!(Interval::EMPTY.precedes(Interval::ENTIRE));
assert!(Interval::ENTIRE.precedes(Interval::EMPTY));
assert!(!Interval::ENTIRE.precedes(Interval::ENTIRE));

Returns true if self is strictly less than rhs.

The formal definition is:

$$(∀x ∈ \self, ∃y ∈ \rhs : x < y) ∧ (∀y ∈ \self, ∃x ∈ \rhs : x < y).$$

# Examples

use inari::*;
assert!(const_interval!(1.0, 2.0).strict_less(const_interval!(3.0, 4.0)));
assert!(const_interval!(1.0, 3.0).strict_less(const_interval!(2.0, 4.0)));
assert!(!const_interval!(1.0, 4.0).strict_less(const_interval!(2.0, 4.0)));
assert!(const_interval!(1.0, f64::INFINITY).strict_less(const_interval!(2.0, f64::INFINITY)));
assert!(Interval::EMPTY.strict_less(Interval::EMPTY));
assert!(!Interval::EMPTY.strict_less(Interval::ENTIRE));
assert!(!Interval::ENTIRE.strict_less(Interval::EMPTY));
assert!(Interval::ENTIRE.strict_less(Interval::ENTIRE));

Returns true if self is strictly to the left of rhs.

The formal definition is:

$$∀x ∈ \self, ∀y ∈ \rhs : x < y.$$

Returns true if self is a subset of rhs ($\self ⊆ \rhs$).

The formal definition is:

$$∀x ∈ \self, ∃y ∈ \rhs : x = y.$$

# Examples

use inari::*;
assert!(const_interval!(1.0, 2.0).subset(const_interval!(1.0, 2.0)));
assert!(Interval::EMPTY.subset(Interval::EMPTY));
assert!(Interval::EMPTY.subset(Interval::ENTIRE));
assert!(Interval::ENTIRE.subset(Interval::ENTIRE));

Returns the interchange representation of the interval in the big-endian byte order.

Returns the interchange representation of the interval in the little-endian byte order.

Returns the interchange representation of the interval in the target platform’s native byte order.

Creates an interval from its interchange representation in the big-endian byte order.

Creates an interval from its interchange representation in the little-endian byte order.

Creates an interval from its interchange representation in the target platform’s native byte order.

$∅$, the empty set.

$[-∞, +∞]$, the whole real line.

The tightest interval enclosing $\e$, the base of natural logarithms.

The tightest interval enclosing $1 / π$.

The tightest interval enclosing $1 / \sqrt{2}$.

The tightest interval enclosing $2 / π$.

The tightest interval enclosing $2 / \sqrt{π}$.

The tightest interval enclosing $π / 2$.

The tightest interval enclosing $π / 3$.

The tightest interval enclosing $π / 4$.

The tightest interval enclosing $π / 6$.

The tightest interval enclosing $π / 8$.

The tightest interval enclosing $\ln 10$.

The tightest interval enclosing $\ln 2$.

The tightest interval enclosing $\log_{10} 2$.

The tightest interval enclosing $\log_{10} \e$.

The tightest interval enclosing $\log_2 10$.

The tightest interval enclosing $\log_2 \e$.

The tightest interval enclosing $π$.

The tightest interval enclosing $\sqrt{2}$.

The tightest interval enclosing $2 π$.

Returns the inverse cosine of self.

Tightness: tightest

Returns the inverse hyperbolic cosine of self.

Tightness: tightest

Returns the inverse sine of self.

Tightness: tightest

Returns the inverse hyperbolic sine of self.

Tightness: tightest

Returns the inverse tangent of self.

Tightness: tightest

Returns the angle of the point $(\rhs, \self)$ measured counterclockwise from the positive $x$-axis in the Euclidean $xy$-plane.

Tightness: tightest

Returns the inverse hyperbolic tangent of self.

Tightness: tightest

Returns the cosine of self.

Tightness: tightest

Returns the hyperbolic cosine of self.

Tightness: tightest

Returns the exponential of self.

Tightness: tightest

Returns self raised to the power of 10.

Tightness: tightest

Returns self raised to the power of 2.

Tightness: tightest

Returns the natural logarithm of self.

Tightness: tightest

Returns the base-10 logarithm of self.

Tightness: tightest

Returns the base-2 logarithm of self.

Tightness: tightest

Returns self raised to the power of rhs.

Tightness: tightest

Returns self raised to the power of rhs, where rhs is an integer.

Tightness: tightest

Returns the sine of self.

Tightness: tightest

Returns the hyperbolic sine of self.

Tightness: tightest

Returns the tangent of self.

Tightness: tightest

Returns the hyperbolic tangent of self.

Tightness: tightest

Rounds the bounds of self to integers using directed rounding toward $+∞$.

Tightness: tightest

# Examples

use inari::*;
assert_eq!(const_interval!(0.2, 1.2).ceil(), const_interval!(1.0, 2.0));
assert_eq!(const_interval!(0.8, 1.8).ceil(), const_interval!(1.0, 2.0));
assert_eq!(const_interval!(-1.2, -0.2).ceil(), const_interval!(-1.0, 0.0));
assert_eq!(const_interval!(-1.8, -0.8).ceil(), const_interval!(-1.0, 0.0));
assert_eq!(Interval::EMPTY.ceil(), Interval::EMPTY);
assert_eq!(Interval::ENTIRE.ceil(), Interval::ENTIRE);

Rounds the bounds of self to integers using directed rounding toward $-∞$.

Tightness: tightest

# Examples

use inari::*;
assert_eq!(const_interval!(0.2, 1.2).floor(), const_interval!(0.0, 1.0));
assert_eq!(const_interval!(0.8, 1.8).floor(), const_interval!(0.0, 1.0));
assert_eq!(const_interval!(-1.2, -0.2).floor(), const_interval!(-2.0, -1.0));
assert_eq!(const_interval!(-1.8, -0.8).floor(), const_interval!(-2.0, -1.0));
assert_eq!(Interval::EMPTY.floor(), Interval::EMPTY);
assert_eq!(Interval::ENTIRE.floor(), Interval::ENTIRE);

Rounds the bounds of self to the nearest integers, with halfway cases rounded away from zero.

Tightness: tightest

# Examples

use inari::*;
assert_eq!(const_interval!(0.2, 1.2).round(), const_interval!(0.0, 1.0));
assert_eq!(const_interval!(0.5, 1.5).round(), const_interval!(1.0, 2.0));
assert_eq!(const_interval!(0.8, 1.8).round(), const_interval!(1.0, 2.0));
assert_eq!(const_interval!(-1.2, -0.2).round(), const_interval!(-1.0, 0.0));
assert_eq!(const_interval!(-1.5, -0.5).round(), const_interval!(-2.0, -1.0));
assert_eq!(const_interval!(-1.8, -0.8).round(), const_interval!(-2.0, -1.0));
assert_eq!(Interval::EMPTY.round(), Interval::EMPTY);
assert_eq!(Interval::ENTIRE.round(), Interval::ENTIRE);

See also: Interval::round_ties_to_even.

Rounds the bounds of self to the nearest integers, with halfway cases rounded to even numbers.

Tightness: tightest

# Examples

use inari::*;
assert_eq!(const_interval!(0.2, 1.2).round_ties_to_even(), const_interval!(0.0, 1.0));
assert_eq!(const_interval!(0.5, 1.5).round_ties_to_even(), const_interval!(0.0, 2.0));
assert_eq!(const_interval!(0.8, 1.8).round_ties_to_even(), const_interval!(1.0, 2.0));
assert_eq!(const_interval!(-1.2, -0.2).round_ties_to_even(), const_interval!(-1.0, 0.0));
assert_eq!(const_interval!(-1.5, -0.5).round_ties_to_even(), const_interval!(-2.0, 0.0));
assert_eq!(const_interval!(-1.8, -0.8).round_ties_to_even(), const_interval!(-2.0, -1.0));
assert_eq!(Interval::EMPTY.round_ties_to_even(), Interval::EMPTY);
assert_eq!(Interval::ENTIRE.round_ties_to_even(), Interval::ENTIRE);

See also: Interval::round.

Returns the sign of self.

Note the difference between the sign function and f64::signum; $\sgn(0)$ is always zero, while the values of +0.0_f64.signum() and -0.0_f64.signum() are +1.0 and -1.0, respectively.

Tightness: tightest

# Examples

use inari::*;
assert_eq!(const_interval!(-10.0, -0.1).sign(), const_interval!(-1.0, -1.0));
assert_eq!(const_interval!(0.0, 0.0).sign(), const_interval!(0.0, 0.0));
assert_eq!(const_interval!(0.1, 10.0).sign(), const_interval!(1.0, 1.0));
assert_eq!(Interval::EMPTY.sign(), Interval::EMPTY);
assert_eq!(Interval::ENTIRE.sign(), const_interval!(-1.0, 1.0));

Rounds the bounds of self to integers using directed rounding toward zero.

Tightness: tightest

# Examples

use inari::*;
assert_eq!(const_interval!(0.2, 1.2).trunc(), const_interval!(0.0, 1.0));
assert_eq!(const_interval!(0.8, 1.8).trunc(), const_interval!(0.0, 1.0));
assert_eq!(const_interval!(-1.2, -0.2).trunc(), const_interval!(-1.0, 0.0));
assert_eq!(const_interval!(-1.8, -0.8).trunc(), const_interval!(-1.0, 0.0));
assert_eq!(Interval::EMPTY.trunc(), Interval::EMPTY);
assert_eq!(Interval::ENTIRE.trunc(), Interval::ENTIRE);

Returns the (greatest) lower bound of self.

Equivalently, it returns $a$ if $\self = [a, b]$ is nonempty; otherwise, $+∞$.

# Examples

use inari::*;
assert_eq!(const_interval!(-2.0, 3.0).inf(), -2.0);
assert_eq!(Interval::EMPTY.inf(), f64::INFINITY);
assert_eq!(Interval::ENTIRE.inf(), f64::NEG_INFINITY);

See also: Interval::sup.

Returns the magnitude of self if self is nonempty; otherwise, NaN.

The magnitude of a nonempty interval $𝒙 = [a, b]$ is defined as follows:

$$\operatorname{mag}(𝒙) = \sup\{|x| ∣ x ∈ 𝒙\} = \max(|a|, |b|).$$

# Examples

use inari::*;
assert_eq!(const_interval!(-2.0, 3.0).mag(), 3.0);
assert!(Interval::EMPTY.mag().is_nan());
assert_eq!(Interval::ENTIRE.mag(), f64::INFINITY);

See also: Interval::mig.

Returns the midpoint of self if self is nonempty; otherwise, NaN. For nonempty cases, the following values are returned.

• If $\self = [-∞, +∞]$, zero is returned.
• If $\self = [-∞, b]$ where $b < +∞$, f64::MIN is returned.
• If $\self = [a, +∞]$ where $a > -∞$, f64::MAX is returned.
• If self is bounded, $\operatorname{mid}(\self)$ rounded to the nearest f64 value is returned.

The midpoint of a nonempty interval $𝒙 = [a, b]$ is defined as follows:

$$\operatorname{mid}(𝒙) = \frac{1}{2}(a + b).$$

# Examples

use inari::*;
assert_eq!(const_interval!(-2.0, 3.0).mid(), 0.5);
assert_eq!(const_interval!(f64::NEG_INFINITY, 3.0).mid(), f64::MIN);
assert_eq!(const_interval!(-2.0, f64::INFINITY).mid(), f64::MAX);
assert!(Interval::EMPTY.mid().is_nan());
assert_eq!(Interval::ENTIRE.mid(), 0.0);

See also: Interval::rad.

Returns the mignitude of self if self is nonempty; otherwise, NaN.

The mignitude of a nonempty interval $𝒙 = [a, b]$ is defined as follows:

$$\operatorname{mig}(𝒙) = \inf\{|x| ∣ x ∈ 𝒙\} = \begin{cases} \min(|a|, |b|) & \text{if } \sgn(a) = \sgn(b), \\ 0 & \text{otherwise}. \end{cases}$$

# Examples

use inari::*;
assert_eq!(const_interval!(-2.0, 3.0).mig(), 0.0);
assert_eq!(const_interval!(2.0, 3.0).mig(), 2.0);
assert!(Interval::EMPTY.mig().is_nan());
assert_eq!(Interval::ENTIRE.mig(), 0.0);

See also: Interval::mag.

Returns the radius of self if self is nonempty; otherwise, NaN. The result $r$ is the smallest f64 number that satisfies $\self ⊆ [m - r, m + r]$ where $m$ is the f64 value returned by self.mid().

The radius of a nonempty interval $𝒙 = [a, b]$ is defined as follows:

$$\operatorname{rad}(𝒙) = \frac{1}{2}(b - a).$$

# Examples

use inari::*;
assert_eq!(Interval::ENTIRE.rad(), f64::INFINITY);

See also: Interval::mid.

Returns the (least) upper bound of self.

Equivalently, it returns $b$ if $\self = [a, b]$ is nonempty; otherwise, $-∞$.

# Examples

use inari::*;
assert_eq!(const_interval!(-2.0, 3.0).sup(), 3.0);
assert_eq!(Interval::EMPTY.sup(), f64::NEG_INFINITY);
assert_eq!(Interval::ENTIRE.sup(), f64::INFINITY);

See also: Interval::inf.

Returns the width of self if self is nonempty; otherwise, NaN. The result is rounded toward $+∞$.

The width of a nonempty interval $𝒙 = [a, b]$ is defined as follows:

$$\operatorname{wid}(𝒙) = b - a.$$

# Examples

use inari::*;
assert_eq!(const_interval!(-2.0, 3.0).wid(), 5.0);
assert_eq!(const_interval!(-1.0, f64::MAX).wid(), f64::INFINITY);
assert!(Interval::EMPTY.wid().is_nan());
assert_eq!(Interval::ENTIRE.wid(), f64::INFINITY);

Returns the overlapping state of self and rhs. See Overlap for the possible values returned.

Returns $[\min(a, c), \max(b, d)]$ if both $\self = [a, b]$ and $\rhs = [c, d]$ are nonempty. If either interval is empty, the other is returned. If both are empty, $∅$ is returned.

This is equivalent to $\self ∪ \rhs$ if the intervals are not disjoint,

Tightness: tightest

Returns $\self ∩ \rhs$. If the result is nonempty, it is equivalent to $[\max(a, c), \min(b, d)]$, where both $\self = [a, b]$ and $\rhs = [c, d]$ are nonempty.

Tightness: tightest

## Trait Implementations

Tightness: tightest

The resulting type after applying the + operator.

Performs the += operation. Read more

Returns a copy of the value. Read more

Performs copy-assignment from source. Read more

Formats the value using the given formatter. Read more

Formats the value using the given formatter. Read more

Tightness: tightest

The resulting type after applying the / operator.

Performs the /= operation. Read more

The associated error which can be returned from parsing.

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

Formats the value using the given formatter.

Formats the value using the given formatter.

Tightness: tightest

The resulting type after applying the * operator.

Performs the *= operation. Read more

Tightness: tightest

The resulting type after applying the - operator.

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

Tightness: tightest

The resulting type after applying the - operator.

Performs the -= operation. Read more

The type returned in the event of a conversion error.

Performs the conversion.

## Blanket Implementations

Gets the TypeId of self. Read more

Casts the value.

Immutably borrows from an owned value. Read more

Mutably borrows from an owned value. Read more

Casts the value.

Converts self into T using Into<T>. Read more

Converts self into a target type. Read more

Causes self to use its Binary implementation when Debug-formatted.

Causes self to use its Display implementation when Debug-formatted. Read more

Causes self to use its LowerExp implementation when Debug-formatted. Read more

Causes self to use its LowerHex implementation when Debug-formatted. Read more

Causes self to use its Octal implementation when Debug-formatted.

Causes self to use its Pointer implementation when Debug-formatted. Read more

Causes self to use its UpperExp implementation when Debug-formatted. Read more

Causes self to use its UpperHex implementation when Debug-formatted. Read more

Performs the conversion.

Performs the conversion.

Casts the value.

Pipes by value. This is generally the method you want to use. Read more

Borrows self and passes that borrow into the pipe function. Read more

Mutably borrows self and passes that borrow into the pipe function. Read more

Borrows self, then passes self.borrow() into the pipe function. Read more

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

Borrows self, then passes self.as_ref() into the pipe function.

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

Borrows self, then passes self.deref() into the pipe function.

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

Casts the value.

Immutable access to the Borrow<B> of a value. Read more

Mutable access to the BorrowMut<B> of a value. Read more

Immutable access to the AsRef<R> view of a value. Read more

Mutable access to the AsMut<R> view of a value. Read more

Immutable access to the Deref::Target of a value. Read more

Mutable access to the Deref::Target of a value. Read more

Calls .tap() only in debug builds, and is erased in release builds.

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

Provides immutable access for inspection. Read more

Calls tap in debug builds, and does nothing in release builds.

Provides mutable access for modification. Read more

Calls tap_mut in debug builds, and does nothing in release builds.

Calls tap_ref in debug builds, and does nothing in release builds.

Calls tap_ref_mut in debug builds, and does nothing in release builds.

Calls tap_borrow in debug builds, and does nothing in release builds.

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

Immutably dereferences self for inspection.

Calls tap_deref in debug builds, and does nothing in release builds.

Mutably dereferences self for modification.

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

The resulting type after obtaining ownership.

Creates owned data from borrowed data, usually by cloning. Read more

🔬 This is a nightly-only experimental API. (toowned_clone_into)

Uses borrowed data to replace owned data, usually by cloning. Read more

Converts the given value to a String. Read more

Attempts to convert self into T using TryInto<T>. Read more

Attempts to convert self into a target type. Read more

The type returned in the event of a conversion error.

Performs the conversion.

The type returned in the event of a conversion error.

Performs the conversion.

Casts the value.

Casts the value.