Merge branch 'development' of https://github.com/jackyarndley/rust-fractal into development

Author: jackyarndley

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "rust_fractal"
-version = "0.2.0"
+version = "0.3.0"
 authors = ["jackyarndley <34801340+jackyarndley@users.noreply.github.com>"]
 description = "Fast, efficient mandelbrot set renderer."
 edition = "2018"

Cargo.toml

@@ -0,0 +1 @@
+Investigate why j22522 is not rendering coorrectly

TODO.md

@@ -1,3 +1,3 @@
 image_width = 1000
 image_height = 1000
-frames = 50
+frames = 99999

default.toml

@@ -6,22 +6,22 @@ use crate::math::reference::Reference;
 pub struct Perturbation {}
 
 impl Perturbation {
-    pub fn iterate(pixel_data: &mut Vec<PixelData>, reference: &Reference, reference_current_iteration: usize) {
+    pub fn iterate(pixel_data: &mut Vec<PixelData>, reference: &Reference) {
         pixel_data.par_chunks_mut(8)
             .for_each(|pixel_data| {
                 for pixel in pixel_data {
                     let mut scaled_iterations = 0;
                     let mut scaled_scale_factor_1 = 1.0f64.ldexp(pixel.delta_current.exponent);
                     let mut scaled_delta_reference = 1.0f64.ldexp(pixel.delta_reference.exponent - pixel.delta_current.exponent) * pixel.delta_reference.mantissa;
 
-                    while pixel.iteration < reference_current_iteration {
+                    while pixel.iteration < reference.current_iteration {
                         let delta_current_float = scaled_scale_factor_1 * pixel.delta_current.mantissa;
 
                         if pixel.delta_current.exponent > -500 {
-                            let z_norm = (reference.data[pixel.iteration - reference.start_iteration].z_fixed + delta_current_float).norm_sqr();
+                            let z_norm = (reference.perturbation_data[pixel.iteration - reference.start_iteration].z_fixed + delta_current_float).norm_sqr();
                             // let z_norm = (reference.data[pixel.iteration - reference.start_iteration].z_fixed + pixel.delta_current.to_float()).norm_sqr();
 
-                            if z_norm < reference.data[pixel.iteration - reference.start_iteration].z_tolerance {
+                            if z_norm < reference.perturbation_data[pixel.iteration - reference.start_iteration].z_tolerance {
                                 pixel.glitched = true;
                                 break;
                             }
@@ -34,7 +34,7 @@ impl Perturbation {
                             }
                         }
 
-                        match reference.data[pixel.iteration - reference.start_iteration].z_extended {
+                        match reference.perturbation_data[pixel.iteration - reference.start_iteration].z_extended {
                             // If the reference is small, use the slow extended method
                             Some(z_extended) => {
                                 // do the slow 
@@ -53,13 +53,15 @@ impl Perturbation {
                             None => {
                                 // pixel.delta_current.mantissa = 2.0 * reference.data[pixel.iteration - reference.start_iteration].z_fixed * pixel.delta_current.mantissa + temp * pixel.delta_current.mantissa + scaled_delta_reference;
 
-                                pixel.delta_current.mantissa *= 2.0 * reference.data[pixel.iteration - reference.start_iteration].z_fixed + delta_current_float;
+                                pixel.delta_current.mantissa *= 2.0 * reference.perturbation_data[pixel.iteration - reference.start_iteration].z_fixed + delta_current_float;
                                 pixel.delta_current.mantissa += scaled_delta_reference;
 
                                 scaled_iterations += 1;
 
                                 // check the counter, if it is > 250, do a normalisation
                                 if scaled_iterations > 250 {
+                                    pixel.delta_current.reduce();
+
                                     scaled_scale_factor_1 = 1.0f64.ldexp(pixel.delta_current.exponent);
                                     scaled_delta_reference = 1.0f64.ldexp(pixel.delta_reference.exponent - pixel.delta_current.exponent) * pixel.delta_reference.mantissa;
 

j22522.toml

@@ -1,14 +1,20 @@
 use crate::util::{ComplexArbitrary, ComplexFixed, ComplexExtended, to_fixed, to_extended};
 
+#[derive(Clone)]
 pub struct Reference {
     pub start_iteration: usize,
     pub current_iteration: usize,
     pub maximum_iteration: usize,
     pub z: ComplexArbitrary,
     pub c: ComplexArbitrary,
-    pub data: Vec<ReferenceIteration>
+    pub perturbation_data: Vec<ReferenceIteration>,
+    pub approximation_data: Vec<ComplexExtended>,
+    // This is for every 100th iteration, when we do glitch correction the new references will be spawed from these values
+    // Storing every iteration is memory intensive.
+    pub high_precision_data: Vec<ComplexArbitrary>
 }
 
+#[derive(Clone)]
 pub struct ReferenceIteration {
     pub z_fixed: ComplexFixed<f64>,
     pub z_extended: Option<ComplexExtended>,
@@ -23,7 +29,9 @@ impl Reference {
             maximum_iteration,
             z,
             c,
-            data: Vec::with_capacity(1000)
+            perturbation_data: Vec::with_capacity(1000),
+            approximation_data: Vec::with_capacity(1000),
+            high_precision_data: Vec::with_capacity(1000)
         }
     }
 
@@ -35,20 +43,21 @@ impl Reference {
         let z_fixed = to_fixed(&self.z);
         let z_tolerance = 1e-6 * z_fixed.norm_sqr();
 
+        let mut z_extended = to_extended(&self.z);
+        z_extended.reduce();
+
         // This is if we need to use the extended precision for the reference
         if z_fixed.re.abs() < 1e-300 && z_fixed.im.abs() < 1e-300 {
             // println!("found slow at: {}", self.current_iteration);
-            let mut temp = to_extended(&self.z);
-            temp.reduce();
-            self.data.push(
+            self.perturbation_data.push(
                 ReferenceIteration {
                     z_fixed,
-                    z_extended: Some(temp),
+                    z_extended: Some(z_extended),
                     z_tolerance
                 }
             )
         } else {
-            self.data.push(
+            self.perturbation_data.push(
                 ReferenceIteration {
                     z_fixed,
                     z_extended: None,
@@ -57,27 +66,32 @@ impl Reference {
             )
         }
 
+        self.approximation_data.push(z_extended);
+
         // 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.norm_sqr() <= 1e256
     }
 
 
-    pub fn run(&mut self) -> bool {
+    pub fn run(&mut self) {
         let z_fixed = to_fixed(&self.z);
         let z_tolerance = 1e-6 * z_fixed.norm_sqr();
 
+        let mut z_extended = to_extended(&self.z);
+        z_extended.reduce();
+
         // This is if we need to use the extended precision for the reference
         if z_fixed.re.abs() < 1e-300 && z_fixed.im.abs() < 1e-300 {
-            self.data.push(
+            self.perturbation_data.push(
                 ReferenceIteration {
                     z_fixed,
-                    z_extended: Some(to_extended(&self.z)),
+                    z_extended: Some(z_extended),
                     z_tolerance
                 }
             )
         } else {
-            self.data.push(
+            self.perturbation_data.push(
                 ReferenceIteration {
                     z_fixed,
                     z_extended: None,
@@ -86,13 +100,28 @@ impl Reference {
             )
         }
 
-        while self.current_iteration < self.maximum_iteration {
-            if !self.step() {
-                break;
-            }
-        };
+        // only needed on central reference
+        self.approximation_data.push(z_extended);
+
+        if self.start_iteration == 1 {
+            // Add the first value for iterations 0-100
+            self.high_precision_data.push(self.z.clone());
 
-        self.current_iteration == self.maximum_iteration
+            while self.current_iteration < self.maximum_iteration {
+                if !self.step() {
+                    break;
+                };
+                if self.current_iteration % 100 == 1 {
+                    self.high_precision_data.push(self.z.clone());
+                }
+            };
+        } else {
+            while self.current_iteration < self.maximum_iteration {
+                if !self.step() {
+                    break;
+                };
+            };
+        }
     }
 }