pub trait Formula<const N: usize>:
Clone
+ Send
+ Sync
+ 'static {
const BOOLEAN: bool = false;
const FAILS_NAN: bool = false;
const HAS_EXACT: bool = false;
const INTEGER_FORMULA: bool = false;
const MAP_ONLY: bool = false;
const REAL_COMPLEX: bool = false;
Show 29 methods
// Provided methods
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 exact(
&self,
_args: [&Ratio<BigInt>; N],
) -> Result<Option<Ratio<BigInt>>, Error> { ... }
fn range(&self, _args: [Range; N]) -> Range { ... }
fn domain(&self, _dtype: DType, _args: [Range; N]) -> Option<[Range; N]> { ... }
fn identity(&self) -> [Option<f64>; N] { ... }
fn fold(&self) -> Option<Reduce> { ... }
fn inverse_fold(&self) -> Option<Reduce> { ... }
fn truth_table(&self) -> Option<u8> { ... }
fn truth(&self) -> Option<Reduce> { ... }
fn same(&self, _arg: Range) -> Option<Range> { ... }
fn reads(&self) -> Reads { ... }
fn supports(&self, _dtype: DType) -> bool { ... }
fn emit<F, O>(
&self,
_o: &O,
_x: [<O as Ops<F>>::V; N],
) -> Option<<O as Ops<F>>::V>
where F: Float,
O: Ops<F> + ?Sized { ... }
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 { ... }
fn bands(&self) -> Option<(Tolerance, Band, Band)> { ... }
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 { ... }
fn complex<F>(
&self,
_ops: &NativeOps<rustymath_core::::facts::Formula::complex::{constant#0}>,
_x: [Complex<F>; N],
) -> Option<Complex<F>>
where F: Native { ... }
fn real_complex<F>(
&self,
_ops: &NativeOps<rustymath_core::::facts::Formula::real_complex::{constant#0}>,
_x: [F; N],
) -> Option<Complex<F>>
where F: Native { ... }
fn native_slices(&self) -> Option<NativeSlices<Self, N>> { ... }
fn emit_partials<F, O>(
&self,
_o: &O,
_x: [<O as Ops<F>>::V; N],
_result: <O as Ops<F>>::V,
_needed: [bool; N],
) -> [Option<<O as Ops<F>>::V>; N]
where F: Float,
O: Ops<F> + ?Sized { ... }
}Expand description
Each object’s range, domain, fold facts and executable formulae.
Provided Associated Constants§
const BOOLEAN: bool = false
Sourceconst FAILS_NAN: 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.
Sourceconst INTEGER_FORMULA: bool = false
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.
Sourceconst MAP_ONLY: bool = 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.
Sourceconst REAL_COMPLEX: bool = false
const REAL_COMPLEX: bool = false
Whether real_complex gives this formula’s complex results from real arguments.
Provided Methods§
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 exact( &self, _args: [&Ratio<BigInt>; N], ) -> Result<Option<Ratio<BigInt>>, Error>
fn range(&self, _args: [Range; N]) -> Range
Sourcefn domain(&self, _dtype: DType, _args: [Range; N]) -> Option<[Range; N]>
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 identity(&self) -> [Option<f64>; N]
fn fold(&self) -> Option<Reduce>
fn inverse_fold(&self) -> Option<Reduce>
Sourcefn truth_table(&self) -> Option<u8>
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>
Sourcefn same(&self, _arg: Range) -> Option<Range>
fn same(&self, _arg: Range) -> Option<Range>
Refines the real result interval when both operands denote the same value.
fn reads(&self) -> Reads
fn supports(&self, _dtype: DType) -> bool
fn emit<F, O>( &self, _o: &O, _x: [<O as Ops<F>>::V; N], ) -> Option<<O as Ops<F>>::V>
fn emit_test<F, O>( &self, _o: &O, _x: [<O as Ops<F>>::V; N], ) -> Option<<O as Ops<F>>::B>
Sourcefn emit_against<F, O>(
&self,
_o: &O,
_c: F,
_v: <O as Ops<F>>::V,
_left: bool,
) -> Option<<O as Ops<F>>::B>
fn emit_against<F, O>( &self, _o: &O, _c: F, _v: <O as Ops<F>>::V, _left: bool, ) -> Option<<O as Ops<F>>::B>
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.
Sourcefn bands(&self) -> Option<(Tolerance, Band, Band)>
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>
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)>
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,
fn complex<F>(
&self,
_ops: &NativeOps<rustymath_core::::facts::Formula::complex::{constant#0}>,
_x: [Complex<F>; N],
) -> Option<Complex<F>>where
F: Native,
Sourcefn real_complex<F>(
&self,
_ops: &NativeOps<rustymath_core::::facts::Formula::real_complex::{constant#0}>,
_x: [F; N],
) -> Option<Complex<F>>where
F: Native,
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.
fn native_slices(&self) -> Option<NativeSlices<Self, N>>
fn emit_partials<F, O>( &self, _o: &O, _x: [<O as Ops<F>>::V; N], _result: <O as Ops<F>>::V, _needed: [bool; N], ) -> [Option<<O as Ops<F>>::V>; N]
Dyn Compatibility§
This trait is not dyn compatible.
In older versions of Rust, dyn compatibility was called "object safety".
Implementors§
impl Formula<1> for Angle
impl Formula<1> for Asinh
impl Formula<1> for Atan
impl Formula<1> for BetaincAt
Source§impl Formula<1> for Bitwise
A bitwise function’s facts, which its table decides: the tables that fold (and, or, xor, xnor) for numbers, and the same tables’ reductions for Booleans.
impl Formula<1> for Bitwise
A bitwise function’s facts, which its table decides: the tables that fold (and, or, xor, xnor) for numbers, and the same tables’ reductions for Booleans.