Struct Tol 

pub struct Tol {
    pub ct: f64,
    pub by_smaller: bool,
}

How close two floats have to be to count as equal.

Both languages compare reals with a relative tolerance: J’s 9!:18 comparison tolerance, APL’s ⎕CT. Two values are equal when they differ by less than the tolerance scaled by one of their magnitudes — the smaller one in J, the larger one in APL. Both references answer strictly: a difference exactly at the threshold is not equal. Integers, characters and boxes are unaffected, and an exact bit-for-bit equality (the infinities included) is equality whatever the tolerance is.

Fields

ct: f64

Relative tolerance; zero compares exactly.

by_smaller: bool

Scale by the smaller magnitude (J) rather than the larger (APL).

Implementations

impl Tol

pub const EXACT: Tol

No tolerance at all — J’s u!.0.

pub const J: Tol

J’s default comparison tolerance, 2^-44.

pub const APL: Tol

GNU APL’s default ⎕CT.

pub fn eq(self, a: f64, b: f64) -> bool

Tolerant equality.

pub fn is_j(self) -> bool

Whose rule this is. A scalar verb is handed the tolerance and nothing else about the dialect, and two rules below need to know which one they are under: J reads a magnitude below the tolerance as zero, and J’s equality is total across the box boundary where APL’s reaches inside the box instead.

pub fn is_zero(self, y: f64) -> bool

Whether the tolerance reads this magnitude as zero.

J’s signum does: * 1e_15 is 0 and * 6e_14 is 1, the threshold being the tolerance itself. APL’s × is exact there. With !.0 the tolerance is zero, so the rule falls away with it.

pub fn lt(self, a: f64, b: f64) -> bool

Tolerant <: less, and not tolerantly equal.

pub fn le(self, a: f64, b: f64) -> bool

Tolerant <=: less, or tolerantly equal.

pub fn eq_cx(self, a: Cx, b: Cx) -> bool

Tolerant equality on complex values: the magnitude of the difference against the same scale the real comparison uses. J answers 3j4 = 3.0000000000001j4 with 1, which is this rule on magnitudes.

pub fn floor(self, y: f64) -> f64

<. y: the largest integer not above y, with a value just under an integer counting as that integer.

pub fn ceil(self, y: f64) -> f64

>. y: the ceiling, with a value just over an integer counting as that integer.

Trait Implementations

impl Clone for Tol

fn clone(&self) -> Tol

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Tol

impl Debug for Tol

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

Formats the value using the given formatter.

impl PartialEq for Tol

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Tol