mathzoo 0.2.0

Colorful real-time mathematical simulations and generative art for your terminal
use crate::canvas::Canvas;
use crate::color::{hsv, WHITE};
use crate::math::{rk4, V3};
use crate::scene::{Key, Scene};
use std::collections::VecDeque;

const MAX_PTS: usize = 5000;
const SUB: usize = 3;
const BURN_IN: usize = 3000;
const PREFILL: usize = 1500;

#[derive(Clone, Copy)]
enum Kind {
    Lorenz,
    Rossler,
    Aizawa,
    Thomas,
    Halvorsen,
}

const KINDS: [Kind; 5] = [
    Kind::Lorenz,
    Kind::Rossler,
    Kind::Aizawa,
    Kind::Thomas,
    Kind::Halvorsen,
];

impl Kind {
    fn name(self) -> &'static str {
        match self {
            Kind::Lorenz => "Lorenz",
            Kind::Rossler => "Rossler",
            Kind::Aizawa => "Aizawa",
            Kind::Thomas => "Thomas",
            Kind::Halvorsen => "Halvorsen",
        }
    }

    fn start(self) -> V3 {
        match self {
            Kind::Lorenz => V3::new(0.1, 0.0, 0.0),
            Kind::Rossler => V3::new(1.0, 1.0, 0.0),
            Kind::Aizawa => V3::new(0.1, 0.0, 0.0),
            Kind::Thomas => V3::new(1.1, 1.1, -0.01),
            Kind::Halvorsen => V3::new(-1.48, -1.51, 2.04),
        }
    }

    fn dt(self) -> f64 {
        match self {
            Kind::Lorenz => 0.005,
            Kind::Rossler => 0.02,
            Kind::Aizawa => 0.01,
            Kind::Thomas => 0.05,
            Kind::Halvorsen => 0.005,
        }
    }

    fn deriv(self, p: V3) -> V3 {
        match self {
            Kind::Lorenz => V3::new(
                10.0 * (p.y - p.x),
                p.x * (28.0 - p.z) - p.y,
                p.x * p.y - 8.0 / 3.0 * p.z,
            ),
            Kind::Rossler => V3::new(-p.y - p.z, p.x + 0.2 * p.y, 0.2 + p.z * (p.x - 5.7)),
            Kind::Aizawa => {
                let (a, b, c, d, e, f) = (0.95, 0.7, 0.6, 3.5, 0.25, 0.1);
                V3::new(
                    (p.z - b) * p.x - d * p.y,
                    d * p.x + (p.z - b) * p.y,
                    c + a * p.z - p.z.powi(3) / 3.0 - (p.x * p.x + p.y * p.y) * (1.0 + e * p.z)
                        + f * p.z * p.x.powi(3),
                )
            }
            Kind::Thomas => {
                let b = 0.208186;
                V3::new(
                    p.y.sin() - b * p.x,
                    p.z.sin() - b * p.y,
                    p.x.sin() - b * p.z,
                )
            }
            Kind::Halvorsen => {
                let a = 1.89;
                V3::new(
                    -a * p.x - 4.0 * p.y - 4.0 * p.z - p.y * p.y,
                    -a * p.y - 4.0 * p.z - 4.0 * p.x - p.z * p.z,
                    -a * p.z - 4.0 * p.x - 4.0 * p.y - p.x * p.x,
                )
            }
        }
    }
}

fn burn_in(kind: Kind) -> V3 {
    let f = |p: V3| kind.deriv(p);
    let mut p = kind.start();
    for _ in 0..BURN_IN {
        p = rk4(&f, p, kind.dt());
    }
    p
}

struct Trail {
    head: V3,
    pts: VecDeque<V3>,
}

impl Trail {
    fn new(head: V3) -> Self {
        Trail {
            head,
            pts: VecDeque::new(),
        }
    }

    fn advance(&mut self, kind: Kind) {
        let f = |p: V3| kind.deriv(p);
        let h = kind.dt();
        for _ in 0..SUB {
            self.head = rk4(&f, self.head, h);
        }
        if !(self.head.x.is_finite() && self.head.y.is_finite() && self.head.z.is_finite()) {
            self.head = kind.start();
            self.pts.clear();
        }
        self.pts.push_back(self.head);
        while self.pts.len() > MAX_PTS {
            self.pts.pop_front();
        }
    }
}

pub struct Attractors {
    idx: usize,
    main: Trail,
    twin: Option<Trail>,
    yaw: f64,
    pitch: f64,
    spin: f64,
    speed: f64,
    acc: f64,
    fit_c: V3,
    fit_r: f64,
    w: usize,
    h: usize,
}

impl Attractors {
    pub fn new() -> Self {
        let mut a = Attractors {
            idx: 0,
            main: Trail::new(V3::default()),
            twin: None,
            yaw: 0.0,
            pitch: 0.35,
            spin: 0.35,
            speed: 1.0,
            acc: 0.0,
            fit_c: V3::default(),
            fit_r: 1.0,
            w: 0,
            h: 0,
        };
        a.load();
        a
    }

    fn kind(&self) -> Kind {
        KINDS[self.idx]
    }

