Crate use_math 

use-math

Feature-gated RustUse facade for concrete geometry, checked counting, Catalan-family sequences, progression helpers, integer helpers, boolean algebra helpers, small set helpers, explicit trigonometry helpers, descriptive statistics helpers, compact linear algebra helpers, finite algebra law helpers, raw-number helpers, complex numbers, numerical calculus, probability, real-number primitives, and rational arithmetic.
One dependency when you want one import surface. Focused crates stay available when you want the narrowest build or an explicit direct crate for one math domain.

Surface · When to use it · Installation · Examples · Features · Constraints

use-math composes the focused RustUse math crates into one entry point while keeping their APIs direct and explicit. It re-exports the currently supported geometry, combinatorics, Catalan-family, progression, integer-helper, boolean-algebra, set-helper, trigonometry, descriptive statistics, compact linear algebra, finite algebra law, raw-number, complex-number, numerical-calculus, probability, real-number, and rational-number surfaces at the crate root, exposes nested modules for every focused crate in the workspace, and keeps the shared prelude limited to the items that already have concrete ergonomic value.

Root re-exports Call functions like factorial, catalan, arithmetic_sum, classify_number, gcd, identity_element, implication, is_ring, set_union, sin_deg, mean, solve_2x2, or types like Point2, IntegerSign, NumberCategory, Angle, LinearVector2, Matrix2, Complex, Differentiator, Probability, Real, and Rational directly from use_math.

Nested modules Use use_math::geometry, use_math::combinatorics, use_math::number, or use_math::algebra when you want crate-shaped namespacing.

Shared prelude Pull common items from use_math::prelude when fast onboarding matters more than fully qualified imports.

What this crate provides

Entry point	What it exposes	Best fit
Root re-exports	Direct access to enabled geometry, combinatorics, Catalan-family, progression, integer-helper, boolean-algebra, set-helper, trigonometry, descriptive statistics, compact linear algebra, finite algebra law, raw-number, complex-number, numerical-calculus, probability, real-number, and rational-number items	Call sites that want short imports
use_math::geometry	The use-geometry crate as a nested module	Code that prefers explicit geometry namespacing
use_math::combinatorics	The use-combinatorics crate as a nested module	Code that prefers explicit combinatorics namespacing
use_math::algebra	The use-algebra crate as a nested module	Code that prefers explicit algebra namespacing
use_math::prelude	Common items from enabled concrete features	Small apps, examples, and quick starts

If you need to…	Start here
Add one dependency and opt into math surfaces with features	use-math
Keep geometry-only code isolated	use-geometry directly
Keep counting-only code isolated	use-combinatorics directly
Keep Catalan-family sequence helpers isolated	use-catalan directly
Keep progression helpers isolated	use-series directly
Keep finite algebra law helpers isolated	use-algebra directly
Keep integer-helper code isolated	use-integer directly
Keep boolean algebra helpers isolated	use-logic directly
Keep set helpers isolated	use-set directly
Keep trigonometry helpers isolated	use-trigonometry directly
Keep descriptive statistics helpers isolated	use-statistics directly
Keep compact linear-algebra helpers isolated	use-linear directly
Keep raw-number helpers isolated	use-number directly
Keep complex-number primitives isolated	use-complex directly
Keep numerical-calculus helpers isolated	use-calculus directly
Keep explicit probability primitives isolated	use-probability directly
Keep finite-value and interval helpers isolated	use-real directly
Keep exact rational arithmetic isolated	use-rational directly
Minimize both dependency weight and API width	The focused crate directly

When to choose the facade

Use the facade when consumer ergonomics matter more than squeezing the dependency graph to the smallest possible shape.

