Trait malachite_base::num::conversion::traits::ConvertibleFrom

source · [−]
pub trait ConvertibleFrom<T> {
    fn convertible_from(value: T) -> bool;
}
Expand description

Tests whether a value of one type is convertible into a value of another.

If ConvertibleFrom<T> for Self is implemented, it usually makes sense to implement CheckedFrom for T as well.

Required Methods

Implementations on Foreign Types

Checks whether a value is convertible to its own type. The result is always true.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value is convertible to its own type. The result is always true.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value is convertible to its own type. The result is always true.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value is convertible to its own type. The result is always true.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value is convertible to its own type. The result is always true.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value is convertible to its own type. The result is always true.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value is convertible to its own type. The result is always true.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value is convertible to its own type. The result is always true.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value is convertible to its own type. The result is always true.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value is convertible to its own type. The result is always true.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value is convertible to its own type. The result is always true.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value is convertible to its own type. The result is always true.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value is convertible to a different type. The result is always true.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value is convertible to a different type. The result is always true.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value is convertible to a different type. The result is always true.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value is convertible to a different type. The result is always true.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value is convertible to a different type. The result is always true.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value is convertible to a different type. The result is always true.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value is convertible to a different type. The result is always true.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value is convertible to a different type. The result is always true.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value is convertible to a different type. The result is always true.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value is convertible to a different type. The result is always true.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value is convertible to a different type. The result is always true.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value is convertible to a different type. The result is always true.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value is convertible to a different type. The result is always true.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value is convertible to a different type. The result is always true.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value is convertible to a different type. The result is always true.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value is convertible to a different type. The result is always true.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value is convertible to a different type. The result is always true.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value is convertible to a different type. The result is always true.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value is convertible to a different type. The result is always true.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value is convertible to a different type. The result is always true.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value is convertible to a different type. The result is always true.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value is convertible to a different type. The result is always true.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value is convertible to a different type. The result is always true.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value is convertible to a different type. The result is always true.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value is convertible to a different type. The result is always true.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value is convertible to a different type. The result is always true.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value is convertible to a different type. The result is always true.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value is convertible to a different type. The result is always true.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value is convertible to a different type. The result is always true.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value is convertible to a different type. The result is always true.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value is convertible to a different type. The result is always true.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value is convertible to a different type. The result is always true.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value is convertible to a different type. The result is always true.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value is convertible to a different type. The result is always true.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value is convertible to a different type. The result is always true.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Determines whether a value is convertible to a different type.

Let $W$ be the width of the target type.

If the target type is unsigned then, $$ f_W(n) = (0 \leq n < 2^W). $$

If the target type is signed then, $$ f_W(n) = (-2^{W-1} \leq n < 2^{W-1}-1). $$

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value of an unsigned type is convertible to a floating point type.

An exact conversion is possible if the unsigned value is not too large to represent (which can only happen when converting a u128 to an f32) and the precision of the unsigned value is not too high.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value of a floating point type is convertible to an unsigned type.

An exact conversion is possible if the floating point value is an integer, not negative (negative zero is ok), and not too large.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value of an unsigned type is convertible to a floating point type.

An exact conversion is possible if the unsigned value is not too large to represent (which can only happen when converting a u128 to an f32) and the precision of the unsigned value is not too high.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value of a floating point type is convertible to an unsigned type.

An exact conversion is possible if the floating point value is an integer, not negative (negative zero is ok), and not too large.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value of an unsigned type is convertible to a floating point type.

An exact conversion is possible if the unsigned value is not too large to represent (which can only happen when converting a u128 to an f32) and the precision of the unsigned value is not too high.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value of a floating point type is convertible to an unsigned type.

An exact conversion is possible if the floating point value is an integer, not negative (negative zero is ok), and not too large.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value of an unsigned type is convertible to a floating point type.

An exact conversion is possible if the unsigned value is not too large to represent (which can only happen when converting a u128 to an f32) and the precision of the unsigned value is not too high.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value of a floating point type is convertible to an unsigned type.

An exact conversion is possible if the floating point value is an integer, not negative (negative zero is ok), and not too large.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value of an unsigned type is convertible to a floating point type.

An exact conversion is possible if the unsigned value is not too large to represent (which can only happen when converting a u128 to an f32) and the precision of the unsigned value is not too high.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value of a floating point type is convertible to an unsigned type.

An exact conversion is possible if the floating point value is an integer, not negative (negative zero is ok), and not too large.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value of an unsigned type is convertible to a floating point type.

An exact conversion is possible if the unsigned value is not too large to represent (which can only happen when converting a u128 to an f32) and the precision of the unsigned value is not too high.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value of a floating point type is convertible to an unsigned type.

An exact conversion is possible if the floating point value is an integer, not negative (negative zero is ok), and not too large.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value of an unsigned type is convertible to a floating point type.

