Cleaned up and refactored. Added in changeable data type.

Author: jackyarndley

output.png

@@ -1,9 +1,7 @@
 use std::time::Instant;
 use rust_fractal::renderer::FractalRenderer;
-use float_extended::float_extended::FloatExtended;
-use std::{io, fs};
-use std::io::{stdout, stdin, Write, BufReader, BufRead};
-use std::fs::File;
+use std::fs;
+use std::io::{stdout, stdin, Write};
 
 fn main() {
     println!("Mandelbrot Renderer");
@@ -33,33 +31,27 @@ fn main() {
     for line in data.lines() {
         let mut parts = line.split_whitespace();
         // println!("{}", line);
-        let mut temp = parts.next().unwrap();
+        let temp = parts.next().unwrap();
 
         match temp {
             "Re:" => {
-                let mut temp2 = parts.next().unwrap();
-                center_re = temp2;
+                center_re = parts.next().unwrap();
             },
             "Im:" => {
-                let mut temp2 = parts.next().unwrap();
-                center_im = temp2;
+                center_im = parts.next().unwrap();
             }
             "Zoom:" => {
-                let mut temp2 = parts.next().unwrap();
-                zoom = temp2;
+                zoom = parts.next().unwrap();
             },
             "Iterations:" => {
-                let mut temp2 = parts.next().unwrap();
-                iterations = temp2;
+                iterations = parts.next().unwrap();
             }
             _ => {}
         }
     }
 
     println!("Zoom: {}", zoom);
 
-    println!("Rendering...");
-
     let mut renderer = FractalRenderer::new(
         1000,
         1000,

src/bin/main.rs

@@ -1,8 +1,4 @@
 #![feature(extra_log_consts)]
-
-// pub mod renderer;
 pub mod renderer;
 pub mod util;
-pub mod colouring;
-pub mod colouring2;
 pub mod math;

src/lib.rs

@@ -1,7 +1,6 @@
-// pub mod perturbation_f64;
-// pub mod perturbation_f64_vectorised;
-pub mod perturbation;
-pub mod perturbation2;
-pub mod reference;
-pub mod reference2;
-pub mod series_approximation;
+pub mod perturbation_double;
+pub mod perturbation_extended;
+pub mod reference_double;
+pub mod reference_extended;
+pub mod series_approximation_double;
+pub mod series_approximation_extended;

src/math/mod.rs

@@ -0,0 +1,40 @@
+use crate::math::reference_double::ReferenceDouble;
+use crate::util::PixelDataDouble;
+use rayon::prelude::*;
+
+pub struct PerturbationDouble {}
+
+impl PerturbationDouble {
+    pub fn iterate(pixel_data: &mut Vec<PixelDataDouble>, reference: &ReferenceDouble, reference_current_iteration: usize) {
+        pixel_data.par_chunks_mut(4)
+            .for_each(|pixel_data| {
+                for packet in pixel_data {
+                    // normal
+                    while packet.iteration < reference_current_iteration {
+                        // This uses the difference between the starting iteration of the reference - can be used to skip some
+                        let z = packet.delta_current + reference.z_reference[packet.iteration - reference.start_iteration];
+                        let z_norm = z.norm_sqr();
+
+                        if z_norm < reference.z_tolerance[packet.iteration - reference.start_iteration] {
+                            packet.glitched = true;
+                            packet.delta_current = z;
+                            break;
+                        }
+
+                        if z_norm > 1e16 {
+                            packet.escaped = true;
+                            packet.delta_current = z;
+                            break;
+                        }
+
+                        // packet.derivative_current = 2.0 * z * packet.derivative_current + 1.0;
+                        packet.delta_current = 2.0 * reference.z_reference[packet.iteration - reference.start_iteration] * packet.delta_current + packet.delta_current * packet.delta_current + packet.delta_reference;
+                        packet.iteration += 1;
+                    }
+                }
+            });
+    }
+}
+
+
+

src/math/perturbation.rs

@@ -1,16 +1,14 @@
-use crate::math::reference::Reference;
-use crate::util::{PixelData, PixelData2};
+use crate::util::PixelDataExtended;
 use float_extended::util::FloatExp;
 
 use rayon::prelude::*;
-use float_extended::float_extended::FloatExtended;
-use crate::math::reference2::Reference2;
+use crate::math::reference_extended::ReferenceExtended;
 use std::cmp::max;
 
-pub struct Perturbation2 {}
+pub struct PerturbationExtended {}
 
-impl Perturbation2 {
-    pub fn iterate(pixel_data: &mut Vec<PixelData2>, reference: &Reference, reference_current_iteration: usize) {
+impl PerturbationExtended {
+    pub fn iterate(pixel_data: &mut Vec<PixelDataExtended>, reference: &ReferenceExtended, reference_current_iteration: usize) {
         pixel_data.par_chunks_mut(4)
             .for_each(|pixel_data| {
                 for packet in pixel_data {

src/math/perturbation_double.rs

@@ -0,0 +1,47 @@
+use crate::util::{ComplexArbitrary, ComplexFixed, to_fixed};
+
+pub struct ReferenceDouble {
+    pub start_iteration: usize,
+    pub current_iteration: usize,
+    pub maximum_iteration: usize,
+    pub z: ComplexArbitrary,
+    pub c: ComplexArbitrary,
+    pub z_reference: Vec<ComplexFixed<f64>>,
+    pub z_tolerance: Vec<f64>
+}
+
+impl ReferenceDouble {
+    pub fn new(z: ComplexArbitrary, c: ComplexArbitrary, current_iteration: usize, maximum_iteration: usize) -> ReferenceDouble {
+        let z_fixed = to_fixed(&z);
+
+        // 1e-6 is the threshold for pauldelbrot's criterion
+        ReferenceDouble {
+            start_iteration: current_iteration,
+            current_iteration,
+            maximum_iteration,
+            z,
+            c,
+            z_reference: vec![z_fixed],
+            z_tolerance: vec![1e-6 * z_fixed.norm_sqr()]
+        }
+    }
+
+    pub fn step(&mut self) -> bool {
+        self.z = self.z.clone().square() + &self.c;
+        self.current_iteration += 1;
+        let z_fixed = to_fixed(&self.z);
+        self.z_reference.push(z_fixed);
+        self.z_tolerance.push(1e-6 * z_fixed.norm_sqr());
+        z_fixed.norm_sqr() <= 1e256
+    }
+
+
+    pub fn run(&mut self) -> bool {
+        while self.current_iteration < self.maximum_iteration {
+            if !self.step() {
+                break;
+            }
+        };
+        self.current_iteration == self.maximum_iteration
+    }
+}

src/math/perturbation2.rs renamed to src/math/perturbation_extended.rs

@@ -1,6 +1,6 @@
 use crate::util::{ComplexArbitrary, ComplexFixed, to_fixed, to_fixed_exp};
 
-pub struct Reference {
+pub struct ReferenceExtended {
     pub start_iteration: usize,
     pub current_iteration: usize,
     pub maximum_iteration: usize,
@@ -10,8 +10,8 @@ pub struct Reference {
     pub z_tolerance: Vec<f64>
 }
 
-impl Reference {
-    pub fn new(z: ComplexArbitrary, c: ComplexArbitrary, current_iteration: usize, maximum_iteration: usize) -> Reference {
+impl ReferenceExtended {
+    pub fn new(z: ComplexArbitrary, c: ComplexArbitrary, current_iteration: usize, maximum_iteration: usize) -> ReferenceExtended {
         let z_fixed = (to_fixed(&z), 0);
 
         // Stored in premultiplied form
@@ -23,7 +23,7 @@ impl Reference {
         };
 
         // 1e-6 is the threshold for pauldelbrot's criterion
-        Reference {
+        ReferenceExtended {
             start_iteration: current_iteration,
             current_iteration,
             maximum_iteration,
@@ -54,7 +54,6 @@ impl Reference {
         // If the value is not small we do the escape check, otherwise it has not escaped
         // as we do the check for 65536 on the perturbation, we need this to be more than that squared
         z_fixed.0.norm_sqr() <= 1e256
-        // true
     }