Rename primes_list -> prime_list.

Sounds better.

src/candidate.rs

@@ -18,17 +18,39 @@
 
 pub struct CandidateGenerator {
 	base:u64,
+	// first use of the base
 	first_use:bool,
 }
 
 impl CandidateGenerator {
-	pub fn new() -> CandidateGenerator {
+	pub fn new() -> Self {
 		CandidateGenerator {
 			base: 0,
 			first_use: true,
 		}
 	}
 
+	pub fn calc_base(&mut self, last_prime:u64) {
+		if last_prime == 2 {
+			self.base = 0;
+			self.first_use = false;
+		} else if last_prime == 3 {
+			self.base = 6;
+			self.first_use = true;
+		} else {
+			let modulo = last_prime % 6;
+			if modulo == 1 {
+				self.base = last_prime + 5;
+				self.first_use = true;
+			} else if modulo == 5 {
+				self.base = last_prime + 1;
+				self.first_use = false;
+			} else {
+				panic!("Invalid last prime {}" , last_prime);
+			}
+		}
+	}
+
 	pub fn next(&mut self) -> u64 {
 		/*
 		 * All primes, except 2 and 3, will be equal to (n * 6 ± 1). This avoids
@@ -50,12 +72,10 @@ impl CandidateGenerator {
 			}
 		}
 
-		if self.first_use {
-			self.first_use = false;
-		} else {
-			self.first_use = true;
+		if !self.first_use {
 			self.base += 6;
 		}
+		self.first_use = !self.first_use;
 
 		val
 	}

src/main.rs

@@ -47,13 +47,13 @@ struct Opt {
 fn main() {
 	let opts = Opt::from_args();
 
-	let primes_list = Rc::new(RefCell::new(VecDeque::<u64>::new()));
+	let prime_list = Rc::new(RefCell::new(VecDeque::<u64>::new()));
 
 	if opts.import.is_some() {
 		let in_file = File::open(opts.import.unwrap()).unwrap();
 		let reader = BufReader::new(in_file);
 		for p in reader.lines().into_iter() {
-			primes_list.borrow_mut().push_back(p.unwrap().parse().unwrap());
+			prime_list.borrow_mut().push_back(p.unwrap().parse().unwrap());
 		}
 	}
 
@@ -67,18 +67,21 @@ fn main() {
 		process::exit(1);
 	}
 
-	if opts.test && *primes_list.borrow().back().unwrap_or(&0) >= opts.num {
-		for i in primes_list.borrow().iter() {
+	if opts.test && *prime_list.borrow().back().unwrap_or(&0) >= opts.num {
+		for i in prime_list.borrow().iter() {
 			if *i == opts.num {
 				process::exit(0)
 			}
 		}
 		process::exit(1)
-	} else if !opts.test && primes_list.borrow().len() >= opts.num as usize {
-		let res = *primes_list.borrow().get(opts.num as usize).unwrap();
+	} else if !opts.test && prime_list.borrow().len() >= opts.num as usize {
+		let res = *prime_list.borrow().get(opts.num as usize).unwrap();
 		println!("{}", res);
 	} else {
 		let mut cand_gen = CandidateGenerator::new();
+		if !prime_list.borrow().is_empty() {
+			cand_gen.calc_base(*prime_list.borrow().back().unwrap());
+		}
 
 		loop {
 			let cand = cand_gen.next();
@@ -87,7 +90,7 @@ fn main() {
 			}
 
 			let mut is_prime = true;
-			for p in primes_list.borrow().iter() {
+			for p in prime_list.borrow().iter() {
 				if cand % *p == 0 {
 					is_prime = false;
 					break;
@@ -95,25 +98,25 @@ fn main() {
 			}
 
 			if is_prime {
-				primes_list.borrow_mut().push_back(cand);
+				prime_list.borrow_mut().push_back(cand);
 				if opts.verbose {
 					println!("{}", cand);
 				}
 
-				if !opts.test && primes_list.borrow().len() == opts.num as usize {
+				if !opts.test && prime_list.borrow().len() == opts.num as usize {
 					break;
 				}
 			}
 		}
 
 		if opts.test {
-			if *primes_list.borrow().back().unwrap() == opts.num {
+			if *prime_list.borrow().back().unwrap() == opts.num {
 				process::exit(0)
 			} else {
 				process::exit(1)
 			}
 		} else if !opts.verbose {
-			let last_prime = *primes_list.borrow().back().unwrap();
+			let last_prime = *prime_list.borrow().back().unwrap();
 			println!("{}", last_prime);
 		}
 	}

src/worker.rs

@@ -21,13 +21,13 @@ use std::collections::VecDeque;
 use std::rc::Rc;
 
 pub struct Worker {
-	primes_list:Rc<RefCell<VecDeque<u64>>>,
+	prime_list:Rc<RefCell<VecDeque<u64>>>,
 }
 
 impl Worker {
 	pub fn new(primes_list:Rc<RefCell<VecDeque<u64>>>) -> Worker {
 		Worker {
-			primes_list,
+			prime_list: primes_list,
 		}
 	}