Struct RangeOps 

pub struct RangeOps(pub DType);

Conservative range interpretation of the shared predicates.

Tuple Fields

0: DType

Trait Implementations

impl<F: Float> Ops<F> for RangeOps

fn overflow(&self, op: Binary, x: Self::V, y: Self::V) -> Self::B

No overflow (Some(false)) where the operation’s range, as its formula’s facts give it, lies within the computing dtype’s values. Past 2⁵³ a bound and the result’s ends round, so a result stays strictly inside such a bound.

type V = Range

A value.

type B = Option<bool>

A truth value.

type I = Range

Integer bits at the resolved working width.

type W = Range

A binary64 temporary for short mixed-width reductions.

fn width(&self) -> FloatWidth

fn fused(&self) -> bool

fn integral(&self) -> bool

Whether values are integers, as a compiler’s values at an integer type are. A recipe for an integer object asks before taking an integer-only step (Binary::BitAnd). Floats never are.

fn widen(&self, _: Self::V) -> Self::W

fn wide_number(&self, x: f64) -> Self::W

fn wide_multiply_add(&self, _: Self::W, _: Self::W, _: Self::W) -> Self::W

fn narrow(&self, _: Self::W) -> Self::V

fn integer(&self, x: i64) -> Self::I

fn integer_op(&self, _: Integer, _: Self::I, _: Self::I) -> Self::I

fn integer_compare(&self, op: Cmp, x: Self::I, y: Self::I) -> Self::B

fn integer_select(&self, test: Self::B, x: Self::I, y: Self::I) -> Self::I

fn to_integer(&self, _: Self::V) -> Self::I

fn from_integer(&self, _: Self::I) -> Self::V

fn to_bits(&self, _: Self::V) -> Self::I

fn from_bits(&self, _: Self::I) -> Self::V

fn number(&self, x: F) -> Self::V

The number x.

fn constant(&self, x: Self::V) -> Option<F>

v where it’s one number that every item shares, known before any item is read, such as the 3 of x^3. A recipe can pick a cheaper formula by it. None where v varies by item.

fn unary(&self, op: Unary, x: Self::V) -> Self::V

fn binary(&self, _: Binary, _: Self::V, _: Self::V) -> Self::V

fn compare(&self, op: Cmp, x: Self::V, y: Self::V) -> Self::B

fn multiply_add(&self, _: Self::V, _: Self::V, _: Self::V) -> Self::V

x·y + z, rounded once where the target fuses multiply-add (FUSED), as rustymath’s mla gives it.

fn and(&self, x: Self::B, y: Self::B) -> Self::B

fn or(&self, x: Self::B, y: Self::B) -> Self::B

fn not(&self, x: Self::B) -> Self::B

fn select(&self, test: Self::B, x: Self::V, y: Self::V) -> Self::V

x where m holds, otherwise y. ∂’s recorder runs a recipe on whole values, where m and each array case must have one layout: build them from the same arguments.

fn one_where(&self, m: Self::B) -> Self::V

1 where m holds, otherwise 0.

fn tolerance(&self, fallback: F) -> Self::V

Captured tolerance; recording backends return its runtime setting slot.

fn sign(&self, x: Self::V) -> Self::V

The sign of x, as sign gives it.

fn reciprocal(&self, x: Self::V) -> Self::V

1 ÷ x, as reciprocal gives it.

fn power(&self, k: F, x: Self::V) -> Self::V

x raised to k, a constant that Exponent::of routes off the general route, as power gives it.

fn real_power(&self, x: Self::V, y: Self::V) -> Self::V

The real part of x^y through the existing power formula.

fn power_slope( &self, x: Self::V, y: Self::V, r: Self::V, halves: bool, ) -> Self::V

The partial in x of x^y = r; halves permits constant half-integer powers.

fn negate(&self, x: Self::V) -> Self::V

fn magnitude(&self, x: Self::V) -> Self::V

fn sqrt(&self, x: Self::V) -> Self::V

fn floor(&self, x: Self::V) -> Self::V

fn ln(&self, x: Self::V) -> Self::V

fn sin(&self, x: Self::V) -> Self::V

fn cos(&self, x: Self::V) -> Self::V

fn sinh(&self, x: Self::V) -> Self::V

fn cosh(&self, x: Self::V) -> Self::V

fn sqrt1mx2(&self, x: Self::V) -> Self::V

fn sqrt1px2(&self, x: Self::V) -> Self::V

fn digamma(&self, x: Self::V) -> Self::V

fn exp(&self, x: Self::V) -> Self::V

fn lgamma(&self, x: Self::V) -> Self::V

fn complement(&self, x: Self::V) -> Self::V

fn add(&self, x: Self::V, y: Self::V) -> Self::V

fn subtract(&self, x: Self::V, y: Self::V) -> Self::V

fn multiply(&self, x: Self::V, y: Self::V) -> Self::V

fn divide(&self, x: Self::V, y: Self::V) -> Self::V

fn larger(&self, x: Self::V, y: Self::V) -> Self::V

fn smaller(&self, x: Self::V, y: Self::V) -> Self::V

fn binom(&self, x: Self::V, y: Self::V) -> Self::V

fn binom_dn(&self, x: Self::V, y: Self::V) -> Self::V

fn binom_dk(&self, x: Self::V, y: Self::V) -> Self::V

fn polygamma(&self, x: Self::V, y: Self::V) -> Self::V

fn bit_and(&self, x: Self::V, y: Self::V) -> Self::V

fn less(&self, x: Self::V, y: Self::V) -> Self::B

fn less_equal(&self, x: Self::V, y: Self::V) -> Self::B

fn equal(&self, x: Self::V, y: Self::V) -> Self::B