Scenario	Choose use-math?	Why
You want one dependency for geometry, counting, Catalan-family sequences, progression helpers, integer helpers, boolean algebra helpers, set helpers, trigonometry helpers, descriptive statistics helpers, compact linear-algebra helpers, raw-number helpers, complex primitives, numerical calculus, probability, real-number helpers, and rational arithmetic	Yes	The facade keeps imports unified behind features
You are building a small app or example project	Yes	Root re-exports and the prelude reduce setup friction
You want namespace access to every focused crate	Usually yes	The facade exposes every focused crate name consistently today
You only need geometry	Usually no	use-geometry stays narrower and more explicit
You only need combinatorics	Usually no	use-combinatorics avoids unrelated modules
You only need Catalan-family sequence helpers	Usually no	use-catalan keeps that counting surface narrow and explicit
You only need progression helpers	Usually no	use-series keeps nth-term and partial-sum helpers narrow and explicit
You only need finite algebra law helpers	Usually no	use-algebra keeps closure-based structure checks explicit and local
You only need integer helpers	Usually no	use-integer keeps parity, divisibility, and gcd/lcm logic local
You only need boolean algebra helpers	Usually no	use-logic keeps named truth-table helpers explicit and local
You only need set helpers	Usually no	use-set keeps membership and set-operation intent explicit and local
You only need trigonometry helpers	Usually no	use-trigonometry keeps degree/radian handling and trig evaluation explicit and local
You only need descriptive statistics helpers	Usually no	use-statistics keeps mean, median, and variance summaries explicit and local
You only need compact linear-algebra helpers	Usually no	use-linear keeps small vectors, matrices, and singular solves explicit and local
You only need raw-number helpers	Usually no	use-number keeps plain f64 classification and shared constants explicit and local
You only need numerical calculus	Usually no	use-calculus keeps the approximation policy local and direct
You only need probability primitives	Usually no	use-probability keeps event assumptions local and direct
You only need finite-value or interval helpers	Usually no	use-real keeps floating-point validation and tolerance policy local
You only need exact rational arithmetic	Usually no	use-rational keeps exact fraction normalization and arithmetic local

[!TIP] The facade is intentionally thin. It is not a second abstraction layer over the focused crates.

Installation

Default features enable the current full surface:

[dependencies]
use-math = "0.0.1"

Geometry only:

[dependencies]
use-math = { version = "0.0.1", default-features = false, features = ["geometry"] }

Combinatorics only:

[dependencies]
use-math = { version = "0.0.1", default-features = false, features = ["combinatorics"] }

Quick examples

Checked counting from the root

use use_math::{combinations, factorial, permutations};

assert_eq!(factorial(5)?, 120);
assert_eq!(permutations(5, 3)?, 60);
assert_eq!(combinations(5, 2)?, 10);

Catalan-family counting from the root

use use_math::{catalan, fuss_catalan};

assert_eq!(catalan(4)?, 14);
assert_eq!(fuss_catalan(3, 3)?, 12);

Progression helpers from the root

use use_math::{arithmetic_nth_term, arithmetic_sum, geometric_nth_term, geometric_sum};

assert_eq!(arithmetic_nth_term(3, 2, 4)?, 11);
assert_eq!(arithmetic_sum(3, 2, 5)?, 35);
assert_eq!(geometric_nth_term(2, 3, 4)?, 162);
assert_eq!(geometric_sum(2, 3, 4)?, 80);

Boolean algebra helpers from the root

use use_math::{equivalence, exclusive_or, implication, majority, nand, nor};

assert!(implication(false, true));
assert!(equivalence(true, true));
assert!(exclusive_or(true, false));
assert!(!nand(true, true));
assert!(nor(false, false));
assert!(majority(true, true, false));

Set helpers from the root

use use_math::{
	are_disjoint, contains_member, is_subset, set_difference, set_intersection,
	set_symmetric_difference, set_union,
};

let left = [1, 2, 2, 3];
let right = [3, 4, 2, 5];

assert!(contains_member(&left, &1));
assert!(is_subset(&[2, 3], &right));
assert!(!are_disjoint(&left, &right));
assert_eq!(set_union(&left, &right), vec![1, 2, 3, 4, 5]);
assert_eq!(set_intersection(&left, &right), vec![2, 3]);
assert_eq!(set_difference(&left, &right), vec![1]);
assert_eq!(set_symmetric_difference(&left, &right), vec![1, 4, 5]);

Trigonometry helpers from the root

use use_math::{Angle, cos_deg, degrees_to_radians, normalize_degrees, radians_to_degrees, sin_deg, tan_deg};

let acute = Angle::from_degrees(30.0);
let wrapped = Angle::from_degrees(765.0).normalized();