An exact conversion is possible if the unsigned value is not too large to represent (which can only happen when converting a u128 to an f32) and the precision of the unsigned value is not too high.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value of a floating point type is convertible to an unsigned type.

An exact conversion is possible if the floating point value is an integer, not negative (negative zero is ok), and not too large.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value of an unsigned type is convertible to a floating point type.

An exact conversion is possible if the unsigned value is not too large to represent (which can only happen when converting a u128 to an f32) and the precision of the unsigned value is not too high.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value of a floating point type is convertible to an unsigned type.

An exact conversion is possible if the floating point value is an integer, not negative (negative zero is ok), and not too large.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value of an unsigned type is convertible to a floating point type.

An exact conversion is possible if the unsigned value is not too large to represent (which can only happen when converting a u128 to an f32) and the precision of the unsigned value is not too high.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value of a floating point type is convertible to an unsigned type.

An exact conversion is possible if the floating point value is an integer, not negative (negative zero is ok), and not too large.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value of an unsigned type is convertible to a floating point type.

An exact conversion is possible if the unsigned value is not too large to represent (which can only happen when converting a u128 to an f32) and the precision of the unsigned value is not too high.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value of a floating point type is convertible to an unsigned type.

An exact conversion is possible if the floating point value is an integer, not negative (negative zero is ok), and not too large.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value of an unsigned type is convertible to a floating point type.

An exact conversion is possible if the unsigned value is not too large to represent (which can only happen when converting a u128 to an f32) and the precision of the unsigned value is not too high.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value of a floating point type is convertible to an unsigned type.

An exact conversion is possible if the floating point value is an integer, not negative (negative zero is ok), and not too large.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value of an unsigned type is convertible to a floating point type.

An exact conversion is possible if the unsigned value is not too large to represent (which can only happen when converting a u128 to an f32) and the precision of the unsigned value is not too high.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value of a floating point type is convertible to an unsigned type.

An exact conversion is possible if the floating point value is an integer, not negative (negative zero is ok), and not too large.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value of a signed type is convertible to a floating point type.

An exact conversion is possible if the precision of the signed value is not too high.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value of a floating point type is convertible to a signed type.

An exact conversion is possible if the floating point value is an integer and not too large or too small.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value of a signed type is convertible to a floating point type.

An exact conversion is possible if the precision of the signed value is not too high.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value of a floating point type is convertible to a signed type.

An exact conversion is possible if the floating point value is an integer and not too large or too small.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value of a signed type is convertible to a floating point type.

An exact conversion is possible if the precision of the signed value is not too high.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value of a floating point type is convertible to a signed type.

An exact conversion is possible if the floating point value is an integer and not too large or too small.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value of a signed type is convertible to a floating point type.

An exact conversion is possible if the precision of the signed value is not too high.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value of a floating point type is convertible to a signed type.

An exact conversion is possible if the floating point value is an integer and not too large or too small.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value of a signed type is convertible to a floating point type.

An exact conversion is possible if the precision of the signed value is not too high.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value of a floating point type is convertible to a signed type.

An exact conversion is possible if the floating point value is an integer and not too large or too small.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value of a signed type is convertible to a floating point type.

An exact conversion is possible if the precision of the signed value is not too high.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value of a floating point type is convertible to a signed type.

An exact conversion is possible if the floating point value is an integer and not too large or too small.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value of a signed type is convertible to a floating point type.

An exact conversion is possible if the precision of the signed value is not too high.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value of a floating point type is convertible to a signed type.

An exact conversion is possible if the floating point value is an integer and not too large or too small.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value of a signed type is convertible to a floating point type.

An exact conversion is possible if the precision of the signed value is not too high.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value of a floating point type is convertible to a signed type.

An exact conversion is possible if the floating point value is an integer and not too large or too small.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value of a signed type is convertible to a floating point type.

An exact conversion is possible if the precision of the signed value is not too high.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value of a floating point type is convertible to a signed type.

An exact conversion is possible if the floating point value is an integer and not too large or too small.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value of a signed type is convertible to a floating point type.

An exact conversion is possible if the precision of the signed value is not too high.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value of a floating point type is convertible to a signed type.

An exact conversion is possible if the floating point value is an integer and not too large or too small.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value of a signed type is convertible to a floating point type.

An exact conversion is possible if the precision of the signed value is not too high.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value of a floating point type is convertible to a signed type.

An exact conversion is possible if the floating point value is an integer and not too large or too small.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value of a signed type is convertible to a floating point type.

An exact conversion is possible if the precision of the signed value is not too high.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Checks whether a value of a floating point type is convertible to a signed type.

An exact conversion is possible if the floating point value is an integer and not too large or too small.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Implementors