# Thread: Math Programming in C++

1. ## Math Programming in C++

have been doing a little math programming over the past few weeks for science fair and my object is to make an efficient program that can find very large mersenne primes, I am currently using Lucas Lehmer's formula and a small statement that finds the first 500,000 prime number and divides the Mersenne prime by those numbers every time to help speed it up. My goal of this program is to make a type of filter that take out uneeded composite number before lucas takes over since it is kind of slow compared to some probablistic tests. One test I am really wanting to integrate is the Rabin-Miller strong pseudoprime test but I am unable to comperehend it, can someone please put it into C++ or a way in which I can understand it? Any suggestions?

Code:
```/*
Name: MPrime Finder
Author: Devon Taylor
Date: 13/10/05 22:07
Description: Uses high precision gmp library and lucas lehmers
determinant formula to find extremely large Mersenne Primes.
*/
#include <windows.h>
#include <fstream>
#include <iostream>
#include <stdlib.h>
#include <math.h>
#include <stdio.h>
#include <gmp.h>                              //Import needed includes
using namespace std;
int main(int argc, char* argv[]){                        //Initiate program
cout<<"Program is making preparations, one moment...\n";
long int n_check;
long int co=0;
long int prime_t;
long int test_primes[500001];
mpz_t d1;
mpz_init_set_si(d1,1);
long int count1=0;
long int d11;
while(count1<500000){
mpz_nextprime(d1,d1);
d11 =mpz_get_si(d1);
test_primes[count1]=d11;
count1=count1+1;
}
long int input_low;
long int input_high;                                     //Initiate Long Integer variables
long int color;
color = atoi(argv[1]);                           //Set color
HANDLE console;                                  //Initiate console handle
console = GetStdHandle(STD_OUTPUT_HANDLE);
SetConsoleTextAttribute(console, 3);
cout<<"Program Created By Devon Taylor in 2005 \n";
SetConsoleTextAttribute(console, 6);
cout<<"Enter an odd # > 3 and < ten mill to start calc. at: ";  //Ask for Lower Boundry
SetConsoleTextAttribute(console, 2);
cin>>input_low;
SetConsoleTextAttribute(console, 6);
cout<<"Enter an odd # > 3 and < ten mill to stop calc. at: ";   //Ask for High Boundry
SetConsoleTextAttribute(console, 2);
cin>>input_high;
SetConsoleTextAttribute(console, 8);
cout<<"Calculating.........";
FILE *fp;
ofstream a_file ( "Mersenne_primes.txt", ios::app );         //Create stream for a file
fp = fopen("Mersenne_primes.txt", "a");                      //Open the file
//Create file pointer
mpz_t test_prime2;
mpz_t p;                                    //Initiate High Precision Variables
mpz_t b;
mpz_t c;
mpz_t dd;
mpz_t x;
mpz_t two;
mpz_t r;
mpz_t k;
mpz_t w;
mpz_t y;
mpz_t m;
mpz_t s;
mpz_t kr;
mpz_t test;
mpz_t one;
mpz_t zero;
mpz_t limit;
mpz_t count;
mpz_init(limit);
mpz_init(kr);
mpz_init2(m,10000000);
mpz_init2(y,10000000);
mpz_init(test_prime2);
mpz_init2(s,1000000000);
mpz_init(c);
mpz_init(r);
mpz_init_set_si(zero,0);
mpz_init_set_si(one,1);
mpz_set_si(s,4);
mpz_init_set_ui(dd,input_high);
mpz_init_set_si(p,input_low);
mpz_init_set_si(two,2);
mpz_init_set_ui(c,3);
mpz_init_set_si(w,2);
mpz_init_set_si(k,3);
mpz_init_set_si(b,3);
mpz_init_set_si(x,3);
mpz_init_set_si(test,3);
mpz_init_set_ui(count,1);
int a=2;                                    //Initiate Variables                                  //|              //|
int mt;
int t;
int z;
int s_limit=mpz_cmp(p,dd);
int div_three;
int div_five;
int div_seven;
int h;
int l;
int cvd_prm;
int cvd_p;
int is_prime;
int s_check;
while (s_limit<0){                          //While the program stays within its boundries
mpz_add_ui(p,p,2);                          //Add 2 to the Mersenne Prime Exponent
s_limit=mpz_cmp(p,dd);                      //Check to see if number is within boundries
t=0;                                        //Set exit variable to 0
mpz_set_si(b,3);                            //Set b to 3
mpz_sqrt(c,p);                          //Divide the Prime Exponent by 3
while(t==0){                                //While exit statement is not true
z=mpz_divisible_p(p,b);                     //Check if Prime Exponent is divisible by b
mpz_add_ui(b,b,2);                          //If not divisible add 2 to b and try again
mt=mpz_cmp(c,b);                            //See if b becomes greater than c
if (z>0){                                   //If p is ever divisible, break while statement
t=1;                                        //Set exit statement to true
}
if(mt<0){                                   //If the Prime Exponent is proven to be prime
prime_t =mpz_get_si(p);
mpz_set_si(x,3);
l =mpz_get_si(p);
mpz_mul_2exp(y,one,l);
mpz_sub_ui(y,y,1);
mpz_set_si(c,500000);
co=0;
while(t==0  && co<500000){           //Test for divisibility of prime #'s under 500,000
mpz_set_ui(x,test_primes[co]);
co=co+1;
z=mpz_divisible_p(y,x);
h=mpz_cmp(c,x);
if(z>0){
t=1;
SetConsoleTextAttribute(console, 5);
cout<<"Testing- "<<l<<", ";
}
if(h<0){
SetConsoleTextAttribute(console, 5);
cout<<" Testing ";
gmp_printf("%Zd",p);                              //State what's being tested
cout<<", ";
cvd_prm =mpz_get_si(p);                           //Convert Prime Exponent to an integer
mpz_mul_2exp(m,one,cvd_prm);                        //Put 2 to the power of the Prime Exponent
mpz_sub_ui(m,m,1);                                //Subtract 1 from the Mersenne Number from above
mpz_set_si(s,4);                                  //Set s to 4
mpz_sub_ui(limit,p,1);                            //Set limit for Lucas test
mpz_set_ui(count,1);                              //Start process count at 1
is_prime=mpz_cmp(limit,count);                // Check if count is over limit
while(t==0){                                  //While exit statement is false
mpz_mul(s,s,s);                   //Multiply s to itself
mpz_sub_ui(s,s,2);                //Subtract 2 from s
mpz_mod(s,s,m);                   //Get modulous from s and m
is_prime=mpz_cmp(limit,count);    //Check if count exceeds the limit
s_check=mpz_cmp(s,zero);          //Compare s to zero
if(is_prime<0){                   //If the limit is reached its not prime, exit
t=1;
}

if (s_check==0){                  //If s is equal to zero then the number is a Mersenne Prime
cvd_p =mpz_get_si(p);           //Convert p to cvd_p
mpz_mul_2exp(r,one,cvd_p);          //Store the mersenne prime
mpz_sub_ui(r,r,cvd_p);          //Subtract 1

mpz_out_str(fp,0,r);                                 //Write the Prime to the file
a_file<<" & ";
a_file<<cvd_p;
a_file<<", ";

SetConsoleTextAttribute(console, 7);
gmp_printf("%Zd",p);                                //Print the prime_exp to the screen
cout<<" is a Mersenne Prime, ";
t=1;                                               //Exit to test a new #
}

}
}
}
}
}
}
fclose(fp);
cout<<".....Finished Calculating......";
system("pause");
}```

Popular pages Recent additions