void testNoDefaultConstructor() {
Deque<NoDefaultConstructor> deque;
deque.reserve(8);
for(int i = 0; i < 5; ++i) {
deque.push_back(NoDefaultConstructor(i));
SINVARIANT(deque.back().v == i);
SINVARIANT(deque.size() == static_cast<size_t>(i + 1));
INVARIANT(NoDefaultConstructor::ndc_count == i + 1, format("%d != %d + 1")
% NoDefaultConstructor::ndc_count % i);
}
for(int i = 0; i < 5; ++i) {
SINVARIANT(deque.front().v == i);
deque.pop_front();
deque.push_back(NoDefaultConstructor(i));
SINVARIANT(deque.back().v == i);
SINVARIANT(deque.size() == 5);
SINVARIANT(NoDefaultConstructor::ndc_count == 5);
}
for(int i = 0; i < 5; ++i) {
SINVARIANT(deque.front().v == i);
deque.pop_front();
SINVARIANT(deque.size() == static_cast<size_t>(4 - i));
SINVARIANT(NoDefaultConstructor::ndc_count == 4 - i);
}
SINVARIANT(NoDefaultConstructor::ndc_count == 0);
}
void testQuickSort(){
cout<<"***********************"<<endl;
cout<<"******quick sort*******"<<endl;
Deque<int> deque;
deque.push_front(10);
deque.push_back(3);
deque.push_back(2);
deque.push_front(4);
deque.output();
hds::quickSort(deque.begin(),deque.end());
deque.output();
hds::quickSort(deque.begin(),deque.end(),hds::Greater<int>());
deque.output();
deque.clear();
for(int i=0;i < 20;++i){
deque.push_back(i+10);
}
deque.insert(deque.begin()+10,2);
deque.insert(deque.begin()+2,34);
deque.insert(deque.begin()+16,6);
deque.insert(deque.begin()+13,78);
deque.output();
hds::quickSort(deque.begin(),deque.end(),hds::Greater<int>());
deque.output();
cout<<"***********************"<<endl;
}
TEST(Deque, grow)
{
Deque d;
for (int i = 0; i < 10; i++)
d.push_back(i);
d.push_back(10);
CHECK(11 == d.size());
CHECK(10 == d.pop_back());
}
TEST (Deque, double_test)
{
Deque<double> d;
d.push_front(0.1);
d.push_back(1.1);
d.push_back(2.1);
d.push_back(3.1);
CHECK ( 4 == d.size() );
CHECK ( 0.1 == d.pop_front() );
CHECK ( 3.1 == d.pop_back() );
}
TEST(Deque, doit)
{
Deque d;
d.push_front(0);
d.push_back(1);
d.push_back(2);
d.push_back(3);
CHECK(4 == d.size());
CHECK(0 == d.pop_front());
CHECK(3 == d.pop_back());
}
void testAssign() {
Deque<int> a;
a.push_back(1);
a.push_back(2);
a.push_back(3);
vector<int> b;
b.assign(a.begin(), a.end());
SINVARIANT(b.size() == 3);
for(int32_t i = 0; i < 3; ++i) {
SINVARIANT(b[i] == i+1);
}
}
void testPushBack() {
Deque<int> deque;
SINVARIANT(deque.empty());
deque.reserve(8);
SINVARIANT(deque.empty() && deque.capacity() == 8);
for(int i = 0; i < 5; ++i) {
deque.push_back(i);
SINVARIANT(deque.back() == i);
SINVARIANT(deque.size() == static_cast<size_t>(i + 1));
}
for(int i = 0; i < 5; ++i) {
SINVARIANT(deque.at(i) == i);
}
for(int i = 0; i < 5; ++i) {
SINVARIANT(deque.front() == i);
deque.pop_front();
deque.push_back(i);
SINVARIANT(deque.back() == i);
SINVARIANT(deque.size() == 5);
}
for(int i = 0; i < 5; ++i) {
SINVARIANT(deque.at(i) == i);
}
{
Deque<int>::iterator i = deque.begin();
int j = 0;
while(i != deque.end()) {
INVARIANT(*i == j, format("%d != %d") % *i % j);
++i;
++j;
}
}
vector<int> avec;
for(int i = 5; i < 10; ++i) {
avec.push_back(i);
}
deque.push_back(avec);
for(int i = 0; i < 10; ++i) {
SINVARIANT(deque.front() == i);
deque.pop_front();
}
SINVARIANT(deque.empty());
}
TEST(EmptyDequeTest, Random) {
std::deque<int> control;
Deque<int> deque;
for (size_t i = 0; i < CHUNK_COUNT; ++i) {
clock_t time = clock();
for (size_t c = 0; c < CHUNK_SIZE; ++c) {
int operand = rand();
switch (rand() % 4) {
case 0:
deque.push_back(operand);
control.push_back(operand);
break;
case 1:
deque.push_front(operand);
control.push_front(operand);
break;
case 2:
if (control.size() == 0) {
break;
}
EXPECT_EQ(deque.pop_front(), control.front());
control.pop_front();
break;
case 3:
if (control.size() == 0) {
break;
}
EXPECT_EQ(deque.pop_back(), control.back());
control.pop_back();
break;
}
}
std::cout << clock() - time << std::endl;
}
}
void update(int64_t packet_raw, int packet_size, const Int64TimeField &packet_at,
const string &filename) {
LintelLogDebug("IPRolling::packet", format("UPD %d %d") % packet_raw % packet_size);
if (!packets_in_flight.empty()) {
int64_t cur_back_ts_raw = packets_in_flight.back().timestamp_raw;
INVARIANT(packet_raw >= cur_back_ts_raw,
format("out of order by %.4fs in %s; %d < %d")
% packet_at.rawToDoubleSeconds(cur_back_ts_raw - packet_raw) % filename
% packet_raw % cur_back_ts_raw);
}
while ((packet_raw - cur_time_raw) > interval_width_raw) {
// update statistics for the interval from cur_time to cur_time + interval_width
// all packets in p_i_f must have been received in that interval
double bw = cur_bytes_in_queue * MiB_per_second_convert;
MiB_per_second.add(bw);
double pps = packets_in_flight.size() * kpackets_per_second_convert;
kpackets_per_second.add(pps);
LintelLogDebug("IPRolling::detail", format("[%d..%d[: %.0f, %d -> %.6g %.6g")
% cur_time_raw % (cur_time_raw + update_step_raw)
% cur_bytes_in_queue % packets_in_flight.size() % bw % pps);
cur_time_raw += update_step_raw;
while (! packets_in_flight.empty() &&
packets_in_flight.front().timestamp_raw < cur_time_raw) {
cur_bytes_in_queue -= packets_in_flight.front().packetsize;
packets_in_flight.pop_front();
}
}
packets_in_flight.push_back(packetTimeSize(packet_raw, packet_size));
cur_bytes_in_queue += packet_size;
}
void HyperDijkstra::visitAdjacencyMap(AdjacencyMap& amap, TreeAction* action, bool useDistance)
{
typedef std::deque<HyperGraph::Vertex*> Deque;
Deque q;
// scans for the vertices without the parent (whcih are the roots of the trees) and applies the action to them.
for (AdjacencyMap::iterator it=amap.begin(); it!=amap.end(); ++it) {
AdjacencyMapEntry& entry(it->second);
if (! entry.parent()) {
action->perform(it->first,0,0);
q.push_back(it->first);
}
}
//std::cerr << "q.size()" << q.size() << endl;
int count=0;
while (! q.empty()) {
HyperGraph::Vertex* parent=q.front();
q.pop_front();
++count;
AdjacencyMap::iterator parentIt=amap.find(parent);
if (parentIt==amap.end()) {
continue;
}
//cerr << "parent= " << parent << " parent id= " << parent->id() << "\t children id =";
HyperGraph::VertexSet& childs(parentIt->second.children());
for (HyperGraph::VertexSet::iterator childsIt=childs.begin(); childsIt!=childs.end(); ++childsIt) {
HyperGraph::Vertex* child=*childsIt;
//cerr << child->id();
AdjacencyMap::iterator adjacencyIt=amap.find(child);
assert (adjacencyIt!=amap.end());
HyperGraph::Edge* edge=adjacencyIt->second.edge();
assert(adjacencyIt->first==child);
assert(adjacencyIt->second.child()==child);
assert(adjacencyIt->second.parent()==parent);
if (! useDistance) {
action->perform(child, parent, edge);
} else {
action->perform(child, parent, edge, adjacencyIt->second.distance());
}
q.push_back(child);
}
//cerr << endl;
}
}
TEST(Deque, pop_back)
{
Deque d;
d.push_back(0);
d.push_back(1);
CHECK(1 == d.pop_back());
CHECK(0 == d.pop_back());
}
int main()
{
cout << "It runs!" << endl;
//create a stack & show it works
Stack<int> s;
s.pop();
s.print();
cout<<"Empty? "<<s.empty()<<endl;
cout<<s.size()<<endl;
for(int i=0; i<10; i++) {
s.push(2*i+1);
s.print();
cout<<s.size()<<endl<<endl;
}
cout<<"Empty? "<<s.empty()<<endl;
cout<<"The top is "<<(s.top())<<endl;
for(int i=0; i<12; i++) {
s.pop();
s.print();
}
cout<<"The top is "<<(s.top())<<endl;
//create a queue & show it works
Queue<int> q;
q.print();
cout<<"Empty? "<<q.empty()<<endl;
cout<<q.size()<<endl;
for(int i=0; i<10; i++) {
q.push(2*i+1);
q.print();
cout<<q.size()<<endl<<endl;
}
cout<<"Empty? "<<q.empty()<<endl;
cout<<"The front is "<<(q.front())<<endl;
cout<<"The rear is "<<(q.back())<<endl;
for(int i=0; i<12; i++) {
q.pop();
q.print();
}
cout<<"The front is "<<(q.front())<<endl;
cout<<"The rear is "<<(q.back())<<endl;
Deque<int> d;
d.print();
for(int i=0; i<10; i++) {
d.push_back(i);
d.print();
}
for(int i=0; i<10; i++) {
if(i%2==0) {cout<<"back"<<endl;
d.pop_back();}
else{cout<<"front"<<endl;
d.pop_front();}
d.print();
}
}
int main(){
int n;
cin>>n;
string s;
getline(cin,s);
Deque dteams;
Map mteams;
bool first=true;
for(int i=0;i<n;i++){
dteams.clear(); mteams.clear();
if(first) first=false; else cout<<endl;
getline(cin,s);
cout<<s<<endl;
int numTeam,numMatch;
cin>>numTeam;
getline(cin,s);
for(int j=0;j<numTeam;j++){
getline(cin,s);
dteams.push_back(Team(s));
mteams.insert(make_pair(s,&(dteams.back())));
}
cin>>numMatch;
getline(cin,s);
for(int j=0;j<numMatch;j++){
Team* t1,*t2;
int score1,score2;
getline(cin,s,'#');
t1=mteams.find(s)->second;
cin>>score1;
getline(cin,s,'@');
cin>>score2;
getline(cin,s,'#');
getline(cin,s);
t2=mteams.find(s)->second;
t1->goalScored+=score1;
t1->goalAgainst+=score2;
t2->goalScored+=score2;
t2->goalAgainst+=score1;
if(score1>score2){t1->win++;t2->lose++;}
else if(score1<score2){t1->lose++;t2->win++;}
else {t1->tie++;t2->tie++;}
}
sort(dteams.begin(),dteams.end());
int rank=1;
for(Deque::iterator it=dteams.begin();it!=dteams.end();it++,rank++){
cout<<rank<<") "<<it->name<<" "<<it->point()<<"p, "<<it->total()<<
"g ("<<it->win<<"-"<<it->tie<<"-"<<it->lose<<"), "<<
it->goalDiff()<<"gd ("<<it->goalScored<<"-"<<it->goalAgainst<<")"<<endl;
}
//cout<<endl;
}
}
int main(){
Deque *d = new Deque();
d->push_front(1);
d->push_back(2);
d->push_back(3);
d->push_front(0);
d->pop_front();
d->pop_back();
d->print();
delete d;
return 0;
}
void testShellSort(){
cout<<"***********************"<<endl;
cout<<"******shell sort*******"<<endl;
Deque<int> deque;
deque.push_front(10);
deque.push_back(3);
deque.push_back(2);
deque.push_front(4);
deque.output();
hds::shellSort(deque.begin(),deque.end());
deque.output();
hds::shellSort(deque.begin(),deque.end(),hds::Greater<int>());
deque.output();
cout<<"***********************"<<endl;
}
void testMergeSortBU(){
cout<<"***********************"<<endl;
cout<<"****merge sort BU******"<<endl;
Deque<int> deque;
deque.push_front(10);
deque.push_back(3);
deque.push_back(2);
deque.push_front(4);
deque.output();
hds::mergeSortBU(deque.begin(),deque.end());
deque.output();
hds::mergeSortBU(deque.begin(),deque.end(),hds::Greater<int>());
deque.output();
cout<<"***********************"<<endl;
}
// verify that the destructor is called on pop_front.
void testDestroy() {
Deque<Thing> things;
for(uint32_t i = 0; i < 10; ++i) {
INVARIANT(Thing::thing_count == i, format("%d != %d") % Thing::thing_count % i);
things.push_back(Thing());
}
for(uint32_t i = 0; i < 10; ++i) {
SINVARIANT(Thing::thing_count == (10-i));
things.pop_front();
}
SINVARIANT(Thing::thing_count == 0);
}
void testInsertionSort(){
cout<<"***********************"<<endl;
cout<<"*****insertion sort****"<<endl;
Deque<int> deque;
deque.push_front(10);
deque.push_back(3);
deque.push_back(2);
deque.push_front(4);
deque.output();
hds::insertionSort(deque.begin(),deque.end());
deque.output();
hds::insertionSort(deque.begin(),deque.end(),hds::Greater<int>());
deque.output();
cout<<"***********************"<<endl;
}
//--------------------Linear solution----------------------
void minimumValues(int v[], int k) {
Deque<int> d = Deque<int>(); // In the queue I store positions, no elements
for (int i = 0; i < N; i++)
{
if (i >= k) // Until we have not consider a subarray, we can not print the minimums.
cout << v[d.front()] << " ";
while (!d.empty() && v[d.back()] >= v[i]) { // While the queue is not empty and the element I want to insert is
// greater or equal than the last one I extract the last element
d.pop_back();
}
d.push_back(i); // I insert the new element
if (d.front() <= i - k) //This remove the minimum once is out of the subarray
d.pop_front();
}
cout << v[d.front()] << endl;
}
int main()
{
Deque<int> A ;
int i ;
for( i = 0; i<200; i++)
{
A.push_back(i);
A.push_front(i);
}
A[100] = 2;
int retval = A[100];
cout<<A[100]<<endl;
cout << retval << endl;
//for (i =100;i>0;i++)
// A[i] = i;
/*for( i =0; i<10;i++)
{
A.pop_front();
A.pop_back();
}
for (i = 0; i<4; i++)
{
A.push_back(i);
A.push_front(i);
}
for( i =0; i<2;i++)
{
A.pop_front();
A.pop_back();
}*/
//A.print();
A[50]=5;
for( i=0; i<400;i++)
cout<<i<<" "<<A[i]<<"\n";
//A[2399]=5;
return 0;
}
int main()
{
#if 0
CString cstr;
cstr.init("abc");
cstr.print();
printf("\n");
Deque<CString> deque;
deque.init();
deque.push_back(cstr);
CString ps;
ps = "102";
cstr.init("def");
deque.push_back(cstr);
deque.print();
deque.back(0, ps);
ps.print();
printf("\n");
#endif
#if 1
setlocale(LC_ALL, "");
initscr();
keypad(stdscr,true);
curs_set(0);
// KEY_UP
// KEY_DOWN
//Deque<string> deque;
Deque<CString> deque;
deque.init();
move(0,0);
int fail_time=1;
while(1)
{
char str[128];
getstr(str);
move(0,0);
//std::string s(str);
CString s;
s.init(str);
if (deque.push_back(s) == false)
{
mvprintw(20, 0, "push back fail ## %d", fail_time++);
deque.pop_front();
deque.push_back(s);
}
deque.print();
int index=0;
noecho();
//string ps;
CString ps;
while(1)
{
mvprintw(17, 0, "index: %d", index);
refresh();
int ch = getch();
switch(ch)
{
case KEY_UP:
{
++index;
if (deque.back(index, ps) == true)
{
mvprintw(0, 15, "%s", ps.c_str());
}
else
--index;
break;
}
case KEY_DOWN:
{
--index;
if (deque.back(index, ps) == true)
{
mvprintw(0, 15, "%s", ps.c_str());
}
else
{
//mvprintw(17, 5, "back fail");
++index;
}
break;
}
case 'q':
{
goto end;
}
default:
{
ungetch(ch);
move(0, 0);
goto outer;
break;
}
}
mvprintw(17, 0, "index: %d", index);
refresh();
}
outer:
echo();
}
end:
endwin();
#endif
return 0;
}
void test_deque()
{
const size_t SIZE = 10;
Deque<int, SIZE> deque;
cout << "--> testing push_back..." << endl;
for (size_t i = 0; i < SIZE; i++)
{
try
{
deque.push_back(i);
}
catch (std::overflow_error &e)
{
cout << "i: " << i << endl;
cout << e.what() << endl;
}
}
deque.traverse(print);
cout << endl;
cout << "size: " << deque.size() << endl;
deque.print_mark();
cout << "--> testing pop_back..." << endl;
while (!deque.empty())
{
deque.pop_back();
}
deque.traverse(print);
cout << endl;
cout << "size: " << deque.size() << endl;
deque.print_mark();
cout << "--> testing push_front..." << endl;
for (size_t i = 0; i < SIZE; i++)
{
try
{
deque.push_front(i);
}
catch (std::overflow_error &e)
{
cout << "i: " << i << endl;
cout << e.what() << endl;
}
}
deque.traverse(print);
cout << endl;
cout << "size: " << deque.size() << endl;
deque.print_mark();
cout << "--> testing pop_front..." << endl;
while (!deque.empty())
{
deque.pop_front();
}
deque.traverse(print);
cout << endl;
cout << "size: " << deque.size() << endl;
deque.print_mark();
}
int
main(int argc, char *argv[])
{
std::set_new_handler(&mem_error);
if (!ParseArguments(argc, argv)) {
Usage();
exit(-1);
}
// Disable core dump
struct rlimit r_core;
r_core.rlim_cur = 0;
r_core.rlim_max = 0;
setrlimit(RLIMIT_CORE, &r_core);
// Set demo limits
if (options.demo) {
struct rlimit r_cpu, r_as;
memlimit = true;
r_cpu.rlim_cur = 30; // max 30 secs.
r_cpu.rlim_max = 30;
setrlimit(RLIMIT_CPU, &r_cpu);
r_as.rlim_cur = 20971520; // max 20MB
r_as.rlim_max = 20971520;
setrlimit(RLIMIT_DATA, &r_as);
signal(SIGXCPU, &cpuLimit);
}
initTimer();
Timer timer_total;
timer_total.start();
///////// PARSING ////////////////////////////////////////////////////////
if (options.printProgress)
cout << "MONA v" << VERSION << "-" << RELEASE << " for WS1S/WS2S\n"
"Copyright (C) 1997-2008 BRICS\n\n"
"PARSING\n";
Timer timer_parsing;
timer_parsing.start();
loadFile(inputFileName);
yyparse();
MonaAST *ast = untypedAST->typeCheck();
lastPosVar = ast->lastPosVar;
allPosVar = ast->allPosVar;
timer_parsing.stop();
if (options.printProgress) {
cout << "Time: ";
timer_parsing.print();
}
delete untypedAST;
if (options.dump) {
// Dump AST for main formula, verify formulas, and assertion
cout << "Main formula:\n";
(ast->formula)->dump();
Deque<ASTForm *>::iterator vf;
Deque<char *>::iterator vt;
for (vf = ast->verifyformlist.begin(), vt = ast->verifytitlelist.begin();
vf != ast->verifyformlist.end(); vf++, vt++) {
cout << "\n\nFormula " << *vt << ":\n";
(*vf)->dump();
}
cout << "\n\nAssertions:\n";
(ast->assertion)->dump();
cout << "\n";
if (lastPosVar != -1)
cout << "\nLastPos variable: "
<< symbolTable.lookupSymbol(lastPosVar) << "\n";
if (allPosVar != -1)
cout << "\nAllPos variable: "
<< symbolTable.lookupSymbol(allPosVar) << "\n";
// Dump ASTs for predicates and macros
PredLibEntry *pred = predicateLib.first();
while (pred != NULL) {
if (pred->isMacro)
cout << "\nMacro '";
else
cout << "\nPredicate '";
cout << symbolTable.lookupSymbol(pred->name)
<< "':\n";
(pred->ast)->dump();
cout << "\n";
pred = predicateLib.next();
}
// Dump restrictions
if (symbolTable.defaultRestriction1) {
cout << "\nDefault first-order restriction ("
<< symbolTable.lookupSymbol(symbolTable.defaultIdent1) << "):\n";
symbolTable.defaultRestriction1->dump();
cout << "\n";
}
if (symbolTable.defaultRestriction2) {
cout << "\nDefault second-order restriction ("
<< symbolTable.lookupSymbol(symbolTable.defaultIdent2) << "):\n";
symbolTable.defaultRestriction2->dump();
cout << "\n";
}
Ident id;
for (id = 0; id < (Ident) symbolTable.noIdents; id++) {
Ident t;
ASTForm *f = symbolTable.getRestriction(id, &t);
if (f) {
cout << "\nRestriction for #" << id << " ("
<< symbolTable.lookupSymbol(id) << "):";
if (t != -1)
cout << " default\n";
else {
cout << "\n";
f->dump();
cout << "\n";
}
}
}
}
if (options.mode != TREE &&
(options.graphvizSatisfyingEx || options.graphvizCounterEx ||
options.inheritedAcceptance))
cout << "Warning: options -gc, -gs, and -h are only used in tree mode\n";
if (options.mode == TREE && options.graphvizDFA)
cout << "Warning: option -gw is only used in linear mode\n";
if (options.mode == TREE && (options.dump || options.whole) &&
!options.externalWhole)
printGuide();
///////// CODE GENERATION ////////////////////////////////////////////////
if (options.printProgress)
cout << "\nCODE GENERATION\n";
Timer timer_gencode;
timer_gencode.start();
// Generate code
codeTable = new CodeTable;
VarCode formulaCode = ast->formula->makeCode();
VarCode assertionCode = ast->assertion->makeCode();
Deque<VarCode> verifyCode;
/* #warning NEW: 'VERIFY' */
for (Deque<ASTForm *>::iterator i = ast->verifyformlist.begin();
i != ast->verifyformlist.end(); i++)
verifyCode.push_back((*i)->makeCode());
// Implicitly assert restrictions for all global variables
for (IdentList::iterator i = ast->globals.begin();
i != ast->globals.end(); i++)
assertionCode = andList(assertionCode, getRestriction(*i, NULL));
// Restrict assertion if not trivial
if (assertionCode.code->kind != cTrue)
assertionCode = codeTable->insert
(new Code_Restrict(assertionCode, assertionCode.code->pos));
// Add assertion to main formula and to all verify formulas
for (Deque<VarCode>::iterator i = verifyCode.begin();
i != verifyCode.end(); i++) {
assertionCode.code->refs++;
*i = andList(*i, VarCode(copy(assertionCode.vars), assertionCode.code));
}
formulaCode = andList(formulaCode, assertionCode);
timer_gencode.stop();
if (options.printProgress) {
codeTable->print_statistics();
/* if (options.dump && options.statistics)
codeTable->print_sizes(); */
cout << "Time: ";
timer_gencode.print();
}
///////// REORDER BDD OFFSETS ////////////////////////////////////////////
if (options.reorder >= 1) {
Timer timer_reorder;
timer_reorder.start();
if (options.printProgress)
cout << "\nREORDERING\n";
// reorder using heuristics
offsets.reorder();
// regenerate DAG in new codetable
CodeTable *oldCodeTable = codeTable, *newCodeTable = new CodeTable;
IdentList emptylist;
codeTable = newCodeTable;
regenerate = true; // force making new nodes
VarCode newcode = formulaCode.substCopy(&emptylist, &emptylist);
Deque<VarCode> newverifycode;
for (Deque<VarCode>::iterator i = verifyCode.begin();
i != verifyCode.end(); i++)
newverifycode.push_back((*i).substCopy(&emptylist, &emptylist));
codeTable->clearSCTable();
regenerate = false;
codeTable = oldCodeTable;
formulaCode.remove();
for (Deque<VarCode>::iterator i = verifyCode.begin();
i != verifyCode.end(); i++)
(*i).remove();
formulaCode = newcode;
verifyCode.reset();
for (Deque<VarCode>::iterator i = newverifycode.begin();
i != newverifycode.end(); i++)
verifyCode.push_back(*i);
delete oldCodeTable;
codeTable = newCodeTable;
if (options.printProgress) {
codeTable->print_statistics2();
cout << "Time: ";
timer_reorder.print();
}
}
///////// REDUCTION AND CODE DUMPING /////////////////////////////////////
if (options.optimize >= 1) {
if (options.printProgress)
cout << "\nREDUCTION\n";
Timer timer_reduction;
timer_reduction.start();
// Reduce
formulaCode.reduceAll(&verifyCode);
timer_reduction.stop();
if (options.printProgress) {
codeTable->print_reduction_statistics();
/* if (options.dump && options.statistics)
codeTable->print_sizes(); */
cout << "Time: ";
timer_reduction.print();
}
}
if (options.dump) {
// Dump symboltable
symbolTable.dump();
// Dump code
cout << "\nMain formula:\n";
formulaCode.dump();
cout << "\n\n";
Deque<VarCode>::iterator i;
Deque<char *>::iterator j;
for (i = verifyCode.begin(), j = ast->verifytitlelist.begin();
i != verifyCode.end(); i++, j++) {
cout << "Formula " << *j << ":\n";
(*i).dump();
cout << "\n\n";
}
}
if (options.graphvizDAG) {
printf("digraph MONA_CODE_DAG {\n"
" size = \"7.5,10.5\";\n"
" main [shape = plaintext];\n"
" main -> L%lx;\n",
(unsigned long) formulaCode.code);
formulaCode.code->viz();
Deque<VarCode>::iterator i;
Deque<char *>::iterator j;
for (i = verifyCode.begin(), j = ast->verifytitlelist.begin();
i != verifyCode.end(); i++, j++) {
printf(" \"%s\" [shape = plaintext];\n"
" \"%s\" -> L%lx;\n",
*j, *j, (unsigned long) (*i).code);
(*i).code->viz();
}
formulaCode.unmark();
for (Deque<VarCode>::iterator i = verifyCode.begin();
i != verifyCode.end(); i++)
(*i).unmark();
cout << "}\n";
}
///////// AUTOMATON CONSTRUCTION /////////////////////////////////////////
// Make variable lists
Deque<char *> *verifytitlelist = ast->verifytitlelist.copy();
if (lastPosVar != -1)
ast->globals.remove(lastPosVar);
if (allPosVar != -1)
ast->globals.remove(allPosVar);
ast->globals.sort(); // sort by id (= index)
int numVars = ast->globals.size();
int ix = 0;
char **vnames = new char*[numVars];
unsigned *offs = new unsigned[numVars];
char *types = new char[numVars];
int **univs = new int*[numVars];
int *trees = new int[numVars];
SSSet *statespaces = new SSSet[numVars];
IdentList sign, freeVars;
IdentList::iterator id;
for (id = ast->globals.begin(); id != ast->globals.end(); id++, ix++) {
statespaces[ix] = stateSpaces(*id);
vnames[ix] = symbolTable.lookupSymbol(*id);
offs[ix] = offsets.off(*id);
sign.push_back(ix);
freeVars.push_back(*id);
switch (symbolTable.lookupType(*id)) {
case VarnameTree:
trees[ix] = 1;
break;
default:
trees[ix] = 0;
}
IdentList *uu = symbolTable.lookupUnivs(*id);
if (uu) {
unsigned j;
univs[ix] = new int[uu->size()+1];
for (j = 0; j < uu->size(); j++)
univs[ix][j] = symbolTable.lookupUnivNumber(uu->get(j));
univs[ix][j] = -1;
}
else
univs[ix] = 0;
switch (symbolTable.lookupType(*id))
{
case Varname0:
types[ix] = 0;
break;
case Varname1:
types[ix] = 1;
break;
default:
types[ix] = 2;
break;
}
}
if (options.printProgress)
cout << "\nAUTOMATON CONSTRUCTION\n";
Timer timer_automaton;
timer_automaton.start();
DFA *dfa = 0;
Deque<DFA *> dfalist;
GTA *gta = 0;
Deque<GTA *> gtalist;
// Initialize
bdd_init();
codeTable->init_print_progress();
if (options.mode != TREE) {
// Generate DFAs
dfa = formulaCode.DFATranslate();
if (lastPosVar != -1)
dfa = st_dfa_lastpos(dfa, lastPosVar);
if (allPosVar != -1)
dfa = st_dfa_allpos(dfa, allPosVar);
for (Deque<VarCode>::iterator i = verifyCode.begin();
i != verifyCode.end(); i++) {
DFA *d = (*i).DFATranslate();
if (lastPosVar != -1)
d = st_dfa_lastpos(d, lastPosVar);
if (allPosVar != -1)
d = st_dfa_allpos(d, allPosVar);
dfalist.push_back(d);
}
}
else {
// Generate GTAs
gta = formulaCode.GTATranslate();
if (allPosVar != -1)
gta = st_gta_allpos(gta, allPosVar);
for (Deque<VarCode>::iterator i = verifyCode.begin();
i != verifyCode.end(); i++) {
GTA *g = (*i).GTATranslate();
if (allPosVar != -1)
g = st_gta_allpos(g, allPosVar);
gtalist.push_back(g);
}
}
formulaCode.remove();
for (Deque<VarCode>::iterator i = verifyCode.begin();
i != verifyCode.end(); i++)
(*i).remove();
timer_automaton.stop();
if (options.printProgress) {
if (options.statistics)
cout << "Total automaton construction time: ";
else
cout << "Time: ";
timer_automaton.print();
}
delete ast;
delete codeTable;
///////// PRINT AUTOMATON ////////////////////////////////////////////////
DFA *dfa2 = dfa;
GTA *gta2 = gta;
Deque<DFA *> *dfalist2 = &dfalist;
Deque<GTA *> *gtalist2 = >alist;
if (options.whole &&
!options.externalWhole)
cout << "\n";
if (options.unrestrict) {
// Unrestrict automata
if (options.mode != TREE) {
DFA *t = dfaCopy(dfa2);
dfaUnrestrict(t);
dfa2 = dfaMinimize(t);
dfaFree(t);
dfalist2 = new Deque<DFA *>;
for (Deque<DFA *>::iterator i = dfalist.begin(); i != dfalist.end(); i++) {
t = dfaCopy(*i);
dfaUnrestrict(t);
dfalist2->push_back(dfaMinimize(t));
dfaFree(t);
}
}
else {
GTA *t = gtaCopy(gta2);
gtaUnrestrict(t);
gta2 = gtaMinimize(t);
gtaFree(t);
gtalist2 = new Deque<GTA *>;
for (Deque<GTA *>::iterator i = gtalist.begin(); i != gtalist.end(); i++) {
t = gtaCopy(*i);
gtaUnrestrict(t);
gtalist2->push_back(gtaMinimize(t));
gtaFree(t);
}
}
}
if (options.whole)
// Print whole automaton
if (options.mode != TREE) {
if (options.externalWhole) {
if (!dfalist.empty())
cout << "Main formula:\n";
DFA *t = dfaCopy(dfa2);
st_dfa_replace_indices(t, &sign, &freeVars, false, true);
dfaExport(t, 0, numVars, vnames, types);
dfaFree(t);
Deque<DFA *>::iterator i;
Deque<char *>::iterator j;
for (i = dfalist2->begin(), j = verifytitlelist->begin();
i != dfalist2->end(); i++, j++) {
cout << "\nFormula " << *j << ":\n";
t = dfaCopy(*i);
st_dfa_replace_indices(t, &sign, &freeVars, false, true);
dfaExport(t, 0, numVars, vnames, types);
dfaFree(t);
}
}
else if (options.graphvizDFA) {
dfaPrintGraphviz(dfa2, numVars, offs);
for (Deque<DFA *>::iterator i = dfalist2->begin(); i != dfalist2->end(); i++)
dfaPrintGraphviz(*i, numVars, offs);
}
else {
if (!dfalist.empty())
cout << "Main formula:\n";
dfaPrint(dfa2, numVars, vnames, offs);
Deque<DFA *>::iterator i;
Deque<char *>::iterator j;
for (i = dfalist2->begin(), j = verifytitlelist->begin();
i != dfalist2->end(); i++, j++) {
cout << "\nFormula " << *j << ":\n";
dfaPrint(*i, numVars, vnames, offs);
}
}
}
else {
if (options.externalWhole) {
if (!gtalist.empty())
cout << "Main formula:\n";
GTA *t = gtaCopy(gta2);
st_gta_replace_indices(t, &sign, &freeVars, false, true);
gtaExport(t, 0, numVars, vnames, types, statespaces,
options.inheritedAcceptance);
gtaFree(t);
Deque<GTA *>::iterator i;
Deque<char *>::iterator j;
for (i = gtalist2->begin(), j = verifytitlelist->begin();
i != gtalist2->end(); i++, j++) {
cout << "\nFormula " << *j << ":\n";
t = gtaCopy(*i);
st_gta_replace_indices(t, &sign, &freeVars, false, true);
gtaExport(t, 0, numVars, vnames, types, statespaces,
options.inheritedAcceptance);
gtaFree(t);
}
}
else {
if (!gtalist.empty())
cout << "Main formula:\n";
gtaPrint(gta2, offs, numVars, vnames,
options.inheritedAcceptance);
Deque<GTA *>::iterator i;
Deque<char *>::iterator j;
for (i = gtalist2->begin(), j = verifytitlelist->begin();
i != gtalist2->end(); i++, j++) {
cout << "\nFormula " << *j << ":\n";
gtaPrint(*i, offs, numVars, vnames,
options.inheritedAcceptance);
}
}
}
else if (options.analysis &&
!options.graphvizSatisfyingEx &&
!options.graphvizCounterEx &&
options.printProgress) {
// Print summary only
if (options.mode != TREE) {
if (!dfalist.empty())
cout << "Main formula:";
dfaPrintVitals(dfa2);
Deque<DFA *>::iterator i;
Deque<char *>::iterator j;
for (i = dfalist2->begin(), j = verifytitlelist->begin();
i != dfalist2->end(); i++, j++) {
cout << "\nFormula " << *j << ":";
dfaPrintVitals(*i);
}
}
else {
if (!gtalist.empty())
cout << "Main formula:";
gtaPrintTotalSize(gta2);
Deque<GTA *>::iterator i;
Deque<char *>::iterator j;
for (i = gtalist2->begin(), j = verifytitlelist->begin();
i != gtalist2->end(); i++, j++) {
cout << "\nFormula " << *j << ":";
gtaPrintTotalSize(*i);
}
}
}
if (dfa2 != dfa) {
dfaFree(dfa2);
for (Deque<DFA *>::iterator i = dfalist2->begin(); i != dfalist2->end(); i++)
dfaFree(*i);
delete dfalist2;
}
if (gta2 != gta) {
gtaFree(gta2);
for (Deque<GTA *>::iterator i = gtalist2->begin(); i != gtalist2->end(); i++)
gtaFree(*i);
delete gtalist2;
}
///////// AUTOMATON ANALYSIS /////////////////////////////////////////////
if (options.analysis) {
if (options.printProgress)
cout << "\nANALYSIS\n";
if (options.mode != TREE) {
if (!dfalist.empty())
cout << "Main formula:\n";
dfaAnalyze(dfa, numVars, vnames, offs, types,
options.treemodeOutput);
Deque<DFA *>::iterator i;
Deque<char *>::iterator j;
for (i = dfalist.begin(), j = verifytitlelist->begin();
i != dfalist.end(); i++, j++) {
cout << "\nFormula " << *j << ":\n";
dfaAnalyze(*i, numVars, vnames, offs, types,
options.treemodeOutput);
}
}
else {
if (numTypes == 0 || options.treemodeOutput) {
if (!gtalist.empty())
cout << "Main formula:\n";
gtaAnalyze(gta, numVars, vnames, offs,
options.graphvizSatisfyingEx,
options.graphvizCounterEx);
Deque<GTA *>::iterator i;
Deque<char *>::iterator j;
for (i = gtalist.begin(), j = verifytitlelist->begin();
i != gtalist.end(); i++, j++) {
cout << "\nFormula " << *j << ":\n";
gtaAnalyze(*i, numVars, vnames, offs,
options.graphvizSatisfyingEx,
options.graphvizCounterEx);
}
}
else {
if (options.graphvizSatisfyingEx ||
options.graphvizCounterEx)
cout << "Graphviz output of typed trees not implemented.\n";
if (!gtalist.empty())
cout << "Main formula:\n";
gtaTypeAnalyze(gta, numVars, vnames, types, offs, univs, trees);
Deque<GTA *>::iterator i;
Deque<char *>::iterator j;
for (i = gtalist.begin(), j = verifytitlelist->begin();
i != gtalist.end(); i++, j++) {
cout << "\nFormula " << *j << ":\n";
gtaTypeAnalyze(*i, numVars, vnames, types, offs, univs, trees);
}
}
}
}
///////// CLEAN UP ///////////////////////////////////////////////////////
if (options.mode != TREE) {
dfaFree(dfa);
for (Deque<DFA *>::iterator i = dfalist.begin(); i != dfalist.end(); i++)
dfaFree(*i);
}
else {
gtaFree(gta);
for (Deque<GTA *>::iterator i = gtalist.begin(); i != gtalist.end(); i++)
gtaFree(*i);
freeGuide();
}
delete verifytitlelist;
Deque<FileSource *>::iterator i;
for (i = source.begin(); i != source.end(); i++)
delete *i;
for (ix = 0; ix < numVars; ix++) {
delete[] univs[ix];
mem_free(statespaces[ix]);
}
delete[] statespaces;
delete[] vnames;
delete[] offs;
delete[] types;
delete[] univs;
delete[] trees;
freeTreetypes();
if (options.statistics)
print_statistics();
if (options.time) {
timer_total.stop();
cout << "\nTotal time: ";
timer_total.print();
print_timing();
}
else if (options.printProgress) {
timer_total.stop();
cout << "\nTotal time: ";
timer_total.print();
}
#ifdef MAXALLOCATED
cout << "Maximum space allocated: " << (maxallocated+524288)/1048576 << " MB\n";
#endif
}
void AddElements(int size)
{
fori(i, size)
deque_int.push_back(random(engine));
}
TEST(Deque, push_back)
{
Deque d;
d.push_back(0);
CHECK(1 == d.size());
}
void testIteratorOperations() {
Deque<int> deque;
MersenneTwisterRandom rng;
int n_ops = rng.randInt(100);
for (int i = 0; i < n_ops; ++i) {
if (rng.randInt(10) < 3 && !deque.empty()) {
deque.pop_front();
} else {
deque.push_back(rng.randInt());
}
}
// Test iterator unary operators
{
for (Deque<int>::iterator it = deque.begin(); it != deque.end(); ) {
Deque<int>::iterator it1 = it;
Deque<int>::iterator it2 = it;
SINVARIANT(it1 == it2);
Deque<int>::iterator it3 = it1++;
INVARIANT(it3 == it && it3 != it1 && it1 != it2,
"return unchanged && return different from iterator && iterator changed");
Deque<int>::iterator it4 = ++it2;
INVARIANT(it4 != it && it4 == it1 && it2 == it1,
"return changed && return == updated && two updates same");
it = it4;
}
}
// Test distance operators
Deque<int>::iterator it_forward = deque.begin();
Deque<int>::iterator it_backward = deque.end();
ptrdiff_t dist_from_start = 0; // start can be .begin() or .end()
ptrdiff_t dist_from_finish = deque.end() - deque.begin(); // finish can be .end() or .begin()
for (; it_forward != deque.end(); ++dist_from_start, --dist_from_finish) {
SINVARIANT(it_backward - it_forward == dist_from_finish - dist_from_start);
SINVARIANT(it_forward + dist_from_finish == deque.end());
SINVARIANT(it_backward - dist_from_finish == deque.begin());
SINVARIANT((it_forward < it_backward) == (dist_from_start < dist_from_finish));
SINVARIANT((it_forward <= it_backward) == (dist_from_start <= dist_from_finish));
SINVARIANT((it_forward > it_backward) == (dist_from_start > dist_from_finish));
SINVARIANT((it_forward >= it_backward) == (dist_from_start >= dist_from_finish));
Deque<int>::iterator temp_a(it_forward);
Deque<int>::iterator temp_b;
temp_b = it_backward;
SINVARIANT(temp_b - temp_a == dist_from_finish - dist_from_start);
temp_a += dist_from_finish;
SINVARIANT(temp_a == deque.end());
temp_b -= dist_from_finish;
SINVARIANT(temp_b == deque.begin());
if (rng.randBool()) { // Exercise both variants of the increment/decrement operators
++it_forward;
--it_backward;
} else {
it_forward++;
it_backward--;
}
}
SINVARIANT(it_backward == deque.begin());
SINVARIANT(static_cast<size_t>(dist_from_start) == deque.size());
SINVARIANT(dist_from_finish == 0);
}
void
DequeTest()
{
Deque<int> testq;
Deque<int> testBad(256);
for(int i=0;i<512;i++) {
testBad.push_back(i);
}
for(int i=0;i<512;i++) {
INVARIANT(testBad.empty() == false && testBad.front() == i,
"simple test failed?!");
testBad.pop_front();
}
// test empty->size1->empty
for(int size1=1;size1<2000;size1++) {
INVARIANT(testq.empty()==true,"internal");
for(int j=0;j<size1;j++) {
testq.push_back(j);
INVARIANT(testq.empty()==false,"internal");
}
for(int j=0;j<size1;j++) {
INVARIANT(testq.empty()==false,"internal");
INVARIANT(testq.front() == j,
boost::format("Internal Error: %d/%d")
% size1 % j);
testq.pop_front();
}
INVARIANT(testq.empty()==true,"internal");
}
printf("pass empty->full->empty tests\n");
// test empty->size1, size2 add/remove, ->empty
for(int size1=1;size1<150;size1++) {
for(int size2=1;size2<400;size2++) {
INVARIANT(testq.empty()==true,"internal");
for(int j=0;j<size1;j++) {
testq.push_back(j);
INVARIANT(testq.empty()==false,"internal");
}
for(int j=0;j<size2;j++) {
INVARIANT(testq.empty()==false,"internal");
INVARIANT(testq.front() == j,
boost::format("Internal Error: %d/%d/%d")
% size1 % size2 %j);
testq.pop_front();
testq.push_back((j+size1));
}
for(int j=size2;j<size1+size2;j++) {
INVARIANT(testq.empty()==false,"internal");
int t = testq.front();
testq.pop_front();
INVARIANT(t == j,
boost::format("Internal Error: %d/%d/%d/%d")
% t % size1 % size2 % j);
}
INVARIANT(testq.empty()==true,"internal");
}
}
printf("pass partial fill tests\n");
}
int main(int argc, char *argv[])
{
Deque *deque;
char line[4096];
size_t len;
void *data;
size_t size;
if (argc == 1)
{
deque = Memory_Deque_create();
}
else
if (argc == 2 && argv[1][0] != '-')
{
deque = File_Deque_create(argv[1]);
}
else
{
printf("Usage:\n"
" test-deque -- use the in-memory deque\n"
" test-deque <path> -- use the file-based deque\n"
"\n"
"Commands:\n"
" destroy -- destroy the deque and exit\n"
" empty -- report if the deque is empty\n"
" size -- print number of elements in the deque\n"
" push_back -- add element at the back\n"
" push_front -- add element at the front\n"
" get_back -- print element at the back\n"
" get_front -- print element at the front\n"
" pop_back -- remove element at the back\n"
" pop_front -- remove element at the front\n");
return 1;
}
if (deque == NULL)
{
fprintf(stderr, "Unable to create deque!\n");
exit(1);
}
while (fgets(line, sizeof(line), stdin) != NULL)
{
/* Determine length and strip trailing newline character */
len = strlen(line);
if (len == 0)
break;
if (line[len - 1] == '\n')
{
line[len - 1] = '\0';
len -= 1;
}
if (strcmp(line, "destroy") == 0)
{
break;
}
else
if (strcmp(line, "empty") == 0)
{
printf("empty=%s\n", deque->empty(deque) ? "true" : "false");
}
else
if (strcmp(line, "size") == 0)
{
printf("size=%ld\n", (long)deque->size(deque));
}
else
if (strncmp(line, "push_back ", 10) == 0)
{
if (!deque->push_back(deque, line + 10, len - 10))
printf("push_back failed!\n");
}
else
if (strncmp(line, "push_front ", 11) == 0)
{
if (!deque->push_front(deque, line + 11, len - 11))
printf("push_front failed!\n");
}
else
if (strcmp(line, "get_back") == 0)
{
if (!deque->get_back(deque, &data, &size))
printf("get_back failed!\n");
else
{
fwrite(data, size, 1, stdout);
fputc('\n', stdout);
}
}
else
if (strcmp(line, "get_front") == 0)
{
if (!deque->get_front(deque, &data, &size))
printf("get_front failed!\n");
else
{
fwrite(data, size, 1, stdout);
fputc('\n', stdout);
}
}
else
if (strcmp(line, "pop_back") == 0)
{
if (!deque->pop_back(deque))
printf("pop_back failed!\n");
}
else
if (strcmp(line, "pop_front") == 0)
{
if (!deque->pop_front(deque))
printf("pop_front failed!\n");
}
else
{
printf("Unrecognized input line: %s!\n", line);
}
}
deque->destroy(deque);
return 0;
}
