Blowing in the wind

use rppal::spi::{Bus, Mode, SlaveSelect, Spi};
use std::thread;
use std::time::Duration;

const CHANNEL_0: u8 = 0x06 | 0x00; // Command byte for single-ended mode

fn main() {
    // Create a SPI object
    let spi = Spi::new(Bus::Spi0, SlaveSelect::Ss0, 1_000_000, Mode::Mode0).unwrap();

    // Define the buffers for reading and writing
    let mut read_buffer = [0u8; 3];
    let write_buffer = [CHANNEL_0, 0x00, 0x00];

    // Poll the sensor every n seconds
    let poll_rate = Duration::from_secs(1);
    loop {
        // Perform the SPI transfer
        spi.transfer(&mut read_buffer, &write_buffer).unwrap();

        // Extract the 12-bit ADC value
        // Note: MCP3204 returns 12-bit data, but the second byte contains status bit(0) and the MSB of the result.
        let msb = (read_buffer[1] & 0x0F) as u16;
        let lsb = read_buffer[2] as u16; // Convert third byte to u16
        let result = (msb << 8) | lsb;

        println!("Sensor value: {}", result);      

        println!("{:08b}, {:08b}", read_buffer[1], read_buffer[2]);

        thread::sleep(poll_rate);
    }
}

[dependencies]
rppal = "0.19.0"

$ ./adc_rppal
Sensor value: 2867
00001011, 00110011
Sensor value: 2867
00001011, 00110011
Sensor value: 2867
00001011, 00110011
Sensor value: 2867
00001011, 00110011
Sensor value: 2868
00001011, 00110100

    // absolute value calc
    let y: Vec<f32> = buffer.iter().map(|z| z.norm().log(10.0)*20.0).collect();

use plotters::prelude::*;
use rustfft::{num_complex::Complex, FftPlanner};
use std::f32::consts::PI;
use std::time::Instant;

const N: usize = 256; // FFT size
const SAMPLE_RATE: f32 = 256.0; // sampling rate
const INPUT_FREQ: f32 = 20.0; // input frequency

fn complex_vector_with_hanning(length: usize, dt: f32, frequency: f32) -> Vec<Complex<f32>> {
    (0..length)
        .map(|i| {
            let t = i as f32 * dt;
            let phase = frequency * 2.0 * PI * t;
            let phase2 = 3.0 * frequency * 2.0 * PI * t;
            Complex::new(
                (f32::sin(phase) + f32::sin(phase2)) * 0.5 * (1.0 - f32::cos(2.0 * PI * t)),
                0.0,
            )
        })
        .collect()
}

fn re_vector(complex_numbers: Vec<Complex<f32>>) -> Vec<f32> {
    complex_numbers.iter().map(|z| z.re).collect()
}

fn draw(
    x: Vec<usize>,
    y: Vec<f32>,
    f_name: &str,
    cap: &str,
) -> Result<(), Box<dyn std::error::Error>> {
    let image_width = 1080;
    let image_height = 720;

    let root = BitMapBackend::new(f_name, (image_width, image_height)).into_drawing_area();

    root.fill(&WHITE)?;

    //   https://qiita.com/lo48576/items/343ca40a03c3b86b67cb
    let (y_min, y_max) = y
        .iter()
        .fold((0.0 / 0.0, 0.0 / 0.0), |(m, n), v| (v.min(m), v.max(n)));

    let caption = cap;
    let font = (“sans-serif”, 20);

    let mut chart = ChartBuilder::on(&root)
        .caption(caption, font.into_font())
        .margin(10)
        .x_label_area_size(16)
        .y_label_area_size(42)
        .build_cartesian_2d(*x.first().unwrap()..*x.last().unwrap(), y_min..y_max)?;

    chart.configure_mesh().draw()?;

    let line_series = LineSeries::new(x.iter().zip(y.iter()).map(|(x, y)| (*x, *y)), &RED);
    chart.draw_series(line_series)?;

    Ok(())
}