    fn load(&mut self) {
        let kind = self.kind();
        self.main = Trail::new(burn_in(kind));
        for _ in 0..PREFILL {
            self.main.advance(kind);
        }
        self.twin = None;
        self.refit(true);
    }

    fn refit(&mut self, snap: bool) {
        if self.main.pts.is_empty() {
            return;
        }
        let mut lo = V3::new(f64::MAX, f64::MAX, f64::MAX);
        let mut hi = V3::new(f64::MIN, f64::MIN, f64::MIN);
        for p in self.main.pts.iter() {
            lo = V3::new(lo.x.min(p.x), lo.y.min(p.y), lo.z.min(p.z));
            hi = V3::new(hi.x.max(p.x), hi.y.max(p.y), hi.z.max(p.z));
        }
        let c = (lo + hi) * 0.5;
        let mut r: f64 = 1e-9;
        for p in self.main.pts.iter() {
            r = r.max((*p - c).norm());
        }
        if snap {
            self.fit_c = c;
            self.fit_r = r;
        } else {
            self.fit_c = self.fit_c + (c - self.fit_c) * 0.05;
            self.fit_r += (r - self.fit_r) * 0.05;
        }
    }

    fn project(&self, p: V3, k: f64) -> (i32, i32) {
        let d = p - self.fit_c;
        let q = V3::new(d.x, d.z, d.y).rot_y(self.yaw).rot_x(self.pitch);
        let cx = self.w as f64 * 0.5;
        let cy = self.h as f64 * 0.5;
        ((cx + q.x * k).round() as i32, (cy - q.y * k).round() as i32)
    }

    fn draw_trail(&self, canvas: &mut Canvas, trail: &Trail, k: f64, hue_old: f64, hue_new: f64) {
        let n = trail.pts.len();
        let mut prev: Option<(i32, i32)> = None;
        for (i, p) in trail.pts.iter().enumerate() {
            let t = i as f64 / n.max(1) as f64;
            let (x, y) = self.project(*p, k);
            let color = hsv(hue_old + (hue_new - hue_old) * t, 0.8, 0.25 + 0.75 * t);
            match prev {
                Some((px, py)) => canvas.line(px, py, x, y, color),
                None => canvas.set(x, y, color),
            }
            prev = Some((x, y));
        }
    }
}

impl Scene for Attractors {
    fn name(&self) -> &'static str {
        "attractors"
    }

    fn status(&self) -> String {
        let mut s = format!(
            "{} | arrows: view  +/-: speed  c: next system  t: twin (butterfly effect)",
            self.kind().name()
        );
        if let Some(t) = &self.twin {
            let d = (self.main.head - t.head).norm();
            s.push_str(&format!(" | twin distance {:.4}", d));
        }
        s
    }

    fn resize(&mut self, px_w: usize, px_h: usize) {
        self.w = px_w;
        self.h = px_h;
    }

    fn reset(&mut self) {
        self.load();
    }

    fn update(&mut self, dt: f64) {
        self.yaw += self.spin * dt;
        self.acc = (self.acc + dt * 60.0 * self.speed).min(30.0);
        let kind = self.kind();
        while self.acc >= 1.0 {
            self.main.advance(kind);
            if let Some(t) = self.twin.as_mut() {
                t.advance(kind);
            }
            self.acc -= 1.0;
        }
        self.refit(false);
    }

    fn draw(&self, canvas: &mut Canvas) {
        if self.w == 0 || self.h == 0 {
            return;
        }
        let k = 0.46 * self.w.min(self.h) as f64 / self.fit_r.max(1e-9);
        self.draw_trail(canvas, &self.main, k, 200.0, 330.0);
        if let Some(t) = &self.twin {
            self.draw_trail(canvas, t, k, 20.0, 60.0);
        }
        let (hx, hy) = self.project(self.main.head, k);
        for (dx, dy) in [(0, 0), (1, 0), (0, 1), (1, 1)] {
            canvas.set(hx + dx, hy + dy, WHITE);
        }
        if let Some(t) = &self.twin {
            let (tx, ty) = self.project(t.head, k);
            for (dx, dy) in [(0, 0), (1, 0), (0, 1), (1, 1)] {
                canvas.set(tx + dx, ty + dy, hsv(0.0, 0.9, 1.0));
            }
        }
    }

    fn key(&mut self, key: Key) {
        match key {
            Key::Left => self.spin -= 0.15,
            Key::Right => self.spin += 0.15,
            Key::Up => self.pitch = (self.pitch + 0.1).min(1.5),
            Key::Down => self.pitch = (self.pitch - 0.1).max(-1.5),
            Key::Char('+') | Key::Char('=') => self.speed = (self.speed * 1.25).min(8.0),
            Key::Char('-') | Key::Char('_') => self.speed = (self.speed / 1.25).max(0.1),
            Key::Char('c') => {
                self.idx = (self.idx + 1) % KINDS.len();
                self.load();
            }
            Key::Char('t') => {
                if self.twin.is_some() {
                    self.twin = None;
                } else {
                    let mut head = self.main.head;
                    head.x += 1e-3;
                    self.twin = Some(Trail::new(head));
                }
            }
            _ => {}
        }
    }
}