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> ¤t_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> ¤t_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
00126
00127
00128
00129
00130
00131
00132
00133
00134
00135
00136
00137
00138
00139
00140
00141
00142
00143 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 }