Main Page | Modules | Alphabetical List | Compound List | File List | Compound Members | Related Pages

testHoldouts.cpp

00001 #include <fstream>
00002 #include <iostream>
00003 #include <iterator>
00004 #include <list>
00005 #include <vector>
00006 #include <stdlib.h>
00007 
00008 #include "stats.hpp"
00009 tm_stats g_counter, c_counter;
00010 
00011 #include "infinite_tape.hpp"
00012 #include "long_int.hpp"
00013 #include "state.hpp"
00014 #include "turing_machine.hpp"
00015 #include "non_halt_detection.hpp"
00016 #include "non_halt_data_structures.hpp"
00017 #include "machine_storage.hpp"
00018 #include "watch.hpp"
00019 
00020 turing_machine<unsigned short> parseMachine(std::string filename);
00021 void testHoldouts(std::string holdoutDir, int numHoldouts);
00022 void runTests(turing_machine<unsigned short> &current_machine,
00023                 long_int machineNum,
00024                 tm_stats &g_counter,
00025                 tm_stats &c_counter,
00026                 std::vector< std::vector<long_int> > &newNonHalters);
00027 void displayNonHaltStats(tm_stats &g_counter, tm_stats &c_counter, std::vector< std::vector<long_int> > &newNonHalters);
00028 
00029 int main()
00030 {
00031         testHoldouts("./B5/holdout/", 232);
00032 
00033         return 0;
00034 }
00035 
00036 turing_machine<unsigned short> parseMachine(std::string filename)
00037 {
00038         std::ifstream file(filename.c_str());
00039         std::string temp;
00040         int states;
00041 
00042         file >> temp;
00043         while(temp != "/*NumStates")
00044                 file >> temp;
00045         file >> temp;
00046         file >> states;
00047 
00048         turing_machine<unsigned short> machine(states+1,0);
00049         machine.set_halt_state(states);
00050 
00051         while(temp != "start")
00052                 file >> temp;
00053         file >> temp;
00054         file >> temp;
00055 
00056         while(1)
00057         {
00058                 int originalState, nextState, readChar, writeChar;
00059                 char read, action;
00060                 std::string firstTemp;
00061                 turing_machine<unsigned short>::move_type move;
00062                 bool writeAction;
00063 
00064                 file >> firstTemp;
00065                 if(firstTemp == "/*EndGraphOutput*/")
00066                         break;
00067                 else
00068                         originalState = firstTemp[0] - 48;
00069                 file >> temp;
00070                 file >> nextState;
00071                 file >> temp;
00072 
00073                 if(file.eof())
00074                         break;
00075                 read = temp[8];
00076                 action = temp[10];
00077                 switch(read)
00078                 {
00079                         case '0': readChar = 0; break;
00080                         case '1': readChar = 1; break;
00081                 }
00082                 switch(action)
00083                 {
00084                         case '0': writeChar = 0; writeAction = true; break;
00085                         case '1': writeChar = 1; writeAction = true; break;
00086                         case 'L': move = turing_machine<unsigned short>::left; writeAction = false; break;
00087                         case 'R': move = turing_machine<unsigned short>::right; writeAction = false; break;
00088                 }
00089                 if(writeAction)
00090                         machine.add_write_transition(originalState,readChar,writeChar,nextState);
00091                 else
00092                         machine.add_move_transition(originalState,readChar,move,nextState);
00093         }
00094 
00095         return machine;
00096 }
00097 
00098 void testHoldouts(std::string holdoutDir, int numHoldouts)
00099 {
00100         std::string filename;
00101         long_int i(0);
00102         long_int max(numHoldouts);
00103         int status = 0;
00104 
00105         tm_stats g_counter, c_counter;
00106         std::vector< std::vector<long_int> > newNonHalters(10);
00107         for(i; i < max; i+=1, status++)
00108         {
00109                 filename = holdoutDir + i.toString() + ".tmo";
00110                 turing_machine<unsigned short> current_machine(parseMachine(filename));
00111                 runTests(current_machine, i, g_counter, c_counter, newNonHalters);
00112                 if(status%10 == 0)
00113                         std::cout << "machine " << status << " done" << std::endl;
00114         }
00115 
00116         displayNonHaltStats(g_counter, c_counter, newNonHalters);
00117 }
00118 
00119 void runTests(turing_machine<unsigned short> &current_machine,
00120                 long_int machineNum,
00121                 tm_stats &g_counter,
00122                 tm_stats &c_counter,
00123                 std::vector< std::vector<long_int> > &newNonHalters)
00124 {
00125         /*if(backTrack(current_machine, 40))
00126         {
00127                 newNonHalters[0].push_back(machineNum);
00128                 g_counter.increment(tm_stats::backTracker, current_machine.number_represented());
00129                 c_counter.increment(tm_stats::backTracker, 1);
00130         }
00131         else if(loopStates(current_machine))
00132         {
00133                 newNonHalters[1].push_back(machineNum);
00134                 g_counter.increment(tm_stats::subsetLoop, current_machine.number_represented());
00135                 c_counter.increment(tm_stats::subsetLoop, 1);
00136         }
00137         else if(simpleLoopCheck(current_machine, 5000))
00138         {
00139                 newNonHalters[2].push_back(machineNum);
00140                 g_counter.increment(tm_stats::simpleLoop, current_machine.number_represented());
00141                 c_counter.increment(tm_stats::simpleLoop, 1);
00142         }
00143         else*/ if(multiSweepChristmasTree(current_machine, 1, 200000))
00144         {
00145                 newNonHalters[3].push_back(machineNum);
00146                 g_counter.increment(tm_stats::christmasTree, current_machine.number_represented());
00147                 c_counter.increment(tm_stats::christmasTree, 1);
00148         }
00149         else if(multiSweepChristmasTree(current_machine, 2, 200000))
00150         {
00151                 newNonHalters[4].push_back(machineNum);
00152                 g_counter.increment(tm_stats::alternateChristmasTree, current_machine.number_represented());
00153                 c_counter.increment(tm_stats::alternateChristmasTree, 1);
00154         }
00155         else if(leaningChristmasTree(current_machine, 200000))
00156         {
00157                 newNonHalters[5].push_back(machineNum);
00158                 g_counter.increment(tm_stats::leaningChristmasTree, current_machine.number_represented());
00159                 c_counter.increment(tm_stats::leaningChristmasTree, 1);
00160         }
00161         else if(multiSweepChristmasTree(current_machine, 3, 200000))
00162         {
00163                 newNonHalters[6].push_back(machineNum);
00164                 g_counter.increment(tm_stats::tripleSweepChristmasTree, current_machine.number_represented());
00165                 c_counter.increment(tm_stats::tripleSweepChristmasTree, 1);
00166         }
00167         else if(multiSweepChristmasTree(current_machine, 4, 200000))
00168         {
00169                 newNonHalters[7].push_back(machineNum);
00170                 g_counter.increment(tm_stats::quadrupleSweepChristmasTree, current_machine.number_represented());
00171                 c_counter.increment(tm_stats::quadrupleSweepChristmasTree, 1);
00172         }
00173         else if(multiSweepChristmasTree(current_machine, 5, 200000))
00174         {
00175                 newNonHalters[8].push_back(machineNum);
00176                 g_counter.increment(tm_stats::quadrupleSweepChristmasTree, current_machine.number_represented());
00177                 c_counter.increment(tm_stats::quadrupleSweepChristmasTree, 1);
00178         }
00179         else if(counter(current_machine, 100000))
00180         {
00181                 newNonHalters[9].push_back(machineNum);
00182                 g_counter.increment(tm_stats::counter, current_machine.number_represented());
00183                 c_counter.increment(tm_stats::counter, 1);
00184         }
00185 }
00186 
00187 void displayNonHaltStats(tm_stats &g_counter, tm_stats &c_counter, std::vector< std::vector<long_int> > &newNonHalters)
00188 {
00189         std::cout << "observed " << c_counter << std::endl;
00190         std::cout << "representative " << g_counter << std::endl;
00191         for(int i = 0; i < newNonHalters.size(); i++)
00192         {
00193                 switch(i)
00194                 {
00195                         case 0: std::cout << "Backtrackers : "; break;
00196                         case 1: std::cout << "SubsetLoops : "; break;
00197                         case 2: std::cout << "SimpleLoops : "; break;
00198                         case 3: std::cout << "ChristmasTrees : "; break;
00199                         case 4: std::cout << "AlternateChristmasTrees : "; break;
00200                         case 5: std::cout << "LeaningChristmasTrees : "; break;
00201                         case 6: std::cout << "TripleSweepChristmasTrees : "; break;
00202                         case 7: std::cout << "QuadrupleSweepChristmasTrees : "; break;
00203                         case 8: std::cout << "QuintupleSweepChristmasTrees : "; break;
00204                         case 9: std::cout << "Counters : "; break;
00205                 }
00206                 for(int j = 0; j < newNonHalters[i].size(); j++)
00207                 {
00208                         std::cout << newNonHalters[i][j] << ' ';
00209                 }
00210                 std::cout << std::endl;
00211         }
00212 }

Generated on Thu Nov 20 00:17:32 2003 for BusyBeaver by doxygen 1.3.3