markfuller1 / hubcap Goto Github PK

use std::collections::HashMap;
use std::collections::LinkedList;

fn main(){
// create graph: adjcency list
/*
0: 1,2
1:
2: 3
3:
*/
let mut graph :HashMap<String, Vec> = HashMap::new();
let mut path :LinkedList = LinkedList::new();

graph.insert("0".to_string(), vec!["1".to_string(),"2".to_string()]);
graph.insert("1".to_string(), vec![]);
graph.insert("2".to_string(), vec!["3".to_string()]);
graph.insert("3".to_string(), vec![]);

// search graph to find if node a is reachable by node b
//get start value
let current = "0".to_string();
let destination = "3".to_string();
println!("starting point: {}", current);

// visit the first node,
// graph: is borrowed, dont want to return it to access it again
// current: is borrowed, dont want to return it to access it again
// path: is borrowed and mutable, should change, we are returning it
// destination: is borrowed, dont want to return it to access it again
let solution = visit(&graph, &current, &mut path, &destination);

print!("{:?}", solution)
}

// graph: is borrowed, dont want to return it to access it again
// current: is borrowed, dont want to return it to access it again
// path: is borrowed and mutable, should change, we are returning it
// destination: is borrowed, dont want to return it to access it again
// 'a lifetime of the return type is the same as the graph itself
fn visit<'a>(graph: &'a HashMap<String, Vec>,
node: &String,
mut path: &'a mut LinkedList,
destination: &String) -> &'a mut LinkedList {

println!("visiting {}, with path {:?}", node, path);

// borrowed pointer to the list of neighbors
let neighbors: &Vec = graph.get("0").unwrap();

// clone the current node and add it to the path, path now owns it own copy
path.push_back(node.clone());

//
for neighbor in neighbors {
path = visit(&graph, &neighbor, path, &destination);

if path.len() > 0 {
  if path.back().unwrap() == destination {
    return path;
  }
}

}
path.pop_back();
return path;
}

use std::time::SystemTime;
use std::thread;
use std::thread::JoinHandle;

fn is_prime(n:&u32) -> bool{
if *n <= 2 {
return false;
}
for i in 2..n/2 + 1 {
if n % i == 0 {
return false;
}
}
return true;
}

fn main(){

let max_val:u32 = 10000;

for num_of_groups in 1..6 {
    let now = SystemTime::now();



  // group the numbers between 0 and 10000 into 10 groups
    let mut handles: Vec<JoinHandle<()>> = Vec::with_capacity(usize::try_from(num_of_groups)
                                                            .unwrap());


    let values:Vec<u32> = (0..max_val).map(|x| x).collect();
  
    // println!("{} values", values.len());

  
    let groups:Vec<Vec<u32>> = values.chunks(usize::try_from(max_val / num_of_groups).unwrap())
        .map(|x| x.to_vec())
        .collect();
    
    // println!("{} {} groups", groups.len(), usize::try_from(num_of_groups).unwrap());

  
  for group in groups {
    let func = || {
      for val in group {
        let n:u32 = u32::from(val);
        // println!("{} : {}",val,is_prime(&n));
        is_prime(&n);
      }
    };

    let handle = thread::spawn(func);
    handles.push(handle);
  }
  for n in handles {
    n.join().unwrap();
    // println!("thread done");
  }
    
  println!("group size: {} took : {} millis",num_of_groups, now.elapsed().unwrap().as_millis());

}

}