306 lines
9.4 KiB
Rust
306 lines
9.4 KiB
Rust
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
|
|
if(goalNumber <= 0){
|
|
return fibNums;
|
|
}
|
|
|
|
//This means that at least 2 1's are elements
|
|
fibNums.push(1);
|
|
fibNums.push(1);
|
|
|
|
//Loop to generate the rest of the Fibonacci numbers
|
|
while(fibNums[fibNums.len() - 1] <= goalNumber){
|
|
fibNums.push(fibNums[fibNums.len() - 1] + fibNums[fibNums.len() - 2]);
|
|
}
|
|
//At this point the most recent number is > goalNumber, so remove it and return the rest of the list
|
|
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
|
|
if(goalNumber <= num::BigInt::from(0)){
|
|
return fibNums;
|
|
}
|
|
|
|
//This means that at least 2 1's are elements
|
|
fibNums.push(num::BigInt::from(1));
|
|
fibNums.push(num::BigInt::from(1));
|
|
|
|
while(fibNums[fibNums.len() - 1] <= goalNumber){
|
|
fibNums.push(&fibNums[fibNums.len() - 1] + &fibNums[fibNums.len() - 2]);
|
|
}
|
|
//At this point the most recent number is > goalNumber, so remove it and return the rest of the list
|
|
fibNums.remove(fibNums.len() - 1);
|
|
return fibNums;
|
|
}
|
|
|
|
//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;
|
|
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;
|
|
}
|
|
|
|
//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;
|
|
}
|