/******************************************************
* Mutator function for member variable theTemplate.
*
* Parameter:
* theTemplate - 2D vector of doubles to set as theTemplate
**/
void KNearest::setTemplate(string fileName)
{
Scanner scan;
ReadData readData;
scan.openFile(fileName);
this->theTemplate = readData.readTemplate(scan);
scan.close();
} // void setTemplate(vector< vector<double> > theTemplate)
/******************************************************
* Mutator function for member variable theQuery.
*
* Parameter:
* theQuery - a vector<double> to set as theQuery
**/
void KNearest::setQuery(string fileName)
{
Scanner scan;
ReadData readData;
scan.openFile(fileName);
this->theQuery = readData.readQuery(scan);
scan.close();
} // void setQuery(vector<double> theQuery)
/******************************************************************************
In the readData() we are simply inputting the "xintput.txt" file in a vector.
we create a object for Scanner class and use a While loop to continuously scan
for text in the file until it has nothing else in it. While the scanner is
reading in the values this data is now pushed back into a vector called TheData.
We now have a vector that consist of 100 values of stock and it now received.
****/
void MovingAverage::readData(std::string fileName)
{
Scanner inScanner;
double value ;
inScanner.openFile(fileName);
std::cout << "Now receiving Stocks" << std::endl;
while(inScanner.hasNext())
{
value = inScanner.nextDouble();
theData.push_back(value);
}
}
int main(int argc, char *argv[])
{ string timeCallOutput = "";
string inFileName = "";
string outFileName = "";
string logFileName = "";
ifstream inStream;
ofstream outStream;
Scanner inScanner;
///////////////////////////////////////////////////////////////
// Boilerplate for opening files
Utils::CheckArgs(3, argc, argv, "infilename outfilename logfilename");
inFileName = (string) argv[1];
outFileName = (string) argv[2];
logFileName = (string) argv[3];
Utils::FileOpen(outStream, outFileName);
Utils::LogFileOpen(logFileName);
timeCallOutput = Utils::timecall("beginning");
Utils::logStream << timeCallOutput;
Utils::logStream << TAG << "Beginning execution" << endl;
Utils::logStream.flush();
Utils::logStream << TAG << "infile '" << inFileName << "'" << endl;
Utils::logStream << TAG << "outfile '" << outFileName << "'" << endl;
Utils::logStream << TAG << "logfile '" << logFileName << "'" << endl;
Utils::logStream.flush();
///////////////////////////////////////////////////////////////
// The actual work part of the main program
inScanner.openFile(inFileName);
///////////////////////////////////////////////////////////////
// Boilerplate for closing up
Utils::logStream << TAG << "Ending execution" << endl;
timeCallOutput = Utils::timecall("ending");
Utils::logStream << timeCallOutput;
Utils::logStream.flush();
Utils::FileClose(outStream);
Utils::FileClose(Utils::logStream);
return 0;
}
// was used to test the scanner
int TestScanner( string argv ) // int TestScanner( int argc, char* argv[] )
{
// name of the file to parse through
std::string fName = argv;
Scanner* dispatcher = new Scanner();
dispatcher->openFile(fName);
// Adjusted to print tokens to text file
std::ofstream out("tokens.txt");
std::streambuf *coutbuf = std::cout.rdbuf(); //save old buffer
std::cout.rdbuf(out.rdbuf()); //redirect std::cout to tokens.txt
// Adjusted to print in the proper order
cout << setw(15) << left << "Token" << setw(8) << "Line #" << setw(10) << "Column #" << setw(45) << "Lexeme"<< endl;
while (dispatcher->hasToken())
{
//Keep on separate couts so that getToken() executes first
cout << setw(15) << left << EnumToString(dispatcher->getToken()); //set the token
cout << setw(8) << dispatcher->getLineNumber() << setw(10) << dispatcher->getColumnNumber();
if (dispatcher->getLexeme().size() > 45){
string temp;
temp = dispatcher->getLexeme().substr(0,44);
cout << temp << endl;
} else
cout << dispatcher->getLexeme()<< endl;
}
cout << setw(15) << left << EnumToString(dispatcher->getToken())
<< setw(8) << dispatcher->getLineNumber() << setw(10) << dispatcher->getColumnNumber()
<< setw(45) << dispatcher->getLexeme() << endl << endl;
std::cout.rdbuf(coutbuf); //reset to standard output
// press enter to exit
printf("Done. Press Enter to exit.\n");
cin.get();
return 0;
}
int main(int argc, char** varg)
{
if(argc < 4)//this is how to use this
{
cerr << "usage: cmd file1 file2 output" << endl;
return 1;
}
//these are for holding each files occurances of strings, or lack thereof
set<WORD> file1, file2;
//Java like Scanner object
Scanner scan;
//open the file given as argument 1
scan.openFile(varg[1]);
//to the first file 'file1' we will add each string that is in there
//for the first occurance we set count at 1, and increment as needed
//to the second file 'file2' we will add each string from 'file1'
//and set the count to 0
while(scan.hasMoreData())
{
ScanLine line;
line.openString(scan.nextLine());
while(line.hasMoreData())
{
string nxt_token = line.next();
nxt_token = Utils::trimBlanks(nxt_token);
//add elements to 'file2' once with count 0
if(file2.count(nxt_token) == 0)
{
WORD f_two;
f_two.token = nxt_token;
f_two.count = 0;
file2.insert(f_two);
}
//add first occurance to file1 with count 1
if(file1.count(nxt_token) == 0)
{
WORD f_one;
f_one.token = nxt_token;
f_one.count = 1;
file1.insert(f_one);
}
else
{
//replace the word with a word of equal token and +1 count
set<WORD>::iterator it = file1.find(WORD(nxt_token));
int ct = it->count;
ct++;
file1.erase(it);
WORD replace;
replace.token = nxt_token;
replace.count = ct;
file1.insert(replace);
}
}
}
scan.close();//close file1
cout << "++++++++++++++++++++++++++++++++++++++++++++++++" << endl;
scan.openFile(varg[2]);//open file2
//to the second file 'file2' we will add each word we find, or
//increment as needed if it occurred in the first file
//if a string occurs in 'file2' that doesn't exist in 'file1'
//we will add any token to 'file1' list from 'file2' list and set count to 0
while(scan.hasMoreData())
{
ScanLine line;
line.openString(scan.nextLine());
while(line.hasMoreData())
{
string nxt_token = line.next();
nxt_token = Utils::trimBlanks(nxt_token);
//if the word doesn't already exist in 'file1' add it with count 0
if(file1.count(nxt_token) == 0)
{
WORD f_two;
f_two.token = nxt_token;
f_two.count = 0;
file1.insert(f_two);
}
//add the first occurance of a word to 'file2' with count 1
if(file2.count(nxt_token) == 0)
{
WORD f_one;
f_one.token = nxt_token;
f_one.count = 1;
file2.insert(f_one);
}
else
{
//replace the word with a word of equal token and +1 count
set<WORD>::iterator it = file2.find(WORD(nxt_token));
int ct = it->count;
ct++;
file2.erase(it);
WORD replace;
replace.token = nxt_token;
replace.count = ct;
file2.insert(replace);
}
}
}
scan.close();
ofstream outStream;
Utils::FileOpen(outStream, varg[3]);//open the output file
//write to it...
outStream << Utils::Format(compare(file1, file2), 2, 6) << endl;
Utils::FileClose(outStream);//close it
}