assert!((acute.radians() - degrees_to_radians(30.0)).abs() < 1.0e-12);
assert!((acute.degrees() - radians_to_degrees(acute.radians())).abs() < 1.0e-12);
assert!((wrapped.degrees() - 45.0).abs() < 1.0e-12);
assert!((normalize_degrees(-90.0) - 270.0).abs() < 1.0e-12);
assert!((acute.sin() - 0.5).abs() < 1.0e-12);
assert!((cos_deg(60.0) - 0.5).abs() < 1.0e-12);
assert!((sin_deg(30.0) - 0.5).abs() < 1.0e-12);
assert!((tan_deg(45.0) - 1.0).abs() < 1.0e-12);

Descriptive statistics from the root

use use_math::{mean, median, population_std_dev, population_variance, sample_std_dev, sample_variance};

let values = [2.0, 4.0, 4.0, 4.0, 5.0, 5.0, 7.0, 9.0];
let sample = [1.0, 2.0, 3.0, 4.0];

assert!((mean(&values)? - 5.0).abs() < 1.0e-12);
assert!((median(&values)? - 4.5).abs() < 1.0e-12);
assert!((population_variance(&values)? - 4.0).abs() < 1.0e-12);
assert!((population_std_dev(&values)? - 2.0).abs() < 1.0e-12);
assert!((sample_variance(&sample)? - 1.666_666_666_666_666_7).abs() < 1.0e-12);
assert!((sample_std_dev(&sample)? - 1.290_994_448_735_805_6).abs() < 1.0e-12);

Linear algebra helpers from the root

use use_math::{LinearVector2, Matrix2, dot, solve_2x2};

let vector = LinearVector2::new(3.0, 4.0);
let other = LinearVector2::new(-2.0, 1.0);
let matrix = Matrix2::new(2.0, 1.0, 5.0, 3.0);

assert_eq!(vector + other, LinearVector2::new(1.0, 5.0));
assert!((dot(vector, other) + 2.0).abs() < 1.0e-12);
assert!((vector.magnitude() - 5.0).abs() < 1.0e-12);
assert_eq!(matrix.mul_vector(LinearVector2::new(1.0, -1.0)), LinearVector2::new(1.0, 2.0));
assert_eq!(solve_2x2(matrix, LinearVector2::new(1.0, 2.0))?, LinearVector2::new(1.0, -1.0));

Raw-number helpers from the root

use use_math::{
	GOLDEN_RATIO, NumberCategory, NumberSign, SQRT_3, classify_number,
	classify_number_sign, is_finite_number,
};

assert_eq!(classify_number(f64::NAN), NumberCategory::Nan);
assert_eq!(classify_number(f64::from_bits(1)), NumberCategory::Subnormal);
assert_eq!(classify_number_sign(-12.5), Some(NumberSign::Negative));
assert_eq!(classify_number_sign(f64::NAN), None);
assert!(is_finite_number(3.5));
assert!(!is_finite_number(f64::INFINITY));
assert!(((GOLDEN_RATIO * GOLDEN_RATIO) - (GOLDEN_RATIO + 1.0)).abs() < 1.0e-12);
assert!(((SQRT_3 * SQRT_3) - 3.0).abs() < 1.0e-12);

Finite algebra law helpers from the root

use use_math::{identity_element, is_abelian_group, is_distributive_over, is_ring};

let residues = [0_u8, 1, 2];
let add_mod_3 = |left, right| (left + right) % 3;
let mul_mod_3 = |left, right| (left * right) % 3;

assert_eq!(identity_element(&residues, add_mod_3), Some(0));
assert!(is_abelian_group(&residues, add_mod_3));
assert!(is_distributive_over(&residues, mul_mod_3, add_mod_3));
assert!(is_ring(&residues, add_mod_3, mul_mod_3));

Integer helpers from the root

use use_math::{IntegerSign, classify_sign, gcd, is_divisible_by, lcm};

assert_eq!(classify_sign(-12), IntegerSign::Negative);
assert!(is_divisible_by(84, 7)?);
assert_eq!(gcd(-54, 24), 6);
assert_eq!(lcm(-6, 15)?, 30);

Geometry from the root

use use_math::{Orientation2, Point2, Triangle, distance_2d, midpoint_2d, try_orientation_2d};

let a = Point2::try_new(0.0, 0.0)?;
let b = Point2::try_new(4.0, 0.0)?;
let c = Point2::try_new(0.0, 3.0)?;
let triangle = Triangle::try_new(a, b, c)?;

