use crate::buffer::Cell;
use crate::canvas::Canvas;
use crate::common::{DEFAULT_SEED, TerminalEffect, seeded_rng};
use crate::render::palette::presets as palette_presets;
use crate::render::{HalfBlockField, Palette};
use crate::runtime::FrameContext;
use crossterm::style::Attribute;
use rand::RngExt;
use serde::{Deserialize, Serialize};
const DEFAULT_ZOOM_RATE: f32 = 0.15;
const STARTING_SCALE: f64 = 0.45;
const MIN_USEFUL_ITERATIONS: u32 = 24;
const REFERENCE_SCALE: f64 = 1.0e-3;
const REFERENCE_BUDGET: f64 = 96.0;
const F32_COORDINATE_STEP: f64 = 2.384185791015625e-7;
const MIN_F32_STEPS_PER_SAMPLE: f64 = 4.0;
const EDGE_SEARCH_STEP: f64 = 1.0e-3;
const EDGE_SEARCH_LIMIT: f64 = 8.0;
const EDGE_BISECTIONS: u32 = 20;
const SAMPLE_ATTEMPTS: usize = 512;
const REJECTION_DRAWS_PER_SAMPLE: usize = 256;
pub const MIN_COLOR_BANDS: u16 = 2;
pub const MAX_COLOR_BANDS: u16 = 256;
fn palette(name: &str) -> Palette {
Palette::named(name)
.unwrap_or_else(|| Palette::new(palette_presets::DEPTH.to_vec()))
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(default)]
pub struct MandelbrotOptions {
pub max_iterations: u16,
pub zoom_rate: f32,
pub color_speed: f32,
pub color_bands: u16,
pub transition_seconds: f32,
pub palette: String,
pub seed: u64,
}
impl Default for MandelbrotOptions {
fn default() -> Self {
Self {
max_iterations: 96,
zoom_rate: DEFAULT_ZOOM_RATE,
color_speed: 0.05,
transition_seconds: 1.5,
color_bands: 32,
palette: String::from("depth"),
seed: DEFAULT_SEED,
}
}
}
pub struct Mandelbrot {
screen_size: (u16, u16),
options: MandelbrotOptions,
canvas: Canvas,
field: HalfBlockField,
center: (f64, f64),
scale: f64,
transition: Option<Transition>,
time: f32,
rng: crate::common::EffectRng,
}
struct Transition {
from_center: (f64, f64),
to_center: (f64, f64),
from_scale: f64,
to_scale: f64,
elapsed: f64,
duration: f64,
pan_fraction: f64,
}
impl Transition {
fn at(&self, elapsed: f64) -> ((f64, f64), f64) {
let p = if self.duration <= 0.0 {
1.0
} else {
(elapsed / self.duration).clamp(0.0, 1.0)
};
if p < self.pan_fraction {
let t = p / self.pan_fraction;
let centre = (
lerp(self.from_center.0, self.to_center.0, t),
lerp(self.from_center.1, self.to_center.1, t),
);
(centre, self.from_scale)
} else {
let q = (p - self.pan_fraction) / (1.0 - self.pan_fraction);
let scale = if q >= 1.0 {
self.to_scale
} else {
lerp(self.from_scale.ln(), self.to_scale.ln(), q).exp()
};
(self.to_center, scale)
}
}
fn done(&self, elapsed: f64) -> bool {
self.duration <= 0.0 || elapsed >= self.duration
}
}
fn lerp(a: f64, b: f64, t: f64) -> f64 {
a + (b - a) * t
}
impl TerminalEffect for Mandelbrot {
fn get_diff(&mut self) -> Vec<(usize, usize, Cell)> {
let (width, height) = (self.field.row_width(), self.field.row_height());
let aspect = width as f64 / height as f64;
let half_height = self.scale;
let half_width = self.scale * aspect;
let (center_re, center_im) = self.center;
let shift = self.time * self.options.color_speed;
let palette = palette(&self.options.palette);
let budget = self.iteration_budget();
let bands = f32::from(
self.options
.color_bands
.clamp(MIN_COLOR_BANDS, MAX_COLOR_BANDS),
);
self.field.fill_with(|x, y| {
let nx = (x as f64 / width as f64) * 2.0 - 1.0;
let ny = (y as f64 / height as f64) * 2.0 - 1.0;
let re = center_re + nx * half_width;
let im = center_im + ny * half_height;
let iterations = escape_time(re as f32, im as f32, budget);
if !iterations.escaped {
return [0.0, 0.0, 0.0];
}
let band = iterations.smooth.max(0.0).rem_euclid(bands);
let t = band.round() / bands;
palette.sample_rgb_wrapped(t + shift)
});
self.field.write_to(&mut self.canvas, Attribute::Reset);
self.canvas.commit()
}
fn update(&mut self) {
self.advance(1.0 / 60.0);
}
fn update_with_context(&mut self, context: &FrameContext) {
self.advance(context.delta.as_secs_f64().min(0.1));
}
fn update_size(&mut self, width: u16, height: u16) {
self.screen_size = (width.max(1), height.max(1));
self.canvas.resize(self.screen_size.0, self.screen_size.1);
self.field
.resize(self.screen_size.0 as usize, self.screen_size.1 as usize);
}
fn reset(&mut self) {
let options = self.options.clone();
*self = Self::new(options, self.screen_size);
}
}
impl Mandelbrot {
pub fn new(options: MandelbrotOptions, screen_size: (u16, u16)) -> Self {
let screen_size = (screen_size.0.max(1), screen_size.1.max(1));
let mut effect = Self {
screen_size,
canvas: Canvas::new(screen_size.0, screen_size.1),
field: HalfBlockField::new(
screen_size.0 as usize,
screen_size.1 as usize,
),
center: (0.0, 0.0),
scale: STARTING_SCALE,
transition: None,
time: 0.0,
rng: seeded_rng(options.seed, "mandelbrot"),
options,
};
effect.canvas.clear();
effect.center = effect.sample_boundary_point(None);
effect
}
fn iteration_budget(&self) -> u32 {
u32::from(self.options.max_iterations).max(MIN_USEFUL_ITERATIONS)
}
fn depth_limit(&self) -> f64 {
let budget = self.iteration_budget() as f64;
let by_budget =
REFERENCE_SCALE * 10.0f64.powf((REFERENCE_BUDGET / budget).log2());
let spacing_per_unit_scale = 2.0 / self.field.row_height() as f64;
let by_precision =
MIN_F32_STEPS_PER_SAMPLE * F32_COORDINATE_STEP / spacing_per_unit_scale;
by_budget.max(by_precision)
}
fn advance(&mut self, dt: f64) {
self.time += dt as f32;
if let Some(transition) = self.transition.as_mut() {
transition.elapsed += dt;
let ((re, im), scale) = transition.at(transition.elapsed);
self.center = (re, im);
self.scale = scale;
if transition.done(transition.elapsed) {
self.transition = None;
}
return;
}
self.scale *= (-self.options.zoom_rate as f64 * dt).exp();
if self.scale < self.depth_limit() {
self.begin_transition();
}
}
fn begin_transition(&mut self) {
let aspect = self.field.row_width() as f64 / self.field.row_height() as f64;
let radius = self.scale * aspect.max(1.0) * 2.5;
let nearby = self.sample_boundary_point(Some((self.center, radius)));
self.transition = Some(Transition {
from_center: self.center,
to_center: nearby,
from_scale: self.scale,
to_scale: STARTING_SCALE,
elapsed: 0.0,
duration: f64::from(self.options.transition_seconds),
pan_fraction: 0.45,
});
self.rng = seeded_rng(self.rng.random::<u64>(), "mandelbrot");
}
fn sample_boundary_point(
&mut self,
near: Option<((f64, f64), f64)>,
) -> (f64, f64) {
let probe = self.iteration_budget();
let walk_limit = match near {
Some((_, radius)) => radius.min(EDGE_SEARCH_LIMIT),
None => EDGE_SEARCH_LIMIT,
};
let mut found = None;
let mut attempts = 0usize;
while attempts < SAMPLE_ATTEMPTS {
attempts += 1;
let mut draws = 0usize;
let drawn = 'draw: loop {
let (x, y) = match near {
Some(((cx, cy), radius)) => {
let radius = if radius.is_finite() && radius > 0.0 {
radius
} else {
f64::MIN_POSITIVE
};
(
cx + self.rng.random_range(-radius..radius),
cy + self.rng.random_range(-radius..radius),
)
}
None => (
self.rng.random_range(-2.0f64..2.0),
self.rng.random_range(-2.0f64..2.0),
),
};
let in_disc = x * x + y * y <= 4.0;
let in_neighbourhood = near.is_none_or(|((cx, cy), radius)| {
let (dx, dy) = (x - cx, y - cy);
dx * dx + dy * dy <= radius * radius
});
if in_disc && in_neighbourhood {
break 'draw Some((x, y));
}
draws += 1;
if draws >= REJECTION_DRAWS_PER_SAMPLE {
break 'draw None;
}
};
let Some((x, y)) = drawn else { continue };
if escape_time(x as f32, y as f32, probe).escaped {
continue;
}
found = Some((x, y));
break;
}
let (x0, y0) = found.unwrap_or((-0.5, 0.0));
let angle = self.rng.random_range(0.0f64..std::f64::consts::PI);
let (dx, dy) = (angle.cos(), angle.sin());
let escaped = |t: f64| {
escape_time((x0 + dx * t) as f32, (y0 + dy * t) as f32, probe).escaped
};
let mut inside = 0.0f64;
let mut outside = None;
let mut step = EDGE_SEARCH_STEP;
while step <= walk_limit {
if escaped(step) {
outside = Some(step);
break;
}
inside = step;
step *= 2.0;
}
match outside {
None => (x0, y0),
Some(outside) => {
let (mut lo, mut hi) = (inside, outside);
for _ in 0..EDGE_BISECTIONS {
let mid = 0.5 * (lo + hi);
if escaped(mid) {
hi = mid;
} else {
lo = mid;
}
}
(x0 + dx * 0.5 * (lo + hi), y0 + dy * 0.5 * (lo + hi))
}
}
}
}
struct Escape {
smooth: f32,
escaped: bool,
}
fn escape_time(re: f32, im: f32, max_iterations: u32) -> Escape {
let (mut zr, mut zi) = (0.0f32, 0.0f32);
let (mut zr2, mut zi2) = (0.0f32, 0.0f32);
let mut i = 0u32;
while i < max_iterations && zr2 + zi2 < 4.0 {
zi = 2.0 * zr * zi + im;
zr = zr2 - zi2 + re;
zr2 = zr * zr;
zi2 = zi * zi;
i += 1;
}
if zr2 + zi2 >= 4.0 {
const LN_2: f32 = std::f32::consts::LN_2;
let magnitude = zr2 + zi2;
let smooth = i as f32 + 1.0 - (magnitude.ln() / LN_2).ln() / LN_2;
Escape {
smooth,
escaped: true,
}
} else {
Escape {
smooth: 0.0,
escaped: false,
}
}
}
#[cfg(test)]
mod tests {
use super::*;
fn interior_and_exterior(
effect: &Mandelbrot,
center: (f64, f64),
scale: f64,
) -> (usize, usize) {
let budget = effect.iteration_budget();
let aspect =
effect.field.row_width() as f64 / effect.field.row_height() as f64;
let (mut interior, mut exterior) = (0usize, 0usize);
for y in 0..effect.field.row_height() {
for x in 0..effect.field.row_width() {
let re = center.0
+ ((x as f64 / effect.field.row_width() as f64) * 2.0 - 1.0)
* scale
* aspect;
let im = center.1
+ ((y as f64 / effect.field.row_height() as f64) * 2.0 - 1.0)
* scale;
if escape_time(re as f32, im as f32, budget).escaped {
exterior += 1;
} else {
interior += 1;
}
}
}
(interior, exterior)
}
fn distinct_colors(
effect: &mut Mandelbrot,
) -> std::collections::HashSet<(u8, u8, u8)> {
let mut seen = std::collections::HashSet::new();
for (_, _, cell) in effect.get_diff() {
if let crossterm::style::Color::Rgb { r, g, b } = cell.color {
seen.insert((r >> 3, g >> 3, b >> 3));
}
}
seen
}
#[test]
fn a_deep_view_uses_the_whole_palette_rather_than_one_colour() {
let mut effect = Mandelbrot::new(MandelbrotOptions::default(), (60, 30));
zoom_to_the_depth_limit(&mut effect);
effect.scale = effect.depth_limit() * 1.02;
let colors = distinct_colors(&mut effect);
assert!(
colors.len() >= 6,
"a view at the depth limit drew only {} distinct colours (of which one \
is presumably the black interior); the escape bands are collapsing \
onto a single palette stop",
colors.len()
);
}
#[test]
fn the_palette_keeps_cycling_rather_than_saturating() {
let mut effect = Mandelbrot::new(MandelbrotOptions::default(), (60, 30));
effect.scale = effect.depth_limit() * 1.02;
effect.time = 10.0;
let late = distinct_colors(&mut effect);
assert!(
late.len() >= 6,
"ten seconds in, the view draws only {} distinct colours, so the \
palette offset has saturated rather than cycled",
late.len()
);
}
#[test]
fn the_colours_shift_over_time() {
let mut effect = Mandelbrot::new(MandelbrotOptions::default(), (60, 30));
effect.scale = effect.depth_limit() * 1.02;
effect.time = 0.0;
let before = distinct_colors(&mut effect);
effect.time = 1.0 / MandelbrotOptions::default().color_speed;
let after = distinct_colors(&mut effect);
assert_ne!(
before, after,
"a full palette lap produced identical colours, so color_speed does \
nothing"
);
}
#[test]
fn the_colour_band_count_reaches_the_renderer() {
let mut effect = Mandelbrot::new(MandelbrotOptions::default(), (60, 30));
effect.scale = effect.depth_limit() * 1.02;
let count_for = |bands: u16| {
let mut effect = Mandelbrot::new(
MandelbrotOptions {
color_bands: bands,
..Default::default()
},
(60, 30),
);
effect.scale = effect.depth_limit() * 1.02;
distinct_colors(&mut effect).len()
};
let coarse = count_for(4);
let fine = count_for(64);
assert!(
coarse < fine,
"{coarse} bands produced {coarse} colours and 64 bands produced {fine}, \
so the knob is not reaching the renderer"
);
}
#[test]
fn the_colour_band_count_is_clamped_away_from_degenerate() {
for requested in [0u16, 1, 2, 256, 1000, u16::MAX] {
let options = MandelbrotOptions {
color_bands: requested,
..Default::default()
};
let mut effect = Mandelbrot::new(options, (40, 20));
let bands = effect
.options
.color_bands
.clamp(MIN_COLOR_BANDS, MAX_COLOR_BANDS);
assert!(
(MIN_COLOR_BANDS..=MAX_COLOR_BANDS).contains(&bands),
"asked for {requested} bands"
);
assert!(
!effect.get_diff().is_empty(),
"{requested} bands drew nothing"
);
}
}
#[test]
fn any_named_palette_renders_and_an_unknown_one_falls_back() {
for name in Palette::preset_names() {
let mut effect = Mandelbrot::new(
MandelbrotOptions {
palette: name.to_string(),
..Default::default()
},
(40, 20),
);
let colors = distinct_colors(&mut effect);
assert!(
colors.len() >= 2,
"palette {name:?} drew {} distinct colours, so it is not being \
used at all",
colors.len()
);
}
let mut effect = Mandelbrot::new(
MandelbrotOptions {
palette: String::from("nonesuch"),
..Default::default()
},
(40, 20),
);
assert!(
distinct_colors(&mut effect).len() >= 2,
"an unknown palette name drew a flat frame instead of falling back"
);
}
#[test]
fn every_preset_cycles_without_a_visible_seam() {
for (name, _) in palette_presets::ALL {
let palette = palette(name);
if palette.stops().len() < 3 {
continue;
}
let last = palette
.stops()
.last()
.copied()
.expect("a preset with no stops");
let first = palette
.stops()
.first()
.copied()
.expect("a preset with no stops");
let gap = match (last, first) {
(
crossterm::style::Color::Rgb {
r: lr,
g: lg,
b: lb,
},
crossterm::style::Color::Rgb {
r: fr,
g: fg,
b: fb,
},
) => {
let l = |r: u8, g: u8, b: u8| {
(0.299 * f32::from(r)
+ 0.587 * f32::from(g)
+ 0.114 * f32::from(b))
/ 255.0
};
(l(lr, lg, lb) - l(fr, fg, fb)).abs()
}
_ => 0.0,
};
assert!(
gap < 0.30,
"palette {name:?} jumps from {last:?} to {first:?} across the wrap, \
which is a visible seam once per palette lap (gap {gap:.2})"
);
}
}
fn settle(effect: &mut Mandelbrot) {
for _ in 0..100_000 {
if effect.transition.is_none() {
return;
}
effect.advance(0.05);
}
panic!("a transition never finished");
}
#[test]
fn the_camera_never_jumps() {
for seed in [3u64, 11, 42] {
let mut effect =
Mandelbrot::new(MandelbrotOptions::default(), (60, 30));
let mut previous = effect.center;
let mut worst: f64 = 0.0;
for _ in 0..3 * 20_000 {
effect.advance(0.01);
let aspect = effect.field.row_width() as f64
/ effect.field.row_height() as f64;
let view_width = effect.scale * aspect.max(1.0);
let moved = ((effect.center.0 - previous.0).powi(2)
+ (effect.center.1 - previous.1).powi(2))
.sqrt();
if view_width > 0.0 {
worst = worst.max(moved / view_width);
}
previous = effect.center;
}
assert!(
worst < 0.25,
"seed {seed}: the camera moved {worst:.2} of a view width in a \
single frame, which is a cut rather than a move"
);
}
}
#[test]
fn the_zoom_is_continuous_across_the_transition() {
let mut effect = Mandelbrot::new(MandelbrotOptions::default(), (60, 30));
let mut previous = effect.scale;
let mut worst = 0.0f64;
for _ in 0..2 * 20_000 {
effect.advance(0.01);
if previous > 0.0 {
worst = worst.max(
(effect.scale / previous).abs().max(previous / effect.scale),
);
}
previous = effect.scale;
}
assert!(
worst < 1.15,
"the scale changed by a factor of {worst:.2} in one frame, so the \
pull-back is a jump rather than a move"
);
}
#[test]
fn a_tour_returns_to_the_restart_view() {
let mut effect = Mandelbrot::new(MandelbrotOptions::default(), (60, 30));
for _ in 0..20_000 {
effect.advance(0.1);
if effect.transition.is_none() && effect.scale > STARTING_SCALE * 0.999
{
break;
}
}
assert_eq!(
effect.scale, STARTING_SCALE,
"after a completed transition the scale should be back at the restart \
view, so the next tour starts wide"
);
assert!(
effect.transition.is_none(),
"a transition was left in flight"
);
}
#[test]
fn a_tour_lasts_long_enough_to_be_worth_watching() {
let options = MandelbrotOptions::default();
let mut effect = Mandelbrot::new(options, (60, 30));
let mut elapsed = 0.0f64;
for _ in 0..40_000 {
effect.advance(0.1);
elapsed += 0.1;
if effect.scale < effect.depth_limit() {
break;
}
}
assert!(
elapsed > 25.0,
"a tour took only {elapsed:.0}s to reach the depth limit, so this \
reads as a loop rather than as travel"
);
}
fn zoom_to_the_depth_limit(effect: &mut Mandelbrot) -> (f64, (f64, f64)) {
let mut deepest = (effect.scale, effect.center);
for _ in 0..20_000 {
let before = effect.scale;
let was_transitioning = effect.transition.is_some();
effect.advance(0.1);
if !was_transitioning
&& effect.transition.is_none()
&& effect.scale < deepest.0
{
deepest = (effect.scale, effect.center);
}
if effect.transition.is_some() {
settle(effect);
return deepest;
}
if effect.scale > before {
return deepest;
}
}
panic!("the camera never reached its depth limit");
}
#[test]
fn a_point_in_the_set_never_escapes() {
assert!(!escape_time(0.0, 0.0, 500).escaped);
assert!(!escape_time(-0.5, 0.0, 500).escaped);
assert!(!escape_time(-1.0, 0.0, 500).escaped);
}
#[test]
fn a_point_outside_the_set_escapes_quickly() {
let escape = escape_time(2.5, 2.5, 500);
assert!(escape.escaped);
assert!(escape.smooth < 10.0, "took {} iterations", escape.smooth);
}
#[test]
fn points_near_the_boundary_take_longer_to_escape() {
let far = escape_time(0.4, 0.0, 4000).smooth;
let near = escape_time(-0.7450, 0.1130, 4000).smooth;
assert!(
near > far,
"a near-boundary point ({near}) escaped sooner than a far one ({far})"
);
}
#[test]
fn the_iteration_budget_is_respected() {
let escape = escape_time(0.0, 0.0, 12);
assert!(!escape.escaped);
}
#[test]
fn the_smooth_count_falls_between_its_iterations() {
let escape = escape_time(0.6, 0.1, 100);
assert!(escape.escaped);
assert!(escape.smooth > 0.0);
}
#[test]
fn the_starting_view_has_the_boundary_running_through_it() {
for seed in 0..12u64 {
let options = MandelbrotOptions {
seed,
..Default::default()
};
let effect = Mandelbrot::new(options, (40, 16));
let (interior, exterior) =
interior_and_exterior(&effect, effect.center, effect.scale);
assert!(
interior > 0,
"seed {seed} started entirely outside the set at {:?}",
effect.center
);
assert!(
exterior > 0,
"seed {seed} started entirely inside the set at {:?}, which is a \
flat black rectangle",
effect.center
);
}
}
#[test]
fn the_first_frame_is_the_restart_view() {
let effect = Mandelbrot::new(MandelbrotOptions::default(), (20, 8));
assert_eq!(effect.scale, STARTING_SCALE);
}
#[test]
fn a_frame_is_drawn_and_stays_in_bounds() {
let mut effect = Mandelbrot::new(MandelbrotOptions::default(), (40, 12));
let diff = effect.get_diff();
assert!(!diff.is_empty(), "the first frame was blank");
for (x, y, _) in &diff {
assert!(*x < 40 && *y < 12, "cell ({x},{y}) is outside the canvas");
}
}
#[test]
fn the_interior_is_black_and_the_exterior_is_not() {
let mut effect = Mandelbrot::new(MandelbrotOptions::default(), (40, 12));
effect.get_diff();
let pixels = effect.field.pixels();
let black = pixels.iter().filter(|p| *p == &[0.0, 0.0, 0.0]).count();
let lit = pixels.len() - black;
assert!(black > 0, "nothing was interior");
assert!(lit > 0, "nothing escaped");
}
#[test]
fn zooming_moves_the_camera_in() {
let mut effect = Mandelbrot::new(MandelbrotOptions::default(), (40, 12));
let before = effect.scale;
effect.update();
assert!(effect.scale < before, "the camera did not move");
}
#[test]
fn going_past_the_depth_limit_starts_a_move_rather_than_a_cut() {
let mut effect = Mandelbrot::new(MandelbrotOptions::default(), (40, 12));
let limit = effect.depth_limit();
let before = effect.center;
effect.scale = limit * 0.5;
effect.advance(1.0 / 60.0);
assert!(
effect.transition.is_some(),
"reaching the depth limit should start a move, not assign a new centre"
);
let moved = ((effect.center.0 - before.0).powi(2)
+ (effect.center.1 - before.1).powi(2))
.sqrt();
let view = effect.scale * 2.0;
assert!(
moved < view * 0.25,
"the first frame of the move shifted the centre by {moved:.2e}, which \
is a quarter of the view width and reads as a cut"
);
settle(&mut effect);
assert_eq!(
effect.scale, STARTING_SCALE,
"the move did not pull back out to the restart view"
);
assert!(effect.scale > limit);
}
#[test]
fn a_budget_under_the_useful_floor_is_raised_rather_than_obeyed() {
for max_iterations in [0u16, 1, 8, 23] {
let options = MandelbrotOptions {
max_iterations,
..Default::default()
};
let mut effect = Mandelbrot::new(options, (20, 8));
assert_eq!(effect.iteration_budget(), MIN_USEFUL_ITERATIONS);
assert!(!effect.get_diff().is_empty());
assert!(effect.depth_limit() > REFERENCE_SCALE);
}
}
#[test]
fn the_deepest_zoom_the_camera_reaches_still_shows_both_sides() {
for seed in 0..10u64 {
let options = MandelbrotOptions {
seed,
..Default::default()
};
let mut effect = Mandelbrot::new(options, (40, 16));
let limit = effect.depth_limit();
let (deepest, center) = zoom_to_the_depth_limit(&mut effect);
assert!(
deepest >= limit && deepest < limit * 1.05,
"seed {seed} stopped at {deepest:.3e}, which is not its depth \
limit of {limit:.3e}"
);
let (interior, exterior) =
interior_and_exterior(&effect, center, deepest);
let total = interior + exterior;
assert!(
interior > 0,
"seed {seed} at {deepest:.3e} was all exterior at {center:?}"
);
assert!(
exterior > 0,
"seed {seed} at {deepest:.3e} was all interior at {center:?}, \
which is the flat wash"
);
assert!(
exterior * 20 > total,
"seed {seed} at {deepest:.3e} had {exterior} exterior samples of \
{total}, too few to read as a boundary"
);
}
}
#[test]
fn the_depth_limit_follows_the_iteration_budget() {
let reached = |max_iterations: u16| {
let options = MandelbrotOptions {
max_iterations,
..Default::default()
};
let mut effect = Mandelbrot::new(options, (40, 16));
let limit = effect.depth_limit();
let (deepest, _) = zoom_to_the_depth_limit(&mut effect);
(limit, deepest)
};
let (cheap_limit, cheap) = reached(MIN_USEFUL_ITERATIONS as u16);
let (default_limit, default) = reached(96);
let (rich_limit, rich) = reached(384);
assert!(
cheap_limit > default_limit && default_limit > rich_limit,
"a bigger budget did not buy depth: {cheap_limit:.3e} at 24, \
{default_limit:.3e} at 96, {rich_limit:.3e} at 384"
);
assert!(
cheap > default && default > rich,
"the camera did not follow its own depth limit: {cheap:.3e}, \
{default:.3e}, {rich:.3e}"
);
assert!(
rich < cheap / 10.0,
"{} is not a decade under {}",
rich,
cheap
);
}
#[test]
fn the_camera_stops_before_f32_runs_out() {
let options = MandelbrotOptions {
max_iterations: 384,
..Default::default()
};
let mut effect = Mandelbrot::new(options, (100, 100));
let limit = effect.depth_limit();
let by_budget =
REFERENCE_SCALE * 10.0f64.powf((REFERENCE_BUDGET / 384.0).log2());
assert!(
by_budget < limit,
"expected the precision term to bind at 384 iterations, got \
{limit:.3e} against a budget term of {by_budget:.3e}"
);
let (deepest, _) = zoom_to_the_depth_limit(&mut effect);
assert!(deepest >= limit && deepest < limit * 1.05);
let spacing = 2.0 * deepest / effect.field.row_height() as f64;
assert!(
spacing >= MIN_F32_STEPS_PER_SAMPLE * F32_COORDINATE_STEP,
"samples are {spacing:.3e} apart, under {} f32 steps",
MIN_F32_STEPS_PER_SAMPLE
);
}
#[test]
fn a_recentre_leaves_the_boundary_across_the_screen() {
for seed in 0..8u64 {
let options = MandelbrotOptions {
seed,
..Default::default()
};
let mut effect = Mandelbrot::new(options, (40, 16));
zoom_to_the_depth_limit(&mut effect);
settle(&mut effect);
assert_eq!(effect.scale, STARTING_SCALE);
let (interior, exterior) =
interior_and_exterior(&effect, effect.center, effect.scale);
let total = interior + exterior;
assert!(
interior * 10 > total,
"seed {seed}: the restart view was {interior} interior of {total} \
samples at {:?}, so the set is a small disc",
effect.center
);
assert!(
exterior * 10 > total,
"seed {seed}: the restart view was all interior at {:?}",
effect.center
);
}
}
#[test]
fn a_full_tour_ends_somewhere_worth_looking_at() {
let options = MandelbrotOptions {
seed: 3,
..Default::default()
};
let mut effect = Mandelbrot::new(options, (40, 16));
let mut centres: Vec<(f64, f64)> = Vec::new();
let limit = effect.depth_limit();
for cycle in 0..3 {
let (deepest, center) = zoom_to_the_depth_limit(&mut effect);
assert!(
deepest >= limit && deepest < limit * 1.05,
"cycle {cycle} stopped at {deepest:.3e} rather than at its depth \
limit of {limit:.3e}"
);
assert_eq!(effect.scale, STARTING_SCALE, "it did not pull back out");
if cycle > 0 {
assert!(
!centres.contains(¢er),
"seed 3 came back to {center:?} on cycle {cycle}"
);
}
centres.push(center);
let (interior, exterior) =
interior_and_exterior(&effect, center, deepest);
assert!(
interior > 0 && exterior > 0,
"the tour stopped at {deepest:.3e} on a view that is all {}",
if interior == 0 {
"exterior"
} else {
"interior"
}
);
}
}
#[test]
fn the_tour_is_reproducible_from_the_seed() {
let tour = |seed: u64| {
let options = MandelbrotOptions {
seed,
..Default::default()
};
let mut effect = Mandelbrot::new(options, (20, 8));
let mut centres = Vec::new();
for _ in 0..4 {
effect.scale = effect.depth_limit() * 0.5;
effect.advance(1.0 / 60.0);
centres.push(effect.center);
}
centres
};
assert_eq!(tour(7), tour(7), "the same seed toured differently");
}
#[test]
fn different_seeds_tour_differently() {
let tour = |seed: u64| {
let options = MandelbrotOptions {
seed,
..Default::default()
};
let mut effect = Mandelbrot::new(options, (20, 8));
let mut centres = Vec::new();
for _ in 0..4 {
effect.scale = effect.depth_limit() * 0.5;
effect.advance(1.0 / 60.0);
centres.push(effect.center);
}
centres
};
assert_ne!(tour(7), tour(8), "two seeds produced the same tour");
}
#[test]
fn surviving_a_resize() {
let mut effect = Mandelbrot::new(MandelbrotOptions::default(), (40, 12));
effect.update_size(6, 6);
let diff = effect.get_diff();
for (x, y, _) in &diff {
assert!(*x < 6 && *y < 6);
}
}
}