Add getNumPrimes

src/Algorithms.rs

@@ -1,7 +1,7 @@
 extern crate num;
 
 
-//
+//This function returns a list of all Fibonacci numbers <= goalNumber
 pub fn getAllFib(goalNumber: u64) -> Vec<u64>{
 	let mut fibNums = Vec::new();	//A list to save the Fibonacci numbers
 	//If the number is <= 0 return an empty list
@@ -21,8 +21,6 @@ pub fn getAllFib(goalNumber: u64) -> Vec<u64>{
 	fibNums.remove(fibNums.len() - 1);
 	return fibNums;
 }
-
-//
 pub fn getAllFibBig(goalNumber: num::BigInt) -> Vec<num::BigInt>{
 	let mut fibNums = Vec::new();	//A list to save the Fibonacci numbers in
 	//If the number is <= 0 return an empty list
@@ -42,7 +40,7 @@ pub fn getAllFibBig(goalNumber: num::BigInt) -> Vec<num::BigInt>{
 	return fibNums;
 }
 
-//Ths function returns all factors of goalNumber
+//This function returns all factors of goalNumber
 pub fn getFactors(mut goalNumber: i64) -> Vec<i64>{
 	//You need to get all the primes that could be factors of this number so you can test them
 	let topPossiblePrime = (goalNumber as f64).sqrt().ceil() as i64;
@@ -207,3 +205,101 @@ pub fn getPrimesBig(goalNumber: num::BigInt) -> Vec<num::BigInt>{
 	primes.sort();
 	return primes;
 }
+
+//This function gets a certain number of primes
+pub fn getNumPrimes(numberOfPrimes: i64) -> Vec<i64>{
+	let mut primes = Vec::<i64>::new();	//Holds the prime numbers
+	let mut foundFactor = false;	//A flag for whether a factor of the current number has been found
+
+	//If the number is 0 or negative return an empty list
+	if(numberOfPrimes <= 0){
+		return primes;
+	}
+	//Otherwise the number is at least 2, so 2 should be added to the list
+	else{
+		primes.push(2);
+	}
+
+	//We can now start at 3 and skip all even numbers, because the cannot be prime
+	let mut possiblePrime = 3;
+	while((primes.len() as i64) < numberOfPrimes){
+		//Check all current primes, up to sqrt)possiblePrime), to see if there is a divisor
+		let topPossibleFactor = (possiblePrime as f64).sqrt().ceil() as i64;
+		//We can safely assume that there will be at least 1 element in primes list because of 2 being added before this
+		let mut primesCnt = 0;
+		while(primes[primesCnt] <= topPossibleFactor){
+			if((possiblePrime as i64 % primes[primesCnt]) == 0){
+				foundFactor = true;
+				break;
+			}
+			else{
+				primesCnt += 1;
+			}
+			//Check if the index has gone out of range
+			if(primesCnt >= primes.len()){
+				break;
+			}
+		}
+		//If you didn't find a factor then the current number must be prime
+		if(!foundFactor){
+			primes.push(possiblePrime as i64);
+		}
+		else{
+			foundFactor = false;
+		}
+		possiblePrime += 2;
+	}
+
+	//Sort the list before returning it
+	primes.sort();
+	return primes;
+}
+pub fn getNumPrimesBig(numberOfPrimes: num::BigInt) -> Vec<num::BigInt>{
+	let mut primes = Vec::<num::BigInt>::new();	//Holds the prime numbers
+	let mut foundFactor = false;	//A flag for whether a factor of the current number has been found
+
+	//If the number is 0 or negative return an empty list
+	if(numberOfPrimes <= num::BigInt::from(1)){
+		return primes;
+	}
+	//Otherwise the number is at least 2, so 2 should be added to the list
+	else{
+		primes.push(num::BigInt::from(2));
+	}
+
+	//We can now start at 3 and skip all even numbers, because they cannot be prime
+	let mut possiblePrime = num::BigInt::from(3);
+	while(numberOfPrimes > num::BigInt::from(primes.len())){
+		//Check all current primes, up to sqrt(possiblePrime), to see if there is a divisor
+		let topPossibleFactor = ((&possiblePrime).sqrt() + num::BigInt::from(1));
+		//We can safely assume that there will be at least 1 element in the primes list because of 2 being added before this
+		let mut primesCnt = 0;
+		while(primes[primesCnt] <= topPossibleFactor){
+			if((&possiblePrime % &primes[primesCnt]) == num::BigInt::from(0)){
+				foundFactor = true;
+				break;
+			}
+			else{
+				primesCnt += 1;
+			}
+			//Check if the index has gone out of bounds
+			if(primesCnt >= primes.len()){
+				break;
+			}
+		}
+
+		//If you didn't find a factor then the current number must be prime
+		if(!foundFactor){
+			primes.push(num::BigInt::new(possiblePrime.sign(), possiblePrime.to_u32_digits().1));
+		}
+		else{
+			foundFactor = false;
+		}
+		//Advance to the next number
+		possiblePrime += 2;
+	}
+
+	//Sort the list before returning it
+	primes.sort();
+	return primes;
+}