assert_eq!(distance_2d(a, b), 4.0);
assert_eq!(midpoint_2d(a, c), Point2::try_new(0.0, 1.5)?);
assert_eq!(try_orientation_2d(a, b, c)?, Orientation2::CounterClockwise);
assert_eq!(triangle.area(), 6.0);

Geometry extras behind the feature gate

use use_math::{Aabb2, Orientation2, Point2, orientation_2d_with_tolerance};

let a = Point2::try_new(0.0, 0.0)?;
let b = Point2::try_new(4.0, 0.0)?;
let c = Point2::try_new(0.0, 3.0)?;
let bounds = Aabb2::from_points(a, c);

assert!(bounds.contains_point(Point2::new(0.0, 1.5)));
assert_eq!(orientation_2d_with_tolerance(a, b, c, 0.0)?, Orientation2::CounterClockwise);

Numerical calculus from the root

use use_math::{Differentiator, IntegrationInterval, Integrator, LimitApproximator};

let differentiator = Differentiator::try_new(1.0e-5)?;
let interval = IntegrationInterval::try_new(0.0, 1.0)?;
let integrator = Integrator::try_new(128)?;
let limit = LimitApproximator::try_new(1.0e-6, 1.0e-5)?;

let slope = differentiator.derivative_at(|x| x.powi(2), 3.0)?;
let area = integrator.simpson(|x| x * x, interval)?;
let sinc_limit = limit.at(
	|x| {
		if x == 0.0 {
			1.0
		} else {
			x.sin() / x
		}
	},
	0.0,
)?;

assert!((slope - 6.0).abs() < 1.0e-6);
assert!((area - (1.0 / 3.0)).abs() < 1.0e-6);
assert!((sinc_limit - 1.0).abs() < 1.0e-5);

Probability from the root

use use_math::{Bernoulli, Probability, independent_intersection, independent_union};

let rain = Probability::from_fraction(1, 4)?;
let traffic = Probability::try_new(0.5)?;
let commute = Bernoulli::new(rain);

assert!((independent_intersection(rain, traffic).value() - 0.125).abs() < 1.0e-12);
assert!((independent_union(rain, traffic).value() - 0.625).abs() < 1.0e-12);
assert_eq!(commute.failure_probability(), Probability::try_new(0.75)?);

Real-number helpers from the root

use use_math::{Real, RealInterval, approx_eq};

let interval = RealInterval::try_new(-2.0, 6.0)?;
let midpoint = interval.midpoint();
let clamped = interval.clamp(Real::try_new(8.0)?);

assert_eq!(clamped, Real::try_new(6.0)?);
assert!(approx_eq(midpoint, Real::try_new(2.0)?, 1.0e-12)?);

Rational arithmetic from the root

use use_math::Rational;

let half = Rational::try_new(1, 2)?;
let third = Rational::try_new(1, 3)?;

assert_eq!(half.checked_add(third)?, Rational::try_new(5, 6)?);
assert_eq!(half.checked_div(third)?, Rational::try_new(3, 2)?);

Feature model

Feature	Enables	Default
geometry	Re-exports from use-geometry, including Aabb2 and tolerance-aware orientation helpers	No
combinatorics	Re-exports from use-combinatorics	No
catalan	Re-exports from use-catalan, including catalan, fuss_catalan, and CatalanError	No
algebra	Re-exports from use-algebra, including finite algebra-law helpers such as identity_element, is_abelian_group, and is_ring	No
series	Re-exports from use-series, including arithmetic and geometric progression helpers	No
integer	Re-exports from use-integer, including IntegerSign, divisibility helpers, and gcd/lcm	No
logic	Re-exports from use-logic, including implication, equivalence, XOR, NAND, NOR, and majority helpers	No
set	Re-exports from use-set, including membership predicates and order-preserving set operations	No
trigonometry	Re-exports from use-trigonometry, including Angle, degree/radian conversion helpers, normalization helpers, and sin_deg/cos_deg/tan_deg	No
statistics	Re-exports from use-statistics, including StatisticsError, mean/median, variance, and standard-deviation helpers	No
linear	Re-exports from use-linear, including LinearVector2, Matrix2, dot, solve_2x2, and LinearError	No
number	Re-exports from use-number, including floating-point classification helpers and shared numeric constants	No
complex	Re-exports from use-complex, including Complex and Imaginary	No
calculus	Re-exports from use-calculus, including Differentiator, Integrator, and limit helpers	No
probability	Re-exports from use-probability, including Probability, Bernoulli, and independent-event helpers	No
rational	Re-exports from use-rational, including Rational and RationalError	No
real	Re-exports from use-real, including Real, RealInterval, and approx_eq	No
full	Every focused crate feature in the workspace	Yes

