Enum Scale 

pub enum Scale {
    Linear,
    Time,
    Log {
        base: f64,
    },
}

A continuous, invertible map from an axis’s data space to scale space, with tick generation and default value formatting.

Construct with Scale::linear, Scale::time, or Scale::log and hand it to a plot axis (plot(...).x(Scale::time())). The visible domain is not carried here — it lives in the plot’s PlotView state, the same way a CSS transform is separate from the element it applies to. A Scale is just the warp + tick policy.

Variants

Linear

A linear (identity-warp) numeric axis. Ticks are “nice” numbers (multiples of 1/2/5 × 10ⁿ).

Time

A time axis. Data is epoch seconds (f64, so millisecond precision survives even for present-day timestamps — see the plan’s decision 7). The warp is the identity (time is linear in seconds); ticks land on natural calendar/clock boundaries and format as clock time or dates.

Log

A logarithmic axis. The warp is log(value), so panning and zooming stay affine in scale space. The domain must stay strictly positive; non-positive values are clamped to a tiny epsilon by the warp.

Fields

base: f64

The logarithm base (e.g. 10.0). Tick placement uses powers of this base.

Implementations

impl Scale

pub fn linear() -> Self

A linear numeric axis.

pub fn time() -> Self

A time axis over epoch seconds.

pub fn log() -> Self

A base-10 logarithmic axis. Use Scale::Log directly for another base.

pub fn forward(&self, v: f64) -> f64

Warp a data-space value into scale space. Identity for Linear/Time; log_base for Log.

pub fn inverse(&self, u: f64) -> f64

Inverse of forward: map a scale-space coordinate back to data space.

pub fn map(&self, v: f64, origin: f64) -> f32

Map a data value to a GPU-ready scale-space coordinate measured relative to origin (a data-space reference subtracted before the cast to f32). Subtracting a per-axis origin is what keeps large absolute coordinates — epoch timestamps especially — inside f32’s ~7 significant digits on the GPU (the plan’s decision 7). Pass the same origin to invert.

pub fn invert(&self, s: f32, origin: f64) -> f64

Inverse of map: recover the data value from an origin-relative scale-space coordinate (e.g. for a crosshair readout).

pub fn ticks(&self, window: (f64, f64), target: usize) -> Vec<Tick>

Generate axis ticks across the visible data window (lo, hi), aiming for about target of them. Returns ticks in ascending data order, each with its data value and a default label. lo/hi are in data space; an empty or inverted window yields no ticks.

pub fn format(&self, v: f64, context: f64) -> String

Format a single data value the way this scale’s ticks would, e.g. for a crosshair readout. context is a neighbouring span (typically the visible window width) used to choose precision; pass 0.0 to accept the default.

Trait Implementations

impl Clone for Scale

fn clone(&self) -> Scale

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Scale

impl Debug for Scale

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

Formats the value using the given formatter.

impl PartialEq for Scale

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl StructuralPartialEq for Scale