Struct IfsMap 

pub struct IfsMap {
    pub theta: f32,
    pub phi: f32,
    pub sx: f32,
    pub sy: f32,
    pub t: [f32; 2],
    pub p: f32,
}

One map, decomposed: M = R(θ)·diag(sx, sy)·R(φ), a translation, and a selection probability.

This is the space every morph and every lever acts in, and the reason the whole family is safe by construction rather than by a guard.

Fields

theta: f32

The rotation applied after the scale.

phi: f32

The rotation applied before the scale.

sx: f32

The larger singular value — non-negative, and >= |sy| by construction.

sy: f32

The smaller singular value, signed so a reflection is representable. The fern’s f₄ has determinant −0.109; a parameterization that forces this non-negative reproduces the fern with its right-hand frond wrong, and silently.

t: [f32; 2]

The translation (e, f). Does not enter contractivity at all, which is what makes lean an unconditionally safe lever.

p: f32

Selection probability. Changes where points land, never whether the orbit converges — which is what makes bias safe too.

Implementations

impl IfsMap

pub fn sigma_max(&self) -> f32

This map’s operator norm — the number the whole safety argument is stated against. Contractive exactly when this is below 1.

Written as max(|sx|, |sy|) rather than as sx, even though sx is the larger by construction and stays so under every operation here (a lerp of two orderings preserves the ordering; a uniform scale preserves it). The property is about the operator norm, and spelling it as the property is what keeps a later edit from quietly making sx the wrong answer.

pub fn to_affine(&self) -> Affine

The affine this map recomposes to.

Trait Implementations

impl Clone for IfsMap

fn clone(&self) -> IfsMap

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for IfsMap

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

Formats the value using the given formatter.

impl PartialEq for IfsMap

fn eq(&self, other: &IfsMap) -> 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 Copy for IfsMap

impl StructuralPartialEq for IfsMap