mgart 0.0.2

Machine Generated Art. CLI app for generating algorithmic art
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

use serde::{Deserialize, Serialize};

use num::complex::Complex64;

use log::{log_enabled, Level};

use num::cast;

use std::sync::atomic::{AtomicU64, Ordering};

pub mod coloring;
pub mod frame;
pub mod gradient;
pub mod post_processing;
pub mod sampler;
pub mod viewport;

/// Representation of a complex number.
///
/// This is intended to be used as means for parsing user input,
/// not for doing calculations.
/// So [`ComplexNumber`] does not implement any math operations,
/// but supports the conversion to [Complex64].
///
#[derive(Serialize, Deserialize, Clone, Copy)]
#[serde(untagged)]
pub enum ComplexNumber {
  Cartesian { re: f64, im: f64 },
  Polar { r: f64, theta: f64 },
}

impl From<&ComplexNumber> for Complex64 {
  fn from(cn: &ComplexNumber) -> Self {
    match cn {
      ComplexNumber::Cartesian { re, im } => Self::new(*re, *im),
      ComplexNumber::Polar { r, theta } => {
        Self::from_polar(*r, *theta)
      }
    }
  }
}

impl From<ComplexNumber> for Complex64 {
  fn from(cn: ComplexNumber) -> Self {
    Self::from(&cn)
  }
}

// TODO: dz is derivative of z in the iteration sequence ... if I were
//       to look for finite attractors for different functions, I'd
//       need to generalize this
#[must_use]
pub fn finite_attractor(
  z0: Complex64,
  c: Complex64,
  p: usize,
) -> Option<(Complex64, Complex64)> {
  let mut zz = z0;

  for _ in 0..64 {
    let mut z = zz;
    let mut dz = Complex64::new(1., 0.);

    for _ in 0..p {
      dz = 2. * z * dz;
      z = z.powi(2) + c;
    }

    let zz_new = zz - (z - zz) / (dz - 1.);

    if (zz_new - zz).norm_sqr() <= 1e-20 {
      return Some((z, dz));
    }

    zz = zz_new;
  }

  None
}

/// Thread-safe progress printer for printing the number of iterations
/// done by a computationally expensive loop.
///
pub enum ProgressPrinter {
  Info(InfoProgressPrinter),
  Disabled,
}

impl ProgressPrinter {
  #[must_use]
  pub fn new(n: u64, interval: u64) -> Self {
    if log_enabled!(Level::Info) {
      Self::Info(InfoProgressPrinter::new(n, interval))
    } else {
      Self::Disabled
    }
  }

  pub fn increment(&self) {
    if let Self::Info(info) = self {
      info.increment();
    }
  }
}

pub struct InfoProgressPrinter {
  counter: AtomicU64,
  n: u64,
  n_f64: f64,
  interval: u64,
}

impl InfoProgressPrinter {
  /// Creates a new instance of [`InfoProgressPrinter`].
  ///
  /// # Panics
  ///
  /// Panics, if [`n`] overflows the 53 bit mantissa of [f64].
  ///
  #[must_use]
  pub fn new(n: u64, interval: u64) -> Self {
    Self {
      counter: AtomicU64::new(0),
      n,
      n_f64: cast::<_, f64>(n).unwrap(),
      interval,
    }
  }

  /// Increments the counter, printing a status update if the counter
  /// equals a multiple of [`interval`] or [`n`].
  ///
  /// # Panics
  ///
  /// Panics, if the counter overflows the 53 bit mantissa of [f64].
  ///
  pub fn increment(&self) {
    let i = self.counter.fetch_add(1, Ordering::SeqCst);

    if i % self.interval == self.interval - 1 || i == self.n - 1 {
      let p = cast::<_, f64>(i).unwrap() / self.n_f64 * 100.;
      print!("{}/{} iterations done ({:.2}%)\r", i + 1, self.n, p);
    }
  }
}