Struct Gcd 

pub struct Gcd(pub Tolerance);

Tolerant::gcd, or TolerantComplex::complex_gcd for complex items, at the tolerance it holds, as a function object. A non-finite argument gives NaN, which marks the item failed. Its i64 form is integer::gcd.

Tuple Fields

0: Tolerance

Trait Implementations

impl Binary<Complex<f32>> for Gcd

fn one(&self, x: Complex<f32>, y: Complex<f32>) -> Complex<f32>

fn judged(&self, x: Complex<f32>, y: Complex<f32>) -> (Complex<f32>, bool)

fn slice( &self, [x, y]: [Arg<'_, Complex<f32>>; 2], n: usize, out: &mut [MaybeUninit<Complex<f32>>], ) -> bool

fn checked(&self, x: T, y: T) -> Option<Self::Out>

fn many( &self, x: Arg<'_, T>, y: Arg<'_, T>, n: usize, out: &mut Vec<Self::Out>, ) -> bool

where T: Copy + Sync,

fn many_into( &self, x: Arg<'_, T>, y: Arg<'_, T>, n: usize, out: &mut Slots<'_, Self::Out>, ) -> bool

where T: Copy,

impl Binary<Complex<f64>> for Gcd

fn one(&self, x: Complex<f64>, y: Complex<f64>) -> Complex<f64>

fn judged(&self, x: Complex<f64>, y: Complex<f64>) -> (Complex<f64>, bool)

fn slice( &self, [x, y]: [Arg<'_, Complex<f64>>; 2], n: usize, out: &mut [MaybeUninit<Complex<f64>>], ) -> bool

fn checked(&self, x: T, y: T) -> Option<Self::Out>

fn many( &self, x: Arg<'_, T>, y: Arg<'_, T>, n: usize, out: &mut Vec<Self::Out>, ) -> bool

where T: Copy + Sync,

fn many_into( &self, x: Arg<'_, T>, y: Arg<'_, T>, n: usize, out: &mut Slots<'_, Self::Out>, ) -> bool

where T: Copy,

impl Binary<bool> for Gcd

fn one(&self, x: bool, y: bool) -> bool

fn judged(&self, x: bool, y: bool) -> (bool, bool)

fn slice( &self, args: [Arg<'_, bool>; 2], n: usize, out: &mut [MaybeUninit<bool>], ) -> bool

fn checked(&self, x: T, y: T) -> Option<Self::Out>

fn many( &self, x: Arg<'_, T>, y: Arg<'_, T>, n: usize, out: &mut Vec<Self::Out>, ) -> bool

where T: Copy + Sync,

fn many_into( &self, x: Arg<'_, T>, y: Arg<'_, T>, n: usize, out: &mut Slots<'_, Self::Out>, ) -> bool

where T: Copy,

impl Binary<f16> for Gcd

fn one(&self, x: f16, y: f16) -> f16

fn judged(&self, x: f16, y: f16) -> (f16, bool)

fn slice( &self, x: [Arg<'_, f16>; 2], n: usize, out: &mut [MaybeUninit<f16>], ) -> bool

fn checked(&self, x: T, y: T) -> Option<Self::Out>

fn many( &self, x: Arg<'_, T>, y: Arg<'_, T>, n: usize, out: &mut Vec<Self::Out>, ) -> bool

where T: Copy + Sync,

fn many_into( &self, x: Arg<'_, T>, y: Arg<'_, T>, n: usize, out: &mut Slots<'_, Self::Out>, ) -> bool

where T: Copy,

impl Binary<f32> for Gcd

fn one(&self, x: f32, y: f32) -> f32

fn judged(&self, x: f32, y: f32) -> (f32, bool)

fn slice( &self, [x, y]: [Arg<'_, f32>; 2], n: usize, out: &mut [MaybeUninit<f32>], ) -> bool

fn checked(&self, x: T, y: T) -> Option<Self::Out>

fn many( &self, x: Arg<'_, T>, y: Arg<'_, T>, n: usize, out: &mut Vec<Self::Out>, ) -> bool

where T: Copy + Sync,

fn many_into( &self, x: Arg<'_, T>, y: Arg<'_, T>, n: usize, out: &mut Slots<'_, Self::Out>, ) -> bool

where T: Copy,

impl Binary<f64> for Gcd

fn one(&self, x: f64, y: f64) -> f64

fn judged(&self, x: f64, y: f64) -> (f64, bool)

fn slice( &self, [x, y]: [Arg<'_, f64>; 2], n: usize, out: &mut [MaybeUninit<f64>], ) -> bool

fn checked(&self, x: T, y: T) -> Option<Self::Out>

fn many( &self, x: Arg<'_, T>, y: Arg<'_, T>, n: usize, out: &mut Vec<Self::Out>, ) -> bool

where T: Copy + Sync,

fn many_into( &self, x: Arg<'_, T>, y: Arg<'_, T>, n: usize, out: &mut Slots<'_, Self::Out>, ) -> bool

where T: Copy,

impl Binary<i16> for Gcd

fn one(&self, x: i16, y: i16) -> i16

fn judged(&self, x: i16, y: i16) -> (i16, bool)

fn slice( &self, args: [Arg<'_, i16>; 2], n: usize, out: &mut [MaybeUninit<i16>], ) -> bool

fn checked(&self, x: T, y: T) -> Option<Self::Out>

fn many( &self, x: Arg<'_, T>, y: Arg<'_, T>, n: usize, out: &mut Vec<Self::Out>, ) -> bool

where T: Copy + Sync,

fn many_into( &self, x: Arg<'_, T>, y: Arg<'_, T>, n: usize, out: &mut Slots<'_, Self::Out>, ) -> bool

where T: Copy,

impl Binary<i32> for Gcd

fn one(&self, x: i32, y: i32) -> i32

fn judged(&self, x: i32, y: i32) -> (i32, bool)

fn slice( &self, args: [Arg<'_, i32>; 2], n: usize, out: &mut [MaybeUninit<i32>], ) -> bool

fn checked(&self, x: T, y: T) -> Option<Self::Out>

fn many( &self, x: Arg<'_, T>, y: Arg<'_, T>, n: usize, out: &mut Vec<Self::Out>, ) -> bool

where T: Copy + Sync,

fn many_into( &self, x: Arg<'_, T>, y: Arg<'_, T>, n: usize, out: &mut Slots<'_, Self::Out>, ) -> bool

where T: Copy,

impl Binary<i64> for Gcd

fn one(&self, x: i64, y: i64) -> i64

fn judged(&self, x: i64, y: i64) -> (i64, bool)

fn slice( &self, args: [Arg<'_, i64>; 2], n: usize, out: &mut [MaybeUninit<i64>], ) -> bool

fn checked(&self, x: T, y: T) -> Option<Self::Out>

fn many( &self, x: Arg<'_, T>, y: Arg<'_, T>, n: usize, out: &mut Vec<Self::Out>, ) -> bool

where T: Copy + Sync,

fn many_into( &self, x: Arg<'_, T>, y: Arg<'_, T>, n: usize, out: &mut Slots<'_, Self::Out>, ) -> bool

where T: Copy,

impl Binary<u8> for Gcd

fn one(&self, x: u8, y: u8) -> u8

fn judged(&self, x: u8, y: u8) -> (u8, bool)

fn slice( &self, args: [Arg<'_, u8>; 2], n: usize, out: &mut [MaybeUninit<u8>], ) -> bool

fn checked(&self, x: T, y: T) -> Option<Self::Out>

fn many( &self, x: Arg<'_, T>, y: Arg<'_, T>, n: usize, out: &mut Vec<Self::Out>, ) -> bool

where T: Copy + Sync,

fn many_into( &self, x: Arg<'_, T>, y: Arg<'_, T>, n: usize, out: &mut Slots<'_, Self::Out>, ) -> bool

where T: Copy,

impl Clone for Gcd

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Gcd

impl Debug for Gcd

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

Formats the value using the given formatter.

impl Formula<2> for Gcd

const HAS_EXACT: bool = true

Whether exact computes this formula on rationals.

const FAILS_NAN: bool = true

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.

fn exact(&self, [x, y]: [&BigRational; 2]) -> Result<Option<BigRational>, Error>

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

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 supports(&self, dtype: DType) -> bool

fn integer<I: Overflowing>( &self, o: &IntegerOps<I>, [x, y]: [I; 2], ) -> Option<I>

fn complex<F: Native>( &self, o: &NativeOps<{ crate::FUSED }>, [x, y]: [Complex<F>; 2], ) -> Option<Complex<F>>

fn real<F: Native>( &self, o: &NativeOps<{ crate::FUSED }>, [x, y]: [F; 2], ) -> Option<F>

fn native_slices(&self) -> Option<NativeSlices<Self, $n>>

const BOOLEAN: 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.

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, [x, y]: [i32; 2]) -> Option<i32>

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

fn range(&self, _args: [Range; N]) -> Range

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 inverse_fold(&self) -> Option<Reduce>

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<F: Float, O: Ops<F> + ?Sized>( &self, _o: &O, _x: [O::V; N], ) -> Option<O::V>

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

fn emit_against<F: Float, O: Ops<F> + ?Sized>( &self, _o: &O, _c: F, _v: O::V, _left: bool, ) -> Option<O::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.

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: Float, O: Ops<F> + ?Sized>( &self, _o: &O, _x: [O::V; N], ) -> Option<O::B>

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

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

const REAL_COMPLEX: bool = false

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

fn real_complex<F: Native>( &self, _ops: &NativeOps<{ crate::FUSED }>, _x: [F; N], ) -> Option<Complex<F>>

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

fn emit_partials<F: Float, O: Ops<F> + ?Sized>( &self, _o: &O, _x: [O::V; N], _result: O::V, _needed: [bool; N], ) -> [Option<O::V>; N]

impl PartialEq for Gcd

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Results<Complex<f32>, 2> for Gcd

const TOTAL: bool

Whether no result fails: checked always gives Some, and many and many_into always give true. A total float function gives NaN from arguments that aren’t NaN only where NaN is its value, as Subtract gives for ∞ - ∞ and Sin for ±∞.

type Out = Complex<f32>

The type of each result.

impl Results<Complex<f64>, 2> for Gcd

const TOTAL: bool

Whether no result fails: checked always gives Some, and many and many_into always give true. A total float function gives NaN from arguments that aren’t NaN only where NaN is its value, as Subtract gives for ∞ - ∞ and Sin for ±∞.

type Out = Complex<f64>

The type of each result.

impl Results<bool, 2> for Gcd

const TOTAL: bool

Whether no result fails: checked always gives Some, and many and many_into always give true. A total float function gives NaN from arguments that aren’t NaN only where NaN is its value, as Subtract gives for ∞ - ∞ and Sin for ±∞.

type Out = bool

The type of each result.

impl Results<f16, 2> for Gcd

const TOTAL: bool

Whether no result fails: checked always gives Some, and many and many_into always give true. A total float function gives NaN from arguments that aren’t NaN only where NaN is its value, as Subtract gives for ∞ - ∞ and Sin for ±∞.

type Out = f16

The type of each result.

impl Results<f32, 2> for Gcd

const TOTAL: bool

Whether no result fails: checked always gives Some, and many and many_into always give true. A total float function gives NaN from arguments that aren’t NaN only where NaN is its value, as Subtract gives for ∞ - ∞ and Sin for ±∞.

type Out = f32

The type of each result.

impl Results<f64, 2> for Gcd

const TOTAL: bool

Whether no result fails: checked always gives Some, and many and many_into always give true. A total float function gives NaN from arguments that aren’t NaN only where NaN is its value, as Subtract gives for ∞ - ∞ and Sin for ±∞.

type Out = f64

The type of each result.

impl Results<i16, 2> for Gcd

const TOTAL: bool

Whether no result fails: checked always gives Some, and many and many_into always give true. A total float function gives NaN from arguments that aren’t NaN only where NaN is its value, as Subtract gives for ∞ - ∞ and Sin for ±∞.

type Out = i16

The type of each result.

impl Results<i32, 2> for Gcd

const TOTAL: bool

Whether no result fails: checked always gives Some, and many and many_into always give true. A total float function gives NaN from arguments that aren’t NaN only where NaN is its value, as Subtract gives for ∞ - ∞ and Sin for ±∞.

type Out = i32

The type of each result.

impl Results<i64, 2> for Gcd

const TOTAL: bool

Whether no result fails: checked always gives Some, and many and many_into always give true. A total float function gives NaN from arguments that aren’t NaN only where NaN is its value, as Subtract gives for ∞ - ∞ and Sin for ±∞.

type Out = i64

The type of each result.

impl Results<u8, 2> for Gcd

const TOTAL: bool

Whether no result fails: checked always gives Some, and many and many_into always give true. A total float function gives NaN from arguments that aren’t NaN only where NaN is its value, as Subtract gives for ∞ - ∞ and Sin for ±∞.

type Out = u8

The type of each result.

impl StructuralPartialEq for Gcd