Struct MathishDivide 

pub struct MathishDivide;

Division with zero divided by zero defined as zero.

Trait Implementations

impl Clone for MathishDivide

fn clone(&self) -> MathishDivide

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for MathishDivide

impl Debug for MathishDivide

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

Formats the value using the given formatter.

impl Formula<2> for MathishDivide

const HAS_EXACT: bool = true

Whether exact computes this formula on rationals.

fn exact(&self, _: [&Ratio<BigInt>; 2]) -> Result<Option<Ratio<BigInt>>, Error>

fn range(&self, _: [Range; 2]) -> Range

fn identity(&self) -> [Option<f64>; 2]

fn inverse_fold(&self) -> Option<Reduce>

fn supports(&self, dtype: DType) -> bool

fn emit<F, O>( &self, o: &O, _: [<O as Ops<F>>::V; 2], ) -> Option<<O as Ops<F>>::V>

where F: Float, O: Ops<F> + ?Sized,

fn emit_partials<F, O>( &self, o: &O, _: [<O as Ops<F>>::V; 2], r: <O as Ops<F>>::V, _: [bool; 2], ) -> [Option<<O as Ops<F>>::V>; 2]

where F: Float, O: Ops<F> + ?Sized,

fn complex<F>( &self, _: &NativeOps<rustymath_core::::facts::{impl#106}::complex::{constant#0}>, _: [Complex<F>; 2], ) -> Option<Complex<F>>

where F: Native,

fn native_slices(&self) -> Option<NativeSlices<MathishDivide, 2>>

const BOOLEAN: bool = false

const FAILS_NAN: bool = false

Whether a NaN result from arguments that aren’t NaN is a Domain error, which the default emit_valid checks (nan_valid). A constant, so a checked loop over items reads it at compile time and never calls a method for it.

const INTEGER_FORMULA: bool = false

Whether integer runs this formula’s emit on integers, so that range arithmetic over emit_valid bounds an integer kernel’s failures (may_raise). A row with a native_integer body supports integers and leaves this false.

const MAP_ONLY: bool = false

Whether kernels of this formula only map. Modified writes, folds, scans and walks of adjacent items build no code for it: each refuses it at compile time, as it refuses a formula of another arity. A derivative’s slope (derivative::Slope) only maps.

fn result_dtype(&self, input: DType) -> DType

fn computing_dtype(&self, input: DType) -> Option<DType>

fn character_rule(&self) -> Option<Rule>

fn ordered_kinds(&self, _: [i32; 2]) -> Option<i32>

fn character_policy(&self, types: [DType; 2]) -> Result<Option<Policy>, Error>

fn domain(&self, _dtype: DType, _args: [Range; N]) -> Option<[Range; N]>

A box at the computing dtype containing args on which graph-numeric results do not raise a data error.

fn fold(&self) -> Option<Reduce>

fn truth_table(&self) -> Option<u8>

The function’s results on Booleans, as bits: bit 2x+y for two arguments, bit x for one. A Boolean kernel computes by it (operation::map_truth).

fn truth(&self) -> Option<Reduce>

fn same(&self, _arg: Range) -> Option<Range>

Refines the real result interval when both operands denote the same value.

fn reads(&self) -> Reads

fn emit_test<F, O>( &self, _o: &O, _x: [<O as Ops<F>>::V; N], ) -> Option<<O as Ops<F>>::B>

where F: Float, O: Ops<F> + ?Sized,

fn emit_against<F, O>( &self, _o: &O, _c: F, _v: <O as Ops<F>>::V, _left: bool, ) -> Option<<O as Ops<F>>::B>

where F: Float, O: Ops<F> + ?Sized,

This comparison of v with the one number c through o, where that has a cheaper recipe than comparing item by item, as a held constant has. left says whether v is the left argument. None for other formulas.

fn bands(&self) -> Option<(Tolerance, Band, Band)>

This comparison’s tolerance, and the bands that an item on the left and on the right of one number must lie in (tolerant::Banding), through which it compares many items with one number (tolerant::against). None for other formulas.

fn emit_repair<F, O>( &self, _o: &O, _x: [<O as Ops<F>>::V; N], ) -> Option<<O as Ops<F>>::B>

where F: Float, O: Ops<F> + ?Sized,

fn repair_routine(&self) -> Option<Repair>

fn emit_valid<F, O>( &self, _variant: Variant, o: &O, x: [<O as Ops<F>>::V; N], result: <O as Ops<F>>::V, ) -> Option<(Kind, <O as Ops<F>>::B)>

where F: Float, O: Ops<F> + ?Sized,

fn real<F>( &self, ops: &NativeOps<rustymath_core::::facts::Formula::real::{constant#0}>, x: [F; N], ) -> Option<F>

where F: Native,

fn integer<I>(&self, _ops: &IntegerOps<I>, _x: [I; N]) -> Option<I>

where I: Overflowing,

const REAL_COMPLEX: bool = false

Whether real_complex gives this formula’s complex results from real arguments.

fn real_complex<F>( &self, _ops: &NativeOps<rustymath_core::::facts::Formula::real_complex::{constant#0}>, _x: [F; N], ) -> Option<Complex<F>>

where F: Native,

The complex result from real arguments, where that costs less than from the arguments as complex numbers. None sends the item to complex.