[!NOTE] full is the default today because the facade exists to smooth over multi-crate integration. Disable defaults when you need tighter control over compile surface. Every focused crate feature now exposes both nested modules and concrete root-level re-exports.

Design constraints

• The facade stays close to the focused crates instead of inventing a separate object model.
• Small APIs are preferred over broad trait-heavy abstractions.
• Depend on the focused crates directly when the facade would be wider than you need.
• Facade-only wrapper types, macros, and a second abstraction layer are intentionally out of scope.

Status

use-math is a concrete pre-1.0 facade crate in the RustUse docs surface. The API remains intentionally thin while every focused crate in the workspace now exposes a concrete public surface. Utility-first facade for RustUse math crates.

Re-exports

pub use use_algebra as algebra;

pub use use_calculus as calculus;

pub use use_catalan as catalan;

pub use use_combinatorics as combinatorics;

pub use use_complex as complex;

pub use use_geometry as geometry;

pub use use_integer as integer;

pub use use_linear as linear;

pub use use_logic as logic;

pub use use_number as number;

pub use use_probability as probability;

pub use use_rational as rational;

pub use use_real as real;

pub use use_series as series;

pub use use_set as set;

pub use use_statistics as statistics;

pub use use_trigonometry as trigonometry;

Modules

prelude

Structs

Aabb2

An axis-aligned bounding box represented by inclusive minimum and maximum corners.

Angle

Explicit angle value stored in radians.

Bernoulli

A Bernoulli distribution with a single success probability.

Circle

A circle in 2D Euclidean space.

Complex

A complex number stored in rectangular form.

Differentiator

Finite-difference differentiation configuration.

Imaginary

A standalone imaginary value.

IntegrationInterval

A finite interval for definite integration.

Integrator

Numerical integration configuration.

LimitApproximator

Symmetric two-sided limit approximation settings.

Line2

An infinite 2D line represented by two sample points.

LinearVector2

A 2D column vector.

Matrix2

A 2×2 matrix stored in row-major order.

Point2

A 2D point represented with f64 coordinates.

Probability

A validated probability value in the closed interval [0, 1].

Rational

A normalized exact rational number.

Real

A validated finite f64 value.

RealInterval

A checked closed interval [min, max] over finite real values.

Segment2

A finite line segment between two 2D points.

Triangle

A constructed 2D triangle represented by three vertices.

Vector2

A 2D vector represented with f64 components.

Enums

CalculusError

Errors returned by numerical-calculus helpers.

CatalanError

Errors returned by checked Catalan-family helpers.

CombinatoricsError

Errors returned by checked combinatorics helpers.

GeometryError

Errors returned by validated geometry constructors.

IntegerError

Errors produced by integer helper operations.

IntegerSign

Sign classification for a signed integer value.

LinearError

Errors returned by linear helpers when a system cannot be solved.

NumberCategory

Broad categories for raw f64 values.

NumberSign

Sign classes for raw numeric values that are not NaN.

Orientation2

The winding order of three 2D points.

ProbabilityError

Errors returned by validated probability helpers.

RationalError

Errors returned by validated rational-number helpers.

RealError

Errors returned by validated real-number helpers.

SeriesError

Errors returned by checked progression helpers.

StatisticsError

Errors returned by statistics helpers when the input cannot support the requested summary.

Constants

GOLDEN_RATIO

The golden ratio as an f64.

GOLDEN_RATIO_F32

The golden ratio as an f32.

SQRT_3

The square root of three as an f64.

SQRT_3_F32

The square root of three as an f32.

Functions

aabb_from_points

Creates a bounding box from any two corners.

approx_eq

Compares two real values with an explicit non-negative tolerance.

are_coprime

Returns whether two integers share no positive common divisor other than one.

are_disjoint

Returns whether left and right share no common members.

arithmetic_nth_term

Returns the zero-based indexth term of an arithmetic progression.

arithmetic_sum

Returns the sum of the first terms values of an arithmetic progression.

catalan

Returns the nth Catalan number using checked u128 arithmetic.

central_difference

Approximates the first derivative with a central difference.

