Code shared from the Rust Playground

playground.rs

#[allow(unused_imports)]
use std::f64::consts::PI;

/// Represents the output of the Uzumaki function F(n, t)
#[derive(Debug)]
pub struct UzumakiPoint {
    pub radial_scale: f64,
    pub oscillation: f64,
    pub rotation: f64,
}

/// Implements the "Most Illegal Uzumaki" mathematical formula:
/// F(n, t) = [ (n^1.5 / (n + 1000)), sin(0.1n * sin(83.3333t)), 0.1nt ]
pub fn calculate_uzumaki(n: f64, t: f64) -> UzumakiPoint {
    // Term 1: Radial growth/saturation
    let radial_scale = n.powf(1.5) / (n + 1000.0);

    // Term 2: Frequency-modulated oscillation
    // Note: 83.3333 is approximately 250/3
    let inner_oscillation = (83.3333 * t).sin();
    let oscillation = (0.1 * n * inner_oscillation).sin();

    // Term 3: Angular displacement
    let rotation = 0.1 * n * t;

    UzumakiPoint {
        radial_scale,
        oscillation,
        rotation,
    }
}

fn main() {
    let t = 1.0; // Simulated time in seconds
    let steps = 501;

    println!("--- Uzumaki Mathematical State (t = {}) ---", t);
    
    for i in 0..steps {
        let n = i as f64 * 100.0; // Sampling at intervals of 100
        let result = calculate_uzumaki(n, t);
        
        println!("n = {:<4} | Result: {:?}", n, result);
        
        // Example: Convert to Cartesian coordinates (x, y) 
        // using (radial_scale * oscillation) as the radius 'r'
        let r = result.radial_scale * result.oscillation;
        let x = r * result.rotation.cos();
        let y = r * result.rotation.sin();
        
        println!("       -> Cartesian Mapping: (x: {:.4}, y: {:.4})", x, y);
    }
}