Divide Existing Program into Two

[SuzyQuant]

• Create a program that generates data

• Create a program that analyzes the data created

• The program that generates data should output two data files:

• Binary data file

• Text file .dat

[SuzyQuant]

//TASK: TO CREATE TWO PROGRAMS FROM THE EXISTING PROGRAM THAT WILL ANALYZE THE DATA .dat or .txt 
//One is to generate the data into .dat files, the other is to analyze the data through the subtasks below

Sub-Task:

• Create a function that will read the data files .dat
• Create function that will solve the Mean Square like the existing code
• Create function that will solve the probability like the existing code

[SuzyQuant]

//Generator Program 8-24-2020
#include <stdio.h>
#include
#include
#include
#include <time.h>

using namespace std;

const int max = 1000;
const int maxGP = 30;

const int a = 2; //STARTING POINT a in GOEMETRIC PROGRESSION
const int r = 2; //COMMON RATIO r in GEOMTRIC PROGRESSION

int main(int argc, char const* argv[]) {

/* initialize random seed: */
srand(time(NULL));

/* generate numWalkers and numSteps between 1 and max*/
int numWalkers = rand() % max + 1;
int numSteps = rand() % max + 1;

/* set output geometric progression stream */
ofstream geometricOut;
geometricOut.open("geometricOutput.txt");

/* set output normal time stream */
ofstream normalOut;
normalOut.open("normalOutput.txt");

/* set output for all steps taken */
ofstream allSteps;
allSteps.open("allStepsOutput.txt");

//====================================================//
//=== GENERATE GEOMETRIC PROGRESSION  ==========================//
unsigned long int* theGP = new unsigned long int[numSteps]; //WILL CONTAIN THE PROGRESSION 
float* stepsTracker = new float[numSteps * numWalkers]; //TRACKS ALL STEPS TAKEN
int currentGPValue = 0; //STARTS AT POSITION 0 IN THE theGP array, THIS WILL BE USED TO CHECK IF THE CURRENT STEP TAKEN IS EQUAL TO THE NEXT GEOMTRIC PROGRESSION
//Get the progression up to 30. It gets too big after 30.
for (int N = 1; N <= maxGP; N++) {
	theGP[N - 1] = a * pow(r, N - 1);
}
for (int i = 0; i < numSteps * numWalkers; i++)
	stepsTracker[i] = 0; //Initialize tracker
int trackercounter = 0;
//=====================================================//

/* output number of walkers and steps */
geometricOut << numWalkers << endl;
geometricOut << numSteps << endl;
normalOut << numWalkers << endl;
normalOut << numSteps << endl;
allSteps << numWalkers << endl;
allSteps << numSteps << endl;

for (int walker = 0; walker < numWalkers; walker++) {

	int currentPosition = 0; //Change depending on the current position of walker

	for (int step = 0; step < numSteps; step++ ) {

		//HEAD OR TAIL CONCEPT
		int randomNum = rand() % 2;

		if (randomNum == 1)
			currentPosition++;
		else
			currentPosition--;

		allSteps << currentPosition << " ";
		stepsTracker[trackercounter++] = currentPosition;

	}

	allSteps << endl;

}

//FOR LOOP FOR EACH GOEMETRIC PROGRESSION VALUE
for (int gpVal = 0; gpVal < maxGP; gpVal++) {

	//CHECK IF THE GP VALUE IS GREATER THAN NUMSTEPS. IF GREATER, STOP OUTPUT
	if (theGP[gpVal] > numSteps)
		break;

	geometricOut << theGP[gpVal];

	//FOR LOOP FOR EACH WALKER
	for (int wlkr = 0; wlkr < numWalkers; wlkr++) {

		float finalStep = stepsTracker[wlkr * numSteps + theGP[gpVal] - 1];
		geometricOut << " " << finalStep ;

	}
	geometricOut << endl;
}

//FOR LOOP FOR EACH NORMAL TIME
for (int normTime = 0; normTime < numSteps; normTime++) {

	normalOut << normTime + 1;
	//FOR LOOP FOR EACH WALKER
	for (int wlkr = 0; wlkr < numWalkers; wlkr++) {

		float finalStep = stepsTracker[wlkr * numSteps + normTime];
		normalOut << " " << finalStep;
	}
	normalOut << endl << endl;
}

allSteps.close();
geometricOut.close();
normalOut.close();
return 0;

}

