Struct LinearAxis 

pub struct LinearAxis<const N: usize> { /* private fields */ }

An axis of N stored knots located by a bounded forward scan.

It stores exactly what BinaryAxis stores and accepts the same arbitrary spacing; it differs only in trading the halving loop for a straight walk. On a three- or four-knot axis that walk is at most two or three comparisons — comparable to the search it replaces, with less code behind it. On a long axis it is the wrong choice, and the bound below says so plainly.

Cost

2*N stored bytes, no index, and at most N - 1 strategy-specific knot comparisons after the endpoint checks. Unlike the binary strategy the count is data-dependent: a coordinate near the first knot costs less than one near the last.

Examples

use ph_surfaces::{BilinearSurface, BinaryAxis, LinearAxis};

static X: [u16; 3] = [0, 30, 100];
static Y: [u16; 2] = [0, 10];
static VALUES: [[i32; 3]; 2] = [[0, 30, 100], [10, 40, 110]];

// A tiny X axis scans; the Y axis keeps the default strategy.
static SURFACE: BilinearSurface<3, 2, LinearAxis<3>, BinaryAxis<2>> =
    BilinearSurface::from_axes(LinearAxis::new(&X), BinaryAxis::new(&Y), &VALUES);

// Same answers as the all-binary surface over the same tables.
static DEFAULT: BilinearSurface<3, 2> = BilinearSurface::new(&X, &Y, &VALUES);
assert_eq!(SURFACE.evaluate(65, 5), DEFAULT.evaluate(65, 5));
assert_eq!(SURFACE.evaluate(65, 5), Ok(70));

An axis of fewer than two knots does not compile:

use ph_surfaces::LinearAxis;

static X: [u16; 1] = [7];
static AXIS: LinearAxis<1> = LinearAxis::new(&X);

Implementations

impl<const N: usize> LinearAxis<N>

pub const fn new(knots: &'static [u16; N]) -> Self

Declares a scanned axis over static knots.

Panics

Panics unless the axis declares at least two strictly increasing knots. In a constant or static definition that panic is a compile error.

Examples found in repository

examples/firmware_cost_budget.rs (line 31)

    static LINEAR: TinyLinear =
        BilinearSurface::from_axes(LinearAxis::new(&X), LinearAxis::new(&Y), &VALUES);

pub const fn knots(&self) -> &'static [u16; N]

Returns the declared knots.

The same array as KnotArray::knots, available in a constant context.

Trait Implementations

impl<const N: usize> AxisLookup<N> for LinearAxis<N>

const KNOT_BYTES: usize

Bytes of stored knots or descriptor this strategy references.

const INDEX_BYTES: usize = 0

Bytes of auxiliary index this strategy references.

const MAX_SEARCH_COMPARISONS: u32

The most strategy-specific knot comparisons needed to locate an in-domain coordinate, after the inclusive endpoint checks.

fn first(&self) -> u16

Returns the first knot: the inclusive lower bound of the axis domain.

fn last(&self) -> u16

Returns the last knot: the inclusive upper bound of the axis domain.

fn knot(&self, index: usize) -> u16

Returns the knot at index.

fn search(&self, coordinate: u16) -> (usize, u32)

Returns the greatest index whose knot is at or below coordinate, together with the number of knot comparisons it took.

impl<const N: usize> Clone for LinearAxis<N>

fn clone(&self) -> LinearAxis<N>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<const N: usize> Copy for LinearAxis<N>

impl<const N: usize> Debug for LinearAxis<N>

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

Formats the value using the given formatter.

impl<const N: usize> Eq for LinearAxis<N>

impl<const N: usize> Hash for LinearAxis<N>

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<const N: usize> KnotArray<N> for LinearAxis<N>

fn knots(&self) -> &'static [u16; N]

Returns the declared knots, strictly increasing and at least two long.

impl<const N: usize> PartialEq for LinearAxis<N>

fn eq(&self, other: &LinearAxis<N>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const N: usize> StructuralPartialEq for LinearAxis<N>