per/src/main.rs

extern crate ramp;
use ramp::Int;

extern crate num_cpus;
#[macro_use]
extern crate clap;



use clap::App;

use std::thread;
// use std::sync::mpsc;
use std::sync::{Arc, Barrier, RwLock};

use std::time::{Duration, Instant};



trait Peristance {
    fn per_mul(&self) -> u8;
}

trait MyProduct<A = Self> {
    fn product<I: Iterator<Item=A>>(iter: I) -> Self;
}

impl MyProduct<Int> for Int {
    fn product<I: Iterator<Item=Self>>(iter: I) -> Int {
        iter.fold(Int::one(), <ramp::Int as Trait>::Mul)
    }
}


impl Peristance for Int {
    fn per_mul(&self) -> u8 {
        let mut n = self.to_str_radix(10, false)
            .chars()
            .map(|x| x - 48).collect()
            .product::<Int>();
        let mut counter = 1;
        while n.to_str_radix(10, false).chars().count() > 1 {
            n = n.to_str_radix(10, false)
                .chars()
                .map(|x| x - 48).collect()
                .product::<Int>();
            counter += 1;
        }
        return counter;
    }
}


#[derive(Debug)]
struct Counter {
    count: Int,
    step: u8,
    offset: u8
}

impl Counter {
    fn new(_step: u8, _offset: u8) -> Counter {
        Counter {count: Int::zero(), step: _step, offset: _offset}
    }
}

impl Iterator for Counter {
    type Item = Int;

    fn next(&mut self) -> Option<Int> {
        // Increment our count. This is why we started at zero.
        self.count += self.step;
        Some(self.count.clone())
    }
}

fn main() {
    let start = Instant::now();


    let args = App::new("Persistance")
        .version("0.2.0")
        .author("Daniel Olsen")
        .about("Finds the sequence of smallest number with a multiplicative persistance of n")
        .args_from_usage("-j, --jobs=[threads] 'Sets the number of worker threads to spin up, if 0 or empty this equals the number of cores on your system (INCLUDING HYPERTHREADS)'
                         -m, --max=[max] 'Sets the maximum n you want to calculate'")
        .get_matches();


    let mut cpus = value_t!(args, "jobs", u8).unwrap_or(num_cpus::get() as u8);
    if cpus == 0 {
        cpus = num_cpus::get() as u8;
    }
    let cpus = cpus;

    let max = value_t!(args, "max", u8).unwrap_or(11u8);

    println!("threads: {}", cpus);

    let barrier = Arc::new(Barrier::new(2));
    for thread in 0..(cpus) {
        let c = barrier.clone();
        thread::spawn(move || {
            println!("Started thread {}!", thread);
            let counter =  Counter::new(cpus-thread, cpus);
            let mut top: u8 = 0;
            for x in counter {
                let n = x.per_mul();
                if n > top {
                    top = n;
                    println!("{:?}  {} - {}: {}", start.elapsed(), thread, n, x);
                    if n > max-1 {
                        c.wait();
                        return;
                    }
                }
            }
        });
    }
    barrier.wait();

    println!("Finding took {:#?}", start.elapsed());
    return;
}