[SuzyQuant]

//Analysis Program 8-24-2020
#include <stdio.h>
#include <math.h>
#include
#include
#include
#include
#include
#include
#include
#include

using namespace std;

const vector explode(const string& s, const char& c)
{
string buff{ "" };
vector v;

for (auto n : s)
{
    if (n != c) buff += n; else
        if (n == c && buff != "") { v.push_back(buff); buff = ""; }
}
if (buff != "") v.push_back(buff);

return v;

}

int main(int argc, char const* argv[])
{
//Read all files to be used.
ifstream allSteps("allStepsOutput.txt");
ifstream allGeometricSteps("geometricOutput.txt");
ifstream allFinalSteps("normalOutput.txt");

//Offstream files
ofstream posMean;
ofstream probTwoOut;
posMean.open("positionVSMeanSquareOutput.txt");
probTwoOut.open("positionVSProbabilityOutput2.txt");

string stringHolder;

//************************************************//
//******* SECTION FOR SQUARED DISPLACEMENT ****** //
//************************************************//

//set numWalkers
getline(allSteps, stringHolder);
int numWalkers = stoi(stringHolder);

//set numSteps
getline(allSteps, stringHolder);
int numSteps = stoi(stringHolder);

//FOR LOOP FOR EACH WALKER

//Variables for Squared Distance
double q1 = 1 / sqrt(numSteps), q2 = 1, q3 = sqrt(numSteps);

int* aStepSquared = new int[numSteps];
int* aStepSquared2 = new int[numSteps];

double* cosRq1 = new double[numSteps];
double* cosRq2 = new double[numSteps];
double* cosRq3 = new double[numSteps];

double* cosSqrdRq1 = new double[numSteps];
double* cosSqrdRq2 = new double[numSteps];
double* cosSqrdRq3 = new double[numSteps];

for (int itime = 0; itime < numSteps; itime++) {
    aStepSquared[itime] = 0;
    aStepSquared2[itime] = 0;

    cosRq1[itime] = 0.0;
    cosRq2[itime] = 0.0;
    cosRq3[itime] = 0.0;

    cosSqrdRq1[itime] = 0.0;
    cosSqrdRq2[itime] = 0.0;
    cosSqrdRq3[itime] = 0.0;
}

//SET PROBABILITY VARIABLES
double* probability = new double[2 * numSteps + 1]; //ARRAY TO HOLD PROBABILITY OF EACH POSITION TO BE VISITED
int* countNumberOfVisits = new int[numSteps * 2 + 1]; //ARRAY TO COUNT THE NUMBER OF VISITS PER POSITION

for (int position = 0; position < (2 * numSteps + 1); position++) {
    countNumberOfVisits[position] = 0;
}

float* stepsTracker = new float[numSteps * numWalkers]; //TRACKS ALL STEPS TAKEN
for (int i = 0; i < numSteps * numWalkers; i++)
    stepsTracker[i] = 0; //Initialize tracker
int trackercounter = 0;
//=====================================================//


for (int kWalkr = 0; kWalkr < numWalkers; kWalkr++) {

    //get all steps of current walker
    getline(allSteps, stringHolder);  

    //store all steps in a vector
    vector<string> positions { explode(stringHolder, ' ') };

    int currentPosition = 0; //CURRENT POSITION OF WALKER

    //FOR LOOP - FOR EACH STEP TAKEN
    int itime = 0;

    for (auto position : positions )
    {
        if (itime == numSteps)
            break;
        else itime++;

        int currentPosition = stoi(position);

        //COMPUTE aStepSquared[itime] and cosRq1, cosRq2, cosRq3
        aStepSquared[itime] += (currentPosition * currentPosition);
        aStepSquared2[itime] += pow(currentPosition, 4);

        // cos (q*R)
        cosRq1[itime] += cos(q1 * currentPosition);
        cosRq2[itime] += cos(q2 * currentPosition);
        cosRq3[itime] += cos(q3 * currentPosition);

        //cos^2 (q*R)
        cosSqrdRq1[itime] += cos(q1 * currentPosition) * cos(q1 * currentPosition);
        cosSqrdRq2[itime] += cos(q2 * currentPosition) * cos(q2 * currentPosition);
        cosSqrdRq3[itime] += cos(q3 * currentPosition) * cos(q3 * currentPosition);

        //cout << "==== The squared displacement is x^2 = " << aStepSquared[itime] << endl << endl;

        //RECORDS ALL STEPS TAKEN BY ALL WALKERS
        //TO BE USED IN GEOMETRIC PROGRESSION
        stepsTracker[trackercounter++] = currentPosition;

    }

    //INCREMENT countNumberOfVisits[] EVERYTIME currentPosition IS VISITED
    countNumberOfVisits[currentPosition + numSteps] += 1;
}

//Mean Square
for (int itime = 0; itime < numSteps; itime++) {
    double meanSquare = (double)aStepSquared[itime] / (double)numWalkers;
    double meanSquare2 = (double)aStepSquared2[itime] / (double)numWalkers;

    //<cos(q*R)>
    cosRq1[itime] = (double)cosRq1[itime] / (double)numWalkers;
    cosRq2[itime] = (double)cosRq2[itime] / (double)numWalkers;
    cosRq3[itime] = (double)cosRq3[itime] / (double)numWalkers;

    //<cos^2(q*R)>
    cosSqrdRq1[itime] = (double)cosSqrdRq1[itime] / (double)numWalkers;
    cosSqrdRq2[itime] = (double)cosSqrdRq2[itime] / (double)numWalkers;
    cosSqrdRq3[itime] = (double)cosSqrdRq3[itime] / (double)numWalkers;

    //standard deviation of the mean

    double stdevMeanSquare = (double)sqrt(meanSquare2 - meanSquare * meanSquare);
    double stdErrorOfMean = (double)(stdevMeanSquare / sqrt(numWalkers));

    double stdevCosSqrdRq1 = (double)sqrt(cosSqrdRq1[itime] - (cosRq1[itime] * cosRq1[itime]));
    double stdErrorCosSqrdRq1 = (double)(stdevCosSqrdRq1 / sqrt(numWalkers));

    double stdevCosSqrdRq2 = (double)sqrt(cosSqrdRq2[itime] - (cosRq2[itime] * cosRq2[itime]));
    double stdErrorCosSqrdRq2 = (double)(stdevCosSqrdRq2 / sqrt(numWalkers));

    double stdevCosSqrdRq3 = (double)sqrt(cosSqrdRq3[itime] - (cosRq3[itime] * cosRq3[itime]));
    double stdErrorCosSqrdRq3 = (double)(stdevCosSqrdRq3 / sqrt(numWalkers));

    // .csv file
    posMean << itime << " " << meanSquare << " " << stdErrorOfMean << " " << cosRq1[itime] << " " << cosRq2[itime] << " " << cosRq3[itime] << " " << stdErrorCosSqrdRq1 << " " << stdErrorCosSqrdRq2 << " " << stdErrorCosSqrdRq3 << endl;
}

//OTHER PROBABILITY REQUESTED
//UTILIZING ONLY THE VISITS ACTUALLY DONE
//==================================

for (int i = 0; i < (2 * numSteps + 1); i += 2)
{     
    probability[i] = (double)countNumberOfVisits[i] / (double)numWalkers;
    probTwoOut << i - numSteps << " " << probability[i] << endl;  // Output(x,y): POSITION VS PROBABILITY
}

posMean.close();
probTwoOut.close();

return 0;

}