fn main() {
    // fft data preparation with window
    let sr = 1.0 / SAMPLE_RATE;

    let mut buffer = complex_vector_with_hanning(N, sr, INPUT_FREQ);
 
    // draw input signal
    let buf_re = re_vector(buffer.clone());

    let n = N;
    let f_input = “plot_input.png”;
    let cap = “fft input”;
    let x: Vec<usize> = (1..=n).collect();

    let _ = draw(x, buf_re, &f_input, &cap);

    // fft mode setting
    let mut planner: FftPlanner<f32> = FftPlanner::new();
    let fft = planner.plan_fft_forward(N);

    let start_time = Instant::now();
    
    // fft exec
    fft.process(&mut buffer);

    let end_time = Instant::now();
    println!(“Elapsed time for FFT: {:?}”, end_time.duration_since(start_time));

    // absolute value calc
    let y: Vec<f32> = buffer.iter().map(|z| z.norm()).collect();

    // draw fft graph output
    let n = N;
    let file_fft = “plot_fft_hanning.png”;
    let cap = “fft hanning result”;
    let x: Vec<usize> = (1..=n).collect();
    let _ = draw(x, y, &file_fft, &cap);

}

// Computes a forward FFT
//
use plotters::prelude::*;
use rustfft::{num_complex::Complex, FftPlanner};
use std::f32::consts::PI;
use std::time::Instant;

const N: usize = 512; // FFT size
const SAMPLE_RATE: f32 = 256.0; // sampling rate
const INPUT_FREQ: f32 = 20.0; // input frequency

// prepare target data
fn complex_vector(length: usize, dt: f32, frequency: f32) -> Vec<Complex<f32>> {
    (0..length)
        .map(|i| {
            let t = i as f32 * dt;
            let phase = frequency * 2.0 * PI * t;
            let phase2 = 3.0 * frequency * 2.0 * PI * t;
            Complex::new(phase.sin() + phase2.sin(), 0.0)
        })
        .collect()
}

fn re_vector(complex_numbers: Vec<Complex<f32>>) -> Vec<f32> {
    complex_numbers.iter().map(|z| z.re).collect()
}

fn draw(x: Vec<usize>, y: Vec<f32>, f_name: &str, cap: &str) -> Result<(), Box<dyn std::error::Error>> {
    let image_width = 1080;
    let image_height = 720;

    let root = BitMapBackend::new(f_name, (image_width, image_height)).into_drawing_area();

    root.fill(&WHITE)?;

    //   https://qiita.com/lo48576/items/343ca40a03c3b86b67cb
    let (y_min, y_max) = y
        .iter()
        .fold((0.0 / 0.0, 0.0 / 0.0), |(m, n), v| (v.min(m), v.max(n)));

    let caption = cap;
    let font = ("sans-serif", 20);

    let mut chart = ChartBuilder::on(&root)
        .caption(caption, font.into_font())
        .margin(10)
        .x_label_area_size(16)
        .y_label_area_size(42)
        .build_cartesian_2d(*x.first().unwrap()..*x.last().unwrap(), y_min..y_max)?;

    chart.configure_mesh().draw()?;

    let line_series = LineSeries::new(x.iter().zip(y.iter()).map(|(x, y)| (*x, *y)), &RED);
    chart.draw_series(line_series)?;

    Ok(())
}

fn main() {
    // fft data preparation
    let sr = 1.0 / SAMPLE_RATE;
    let mut buffer = complex_vector(N, sr, INPUT_FREQ);

    // draw input signal
    let buf_re = re_vector(buffer.clone());

    let n = N;
    let f_input = "plot_input.png";
    let cap = "fft input";
    let x: Vec<usize> = (1..=n).collect();
    let _ = draw(x, buf_re, &f_input, &cap);

    // fft mode setting
    let mut planner = FftPlanner::new();
    let fft = planner.plan_fft_forward(N);

    let start_time = Instant::now();
    // fft exec
    fft.process(&mut buffer);

    let end_time = Instant::now();
    println!("Elapsed time: {:?}", end_time.duration_since(start_time));

    // absolute value calc
    let y: Vec<f32> = buffer.iter().map(|z| z.norm()).collect();

    // drwa fft graph output
    let n = N;
    let file_fft = "plot_fft.png";
    let cap = "fft result";
    let x: Vec<usize> = (1..=n).collect();
    let _ = draw(x, y, &file_fft, &cap);

    // ifft exec
    let ifft = planner.plan_fft_inverse(N);
    ifft.process(&mut buffer);
    // get complex:re
    let y = re_vector(buffer);

    // ifft graph output
    let n = N;
    let file_ifft = "plot_ifft.png";
    let cap = "ifft result";
    let x: Vec<usize> = (1..=n).collect();
    let _ = draw(x, y, &file_ifft, &cap);

}

