Struct fj_kernel::algorithms::approx::tolerance::Tolerance

pub struct Tolerance(_);

A tolerance value

A tolerance value is used during approximation. It defines the maximum allowed deviation of the approximation from the actual shape.

The Tolerance type enforces that the tolerance value is always larger than zero, which is an attribute that the approximation code relies on.

Failing From/Into implementation

The From/Into implementations of tolerance are fallible, which goes against the explicit mandate of those traits, as stated in their documentation.

A fallible Into provides a lot of convenience in test code. Since said documentation doesn’t provide any actual reasoning for this requirement, I’m feeling free to just ignore it.

Implementations

impl Tolerance

pub fn from_scalar(scalar: impl Into<Scalar>) -> Result<Self, InvalidTolerance>

Construct a Tolerance from a Scalar

Returns an error, if the passed scalar is not larger than zero.

Examples found in repository

src/algorithms/approx/tolerance.rs (line 54)

    fn from(scalar: S) -> Self {
        Self::from_scalar(scalar)
            .expect("Tried to create `Tolerance` from invalid value")
    }

pub fn inner(&self) -> Scalar

Return the Scalar that defines the tolerance

Examples found in repository

src/algorithms/approx/path.rs (line 131)

    pub fn for_circle<const D: usize>(
        circle: &Circle<D>,
        tolerance: impl Into<Tolerance>,
    ) -> Self {
        let radius = circle.a().magnitude();

        let num_vertices_to_approx_full_circle = Scalar::max(
            Scalar::PI
                / (Scalar::ONE - (tolerance.into().inner() / radius)).acos(),
            3.,
        )
        .ceil();

        let increment = Scalar::TAU / num_vertices_to_approx_full_circle;

        Self { increment }
    }

Trait Implementations

impl Clone for Tolerance

fn clone(&self) -> Tolerance

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Tolerance

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

Formats the value using the given formatter.

impl<S> From<S> for Tolerancewhere
    S: Into<Scalar>,

fn from(scalar: S) -> Self

Converts to this type from the input type.

impl Hash for Tolerance

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where
    H: Hasher,
    Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for Tolerance

fn cmp(&self, other: &Tolerance) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Selfwhere
    Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Selfwhere
    Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere
    Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval.

impl PartialEq<Tolerance> for Tolerance

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd<Tolerance> for Tolerance

fn partial_cmp(&self, other: &Tolerance) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Copy for Tolerance

impl Eq for Tolerance

impl StructuralEq for Tolerance

impl StructuralPartialEq for Tolerance