Added a few more functions

src/Algorithms.rs

@@ -1,6 +1,7 @@
 extern crate num;
 
 
+//
 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,6 +22,7 @@ pub fn getAllFib(goalNumber: u64) -> Vec<u64>{
 	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
@@ -39,3 +41,169 @@ pub fn getAllFibBig(goalNumber: num::BigInt) -> Vec<num::BigInt>{
 	fibNums.remove(fibNums.len() - 1);
 	return fibNums;
 }
+
+//Ths 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;
+	let primes = getPrimes(topPossiblePrime);
+	let mut factors = Vec::<i64>::new();
+
+	//You need to step through each prime and see if it is a factor in the number
+	let mut cnt = 0;
+	while(cnt < primes.len()){
+		//If the prime is a factor you need to add it to the factor list
+		if((goalNumber % primes[cnt]) == 0){
+			factors.push(primes[cnt]);
+			goalNumber /= primes[cnt];
+		}
+		//Otherwise advance the location in primes you are looking at
+		//By not advancing if the prime is a factor you allow for multiple of the same prime number as a factor
+		else{
+			cnt += 1;
+		}
+	}
+
+	//If you didn't get any factors the number itself must be a prime
+	if(factors.len() == 0){
+		factors.push(goalNumber);
+		goalNumber /= goalNumber;
+	}
+
+	//TODO: If for some reason the goalNumber is not 1 throw an error
+	if(goalNumber != 1){
+	}
+
+	//Return the list of factors
+	return factors;
+}
+pub fn getFactorsBig(mut goalNumber: num::BigInt) -> Vec<num::BigInt>{
+	//You need to get all the rpimes that could be factors of this number so you can test them
+	let topPossiblePrime = goalNumber.sqrt();
+	let primes = getPrimesBig(topPossiblePrime);
+	let mut factors = Vec::<num::BigInt>::new();
+
+	//You need to step through each prime and see if it is a factor in the number
+	let mut cnt = 0;
+	while(cnt < primes.len()){
+		//If the prime is a factor you need to add it to the factor list
+		if((&goalNumber % &primes[cnt]) == num::BigInt::from(0)){
+			factors.push(num::BigInt::new(primes[cnt].sign(), primes[cnt].to_u32_digits().1));
+			goalNumber /= &primes[cnt];
+		}
+		//Otherwise advance the location in primes you are looking at
+		//By not advancing if the prime is a factor you allow for multiple of the same prime number as a factor
+		else{
+			cnt += 1;
+		}
+	}
+
+	//If you didn't get any factors the number itself must be a prime
+	if(factors.len() == 0){
+		factors.push(goalNumber);
+		goalNumber = num::BigInt::from(1);
+	}
+
+	//TODO: If for some reason the goalNumber is not 1 throw an error
+	if(goalNumber != num::BigInt::from(1)){
+	}
+
+	//Return the list of factors
+	return factors;
+}
+
+//This function returns a list with all the prime numbers <= goalNumber
+pub fn getPrimes(goalNumber: i64) -> Vec<i64>{
+	let mut primes = Vec::<i64>::new();
+	let mut foundFactor = false;
+
+	//If the number is 1, 0, or negative return an empty list
+	if(goalNumber <= 1){
+		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 number, because they cannot be prime
+	for possiblePrime in (3..=goalNumber).step_by(2){
+		//Check all current primes, up to sqrt(possiblePrime), to see if there is a divisor
+		let topPossibleFactor = (possiblePrime as f64).sqrt().ceil();
+		//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 as i64){
+			if((possiblePrime % 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);
+		}
+		else{
+			foundFactor = false;
+		}
+	}
+
+	//Sort the list before returning it
+	primes.sort();
+	return primes;
+}
+pub fn getPrimesBig(goalNumber: num::BigInt) -> Vec<num::BigInt>{
+	let mut primes = Vec::<num::BigInt>::new();
+	let mut foundFactor = false;
+
+	//If the number is 1, 0, or negative return an empty list
+	if(goalNumber <= num::BigInt::from(0)){
+		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 number, because they cannot be prime
+	let mut possiblePrime = num::BigInt::from(3);
+	while(possiblePrime <= goalNumber){
+		//Check for all currentprimes, 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 2 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 range
+			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;
+		}
+		possiblePrime += num::BigInt::from(2);
+	}
+
+	//Sort the list before returning it
+	primes.sort();
+	return primes;
+}