use std::time::Instant;

fn is_prime(num: u64) -> bool {
    if num <= 1 {
        return false;
    }
    if num <= 3 {
        return true;
    }
    if num % 2 == 0 || num % 3 == 0 {
        return false;
    }

    let mut i = 5;
    while i * i <= num {
        if num % i == 0 || num % (i + 2) == 0 {
            return false;
        }
        i += 6;
    }

    true
}

fn find_primes(start: u64, end: u64) {
    let mut pri: Vec = Vec::new();
    let start_time = Instant::now();
    for num in start..=end {
        if is_prime(num) {
            pri.push(num);
        }
    }
    let end_time = Instant::now();
    println!("Elapsed time: {:?}", end_time.duration_since(start_time));
    println!("number of primes: {}", pri.len());
}

fn main() {
    let start = 2;
    let end = 1000_000;

    println!("{}から{}までの素数:", start, end);
    find_primes(start, end);
}

use rayon::prelude::*;
use std::time::Instant;

fn is_prime(num: u64) -> bool {
    if num <= 1 {
        return false;
    }
    if num <= 3 {
        return true;
    }
    if num % 2 == 0 || num % 3 == 0 {
        return false;
    }

    let mut i = 5;
    while i * i <= num { if num % i == 0 || num % (i + 2) == 0 { return false; } i += 6; } true } fn find_primes_multithreaded(start: u64, end: u64) -> Vec {
    (start..=end)
        .into_par_iter()
        .filter(|num| is_prime(*num))
        .collect()
}

fn main() {
    let start = 2;
    let end = 1000_000;

    println!("{}から{}までの素数:", start, end);

    let start_time = Instant::now();
    let primes = find_primes_multithreaded(start, end);
    let end_time = Instant::now();

    println!("Elapsed time: {:?}", end_time.duration_since(start_time));
    println!("number of primes: {}", primes.len());
}

<Geminiで生成したシングルスレッド版 : release mode>
2から1000000までの素数:
Elapsed time: 37.51125ms


rayon::tierクレートのinto_par_iter()メソッドでマルチスレッド対応のiteratorが作れるということ、

<Geminiで生成したマルチスレッド版 : release mode>
2から1000000までの素数:
Elapsed time: 7.397958ms

use std::sync::{Arc, Mutex};
use std::time::Instant;

fn main() {
    let start_time = Instant::now();
    let num = find_primes(2, 10000 * 100);
    println!("{}",num.len());
    let end_time = Instant::now();
    println!("Elapsed time: {:?}", end_time.duration_since(start_time));
}

fn find_primes(start: i32, end: i32) -> Vec<i32>{
    let counter = Arc::new(Mutex::new(start)); // Shared counter for prime candidates

    let mut value = Vec::new();
    let counter_clone = counter.clone();

    loop {
        let c = counter_clone.lock().unwrap().clone();
        if c > end {
            break;
        }

        let mut flag = true;
        for j in 2..((c as f64).sqrt() as i32 + 1) {
            if c % j == 0 {
                flag = false;
                break;
            }
        }

        if flag {
            value.push(c);
        }

        *counter_clone.lock().unwrap() += 1;
    }
    value
}

@MacBook Air M1

<Golangでの百万までの素数計算>
78498	; 素数の数
440.783125ms　; 実行時間

<rust build>
78498
Elapsed time: 508.7235ms

<rust release>
78498
Elapsed time: 91.830167ms


@Raspberry pi zero W
<rust build>
78498
Elapsed time: 18.59699031s

<rust release>
78498
Elapsed time: 7.10051562s