Format code

Author: terasakisatoshi

benches/benchmarks.rs

@@ -4,7 +4,7 @@ use criterion::{black_box, criterion_group, criterion_main, Criterion};
 use rand::SeedableRng;
 use rand_xoshiro::Xoshiro256PlusPlus;
 
-use rust_random_logo::{Config, render, rand_sigma_factor_ifs};
+use rust_random_logo::{rand_sigma_factor_ifs, render, Config};
 
 fn bench_generate_ifs(c: &mut Criterion) {
     c.bench_function("generate_ifs", |b| {

examples/basic.rs

@@ -1,10 +1,10 @@
 //! Basic example of using the rust-random-logo library
 
-use std::path::PathBuf;
 use rand::SeedableRng;
 use rand_xoshiro::Xoshiro256PlusPlus;
+use std::path::PathBuf;
 
-use rust_random_logo::{Config, render, rand_sigma_factor_ifs};
+use rust_random_logo::{rand_sigma_factor_ifs, render, Config};
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
     // Create a random number generator with a seed

examples/grid.rs

@@ -3,12 +3,12 @@
 //! This example generates 25 different fractal images with different seeds
 //! and arranges them in a 5x5 grid, saving the result as a single large image.
 
-use std::path::PathBuf;
+use image::ImageBuffer;
 use rand::SeedableRng;
 use rand_xoshiro::Xoshiro256PlusPlus;
-use image::ImageBuffer;
+use std::path::PathBuf;
 
-use rust_random_logo::{Config, render, rand_sigma_factor_ifs};
+use rust_random_logo::{rand_sigma_factor_ifs, render, Config};
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
     // Configuration for each fractal
@@ -31,7 +31,12 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     let grid_height = base_config.height * grid_rows;
     let mut grid_image = ImageBuffer::new(grid_width as u32, grid_height as u32);
 
-    println!("Generating {} fractals for a {}x{} grid...", grid_rows * grid_cols, grid_rows, grid_cols);
+    println!(
+        "Generating {} fractals for a {}x{} grid...",
+        grid_rows * grid_cols,
+        grid_rows,
+        grid_cols
+    );
 
     // Generate fractals and place them in the grid
     for row in 0..grid_rows {
@@ -51,7 +56,12 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
             let ifs = rand_sigma_factor_ifs(&mut rng);
 
             // Render the fractal
-            println!("  Rendering fractal {}/{} with seed {}...", index + 1, grid_rows * grid_cols, seed);
+            println!(
+                "  Rendering fractal {}/{} with seed {}...",
+                index + 1,
+                grid_rows * grid_cols,
+                seed
+            );
             let fractal = render(rng, &ifs, &config);
 
             // Calculate the position in the grid

src/core/config.rs

@@ -3,9 +3,9 @@
 //! This module provides the Config struct and related functions for loading
 //! configuration from TOML files.
 
+use serde::{Deserialize, Serialize};
 use std::fs;
 use std::path::Path;
-use serde::{Deserialize, Serialize};
 use toml;
 
 use crate::error::Result;

src/core/ifs.rs

@@ -4,9 +4,9 @@
 //! The implementation is based on the SVD approach proposed in the
 //! [Improving Fractal Pre-training](http://catalys1.github.io/fractal-pretraining/) paper.
 
-use nalgebra::{Matrix2, Vector2, Rotation2};
-use rand::Rng;
+use nalgebra::{Matrix2, Rotation2, Vector2};
 use rand::distributions::{Distribution, WeightedIndex};
+use rand::Rng;
 
 use crate::core::affine::Affine;
 use crate::core::types::{Matrix2f, Vector2f, IFS};
@@ -36,8 +36,15 @@ impl SigmaFactorIFS {
     ///
     /// A new SigmaFactorIFS
     pub fn new(transforms: Vec<Affine>, weights: Vec<f64>) -> Self {
-        assert_eq!(transforms.len(), weights.len(), "Number of transforms must match number of weights");
-        Self { transforms, weights }
+        assert_eq!(
+            transforms.len(),
+            weights.len(),
+            "Number of transforms must match number of weights"
+        );
+        Self {
+            transforms,
+            weights,
+        }
     }
 }
 
@@ -71,26 +78,26 @@ pub fn sample_svs<R: Rng>(rng: &mut R, alpha: f64, n: usize) -> Vec<(f64, f64)>
     let mut b_upper = alpha;
 
     // Sample n-1 pairs
-    for _ in 0..(n-1) {
+    for _ in 0..(n - 1) {
         // Define sigma1
         let sigma1 = uniform(rng, f64::max(0.0, b_lower / 3.0), f64::min(1.0, b_upper));
         b_lower = b_lower - sigma1;
         b_upper = b_upper - sigma1;
 
         // Define sigma2
-        let sigma2 = uniform(rng, f64::max(0.0, 0.5 * b_lower), f64::min(sigma1, 0.5 * b_upper));
+        let sigma2 = uniform(
+            rng,
+            f64::max(0.0, 0.5 * b_lower),
+            f64::min(sigma1, 0.5 * b_upper),
+        );
         b_lower = b_lower - 2.0 * sigma2 + 3.0;
         b_upper = b_upper - 2.0 * sigma2;
 
         result.push((sigma1, sigma2));
     }
 
     // Last pair
-    let sigma2 = uniform(
-        rng,
-        f64::max(0.0, 0.5 * (b_upper - 1.0)),
-        b_upper / 3.0,
-    );
+    let sigma2 = uniform(rng, f64::max(0.0, 0.5 * (b_upper - 1.0)), b_upper / 3.0);
     let sigma1 = b_upper - 2.0 * sigma2;
     result.push((sigma1, sigma2));
 
@@ -173,9 +180,7 @@ pub fn rand_sigma_factor_ifs<R: Rng>(rng: &mut R) -> SigmaFactorIFS {
     }
 
     // Create probability weights based on determinants
-    let mut weights: Vec<f64> = transforms.iter()
-        .map(|t| t.determinant().abs())
-        .collect();
+    let mut weights: Vec<f64> = transforms.iter().map(|t| t.determinant().abs()).collect();
 
     // Normalize weights
     let sum: f64 = weights.iter().sum();

src/core/mod.rs

@@ -2,15 +2,15 @@
 // This module contains the core components for generating fractal images
 
 pub mod affine;
+pub mod config;
 pub mod ifs;
-pub mod types;
 pub mod renderer;
-pub mod config;
+pub mod types;
 pub mod utils;
 
 // Re-export commonly used items
 pub use affine::Affine;
-pub use ifs::{SigmaFactorIFS, sample_svs, rand_sigma_factor_ifs};
-pub use types::*;
-pub use renderer::{generate_points, render};
 pub use config::Config;
+pub use ifs::{rand_sigma_factor_ifs, sample_svs, SigmaFactorIFS};
+pub use renderer::{generate_points, render};
+pub use types::*;

src/core/renderer.rs

@@ -96,11 +96,7 @@ fn normalize_points(xs: &mut Vec<f64>, ys: &mut Vec<f64>, height: usize, width:
 /// # Returns
 ///
 /// An RGB image
-pub fn render<R: Rng + Clone>(
-    mut rng: R,
-    ifs: &SigmaFactorIFS,
-    config: &Config,
-) -> RgbImage {
+pub fn render<R: Rng + Clone>(mut rng: R, ifs: &SigmaFactorIFS, config: &Config) -> RgbImage {
     let height = config.height;
     let width = config.width;
     let npoints = config.npoints;
@@ -141,17 +137,28 @@ pub fn render_from_config(config: &Config) -> Result<RgbImage> {
 
     // Validate IFS configuration
     if config.ifs_name != "SigmaFactorIFS" {
-        return Err(Error::ConfigError(format!("Unknown IFS: {}", config.ifs_name)));
+        return Err(Error::ConfigError(format!(
+            "Unknown IFS: {}",
+            config.ifs_name
+        )));
     }
 
     if config.ndims != 2 {
-        return Err(Error::ConfigError(format!("Unsupported dimension: {}", config.ndims)));
+        return Err(Error::ConfigError(format!(
+            "Unsupported dimension: {}",
+            config.ndims
+        )));
     }
 
     // Create RNG
     let mut rng = match config.rng_name.as_str() {
         "Xoshiro256PlusPlus" => Xoshiro256PlusPlus::seed_from_u64(config.seed),
-        _ => return Err(Error::ConfigError(format!("Unknown RNG: {}", config.rng_name))),
+        _ => {
+            return Err(Error::ConfigError(format!(
+                "Unknown RNG: {}",
+                config.rng_name
+            )))
+        }
     };
 
     // Create IFS

src/error.rs

@@ -1,7 +1,7 @@
 //! Error types for the rust-random-logo library
 
-use thiserror::Error;
 use std::io;
+use thiserror::Error;
 
 /// Error type for the rust-random-logo library
 #[derive(Error, Debug)]

src/lib.rs

@@ -32,7 +32,7 @@ pub mod error;
 
 // Re-export commonly used items
 pub use core::affine::Affine;
-pub use core::ifs::{SigmaFactorIFS, sample_svs, rand_sigma_factor_ifs};
 pub use core::config::Config;
+pub use core::ifs::{rand_sigma_factor_ifs, sample_svs, SigmaFactorIFS};
 pub use core::renderer::{generate_points, render, render_from_config};
 pub use error::{Error, Result};

src/main.rs

@@ -4,7 +4,7 @@ use std::env;
 use std::path::PathBuf;
 use std::process;
 
-use rust_random_logo::{Config, render_from_config};
+use rust_random_logo::{render_from_config, Config};
 
 fn main() {
     // Parse command-line arguments