classify_number

Classifies a raw f64 by floating-point category.

classify_number_sign

Classifies the sign of a raw f64 while keeping NaN explicit.

classify_sign

Classifies a signed integer as negative, zero, or positive.

combinations

Returns the number of unordered selections of size k from n items.

contains_member

Returns whether value is a member of set.

cos_deg

Evaluates cos for a degrees input.

degrees_to_radians

Converts a degrees value into radians.

distance_2d

Returns the Euclidean distance between two 2D points.

distance_squared_2d

Returns the squared Euclidean distance between two 2D points.

dot

Returns the dot product of two vectors.

equivalence

Returns whether two boolean values are logically equivalent.

exclusive_or

Returns the exclusive-or of two boolean values.

factorial

Returns n! using checked u128 arithmetic.

fuss_catalan

Returns the nth Fuss-Catalan number for a positive order.

gcd

Computes the non-negative greatest common divisor of two signed integers.

geometric_nth_term

Returns the zero-based indexth term of a geometric progression.

geometric_sum

Returns the sum of the first terms values of a geometric progression.

has_inverses

Returns whether every value in elements has a two-sided inverse with respect to identity and operation.

identity_element

Returns a two-sided identity element for operation, if one exists in elements.

implication

Returns the material implication left -> right.

independent_intersection

Returns the probability of two independent events both happening.

independent_union

Returns the probability of at least one of two independent events happening.

is_abelian_group

Returns whether elements with operation form an abelian group.

is_associative

Returns whether operation is associative over elements.

is_closed_under

Returns whether applying operation to any pair of values in elements yields another member of elements.

is_commutative

Returns whether operation is commutative over elements.

is_distributive_over

Returns whether multiply distributes over add from both sides on elements.

is_divisible_by

Returns whether value is evenly divisible by divisor.

is_even

Returns whether an integer is evenly divisible by two.

is_finite_number

Returns whether a raw f64 is finite.

is_group

Returns whether elements with operation form a group.

is_monoid

Returns whether elements with operation form a monoid.

is_odd

Returns whether an integer leaves a remainder of one when divided by two.

is_ring

Returns whether elements with add and multiply form a ring.

is_subset

Returns whether every unique value in left appears in right.

lcm

Computes the non-negative least common multiple of two signed integers.

majority

Returns whether at least two of three inputs are true.

mean

Returns the arithmetic mean of values.

median

Returns the median of values.

midpoint_2d

Returns the midpoint between two 2D points.

nand

Returns the NAND of two boolean values.

nor

Returns the NOR of two boolean values.

normalize_degrees

Normalizes a degrees value into the interval [0, 360).

normalize_radians

Normalizes a radians value into the interval [0, 2π).

orientation_2d

Returns the winding order of three 2D points.

orientation_2d_with_tolerance

Returns the winding order of three 2D points using an explicit area tolerance.

permutations

Returns the number of ordered selections of size k from n items.

population_std_dev

Returns the population standard deviation of values.

population_variance

Returns the population variance of values.

radians_to_degrees

Converts a radians value into degrees.

sample_std_dev

Returns the sample standard deviation of values using Bessel’s correction.

sample_variance

Returns the sample variance of values using Bessel’s correction.

second_central_difference

Approximates the second derivative with a central difference.

set_difference

Returns the unique members of left \ right in the order they first appear in left.

set_intersection

Returns the unique members of left ∩ right in the order they first appear in left.

set_symmetric_difference

Returns the unique members that appear in exactly one of left or right.

set_union

Returns the unique members of left ∪ right in first-seen order.

simpson_integral

Approximates a definite integral with Simpson’s rule.

sin_deg

Evaluates sin for a degrees input.

solve_2x2

Solves matrix * x = rhs for x.

symmetric_limit

Approximates a two-sided limit with one symmetric sample scale.

tan_deg

Evaluates tan for a degrees input.

trapezoidal_integral

Approximates a definite integral with the trapezoidal rule.

triangle_area

Returns the 2D triangle area.

triangle_twice_area

Returns twice the unsigned 2D triangle area.

triangle_twice_signed_area

Returns twice the signed 2D triangle area using the shoelace formula.

try_orientation_2d

Returns the winding order of three 2D points with finite coordinates.

try_orientation_2d_with_tolerance

Returns the winding order of three finite 2D points using an explicit area tolerance.