Расчет фрактала на Go, Rust, Python

main.rs

@@ -0,0 +1,219 @@
+use std::env;
+use std::ops::{Add, Div, Mul, Sub};
+
+#[derive(Debug, Clone, Copy)]
+struct Complex {
+    re: f64,
+    im: f64,
+}
+
+impl Complex {
+    fn new(re: f64, im: f64) -> Self {
+        Complex { re, im }
+    }
+
+    fn abs(&self) -> f64 {
+        (self.re * self.re + self.im * self.im).sqrt()
+    }
+
+    fn powi(&self, mut n: i32) -> Self {
+        if n == 0 {
+            return Complex::new(1.0, 0.0);
+        }
+        if n < 0 {
+            return Complex::new(1.0, 0.0) / self.powi(-n);
+        }
+
+        let mut base = *self;
+        let mut result = Complex::new(1.0, 0.0);
+
+        while n > 0 {
+            if n % 2 == 1 {
+                result = result * base;
+            }
+            base = base * base;
+            n /= 2;
+        }
+        result
+    }
+}
+
+// === Complex to Complex ===
+impl Add for Complex {
+    type Output = Self;
+    fn add(self, rhs: Self) -> Self::Output {
+        Complex::new(self.re + rhs.re, self.im + rhs.im)
+    }
+}
+
+impl Sub for Complex {
+    type Output = Self;
+    fn sub(self, rhs: Self) -> Self::Output {
+        Complex::new(self.re - rhs.re, self.im - rhs.im)
+    }
+}
+
+impl Mul for Complex {
+    type Output = Self;
+    fn mul(self, rhs: Self) -> Self::Output {
+        Complex::new(
+            self.re * rhs.re - self.im * rhs.im,
+            self.re * rhs.im + self.im * rhs.re,
+        )
+    }
+}
+
+impl Div for Complex {
+    type Output = Self;
+    fn div(self, rhs: Self) -> Self::Output {
+        let denom = rhs.re * rhs.re + rhs.im * rhs.im;
+        Complex::new(
+            (self.re * rhs.re + self.im * rhs.im) / denom,
+            (self.im * rhs.re - self.re * rhs.im) / denom,
+        )
+    }
+}
+
+// === Complex to f64 ===
+impl Add<f64> for Complex {
+    type Output = Self;
+    fn add(self, rhs: f64) -> Self::Output {
+        Complex::new(self.re + rhs, self.im)
+    }
+}
+
+impl Sub<f64> for Complex {
+    type Output = Self;
+    fn sub(self, rhs: f64) -> Self::Output {
+        Complex::new(self.re - rhs, self.im)
+    }
+}
+
+impl Mul<f64> for Complex {
+    type Output = Self;
+    fn mul(self, rhs: f64) -> Self::Output {
+        Complex::new(self.re * rhs, self.im * rhs)
+    }
+}
+
+impl Div<f64> for Complex {
+    type Output = Self;
+    fn div(self, rhs: f64) -> Self::Output {
+        Complex::new(self.re / rhs, self.im / rhs)
+    }
+}
+
+// === f64 to Complex ===
+impl Add<Complex> for f64 {
+    type Output = Complex;
+    fn add(self, rhs: Complex) -> Complex {
+        Complex::new(self + rhs.re, rhs.im)
+    }
+}
+
+impl Sub<Complex> for f64 {
+    type Output = Complex;
+    fn sub(self, rhs: Complex) -> Complex {
+        Complex::new(self - rhs.re, rhs.im)
+    }
+}
+
+impl Mul<Complex> for f64 {
+    type Output = Complex;
+    fn mul(self, rhs: Complex) -> Complex {
+        Complex::new(self * rhs.re, self * rhs.im)
+    }
+}
+
+impl Div<Complex> for f64 {
+    type Output = Complex;
+    fn div(self, rhs: Complex) -> Complex {
+        Complex::new(self, 0.0) / rhs
+    }
+}
+
+#[derive(Debug)]
+struct Args {
+    size: u8,
+    depth: u8,
+    g2: Complex,
+    g3: Complex,
+}
+
+fn parse_args() -> Args {
+    let mut args_struct = Args {
+        size: 128,
+        depth: 8,
+        g2: Complex::new(0.0, 0.0),
+        g3: Complex::new(1.0, 0.0),
+    };
+
+    let args: Vec<String> = env::args().skip(1).collect();
+
+    let mut i = 0;
+    while i < args.len() {
+        match args[i].as_str() {
+            "--size" | "-s" => {
+                if i + 1 < args.len() {
+                    args_struct.size = args[i + 1].parse().unwrap_or(args_struct.size);
+                    i += 1;
+                }
+            }
+            "--depth" | "-d" => {
+                if i + 1 < args.len() {
+                    args_struct.depth = args[i + 1].parse().unwrap_or(args_struct.depth);
+                    i += 1;
+                }
+            }
+            "-g2" => {
+                if i + 1 < args.len() {
+                    let val: f64 = args[i + 1].parse().unwrap_or(args_struct.g2.re);
+                    args_struct.g2 = Complex::new(val, 0.0);
+                    i += 1;
+                }
+            }
+            "-g3" => {
+                if i + 1 < args.len() {
+                    let val: f64 = args[i + 1].parse().unwrap_or(args_struct.g3.re);
+                    args_struct.g3 = Complex::new(val, 0.0);
+                    i += 1;
+                }
+            }
+            _ => {}
+        }
+        i += 1;
+    }
+    args_struct
+}
+
+
+fn main() {
+    let args = parse_args();
+    println!("{}", fractal(args.size, args.depth, args.g2, args.g3));
+}
+
+fn fractal(size: u8, depth: u8, g2: Complex, g3: Complex) -> String {
+    let xi: f64 = -2.0;
+    let yi: f64 = -2.0;
+    let xf: f64 = 2.0;
+    let yf: f64 = 2.0;
+
+    let mut code = String::new();
+
+    for y in 0..=size - 1 {
+        let zy = y as f64 * (yf - yi) / (size as f64 - 1.0) + yi;
+        for x in 0..=size - 1 {
+            let zx = x as f64 * (xf - xi) / (size as f64 - 1.0) + xi;
+            let mut z = Complex::new(zx, zy);
+            for i in 0..=depth - 1 {
+                if z.abs() > 2.0 {
+                    code.push_str(&i.to_string());
+                    break;
+                }
+                z = (z.powi(4) + 0.5 * g2 * z.powi(2) + 2.0 * g3 * z + 1.0 / 16.0 * g2.powi(2))
+                    / (4.0 * z.powi(3) - g2 * z - g3)
+            }
+        }
+    }
+    code
+}