From 149f5cd83b7a176c68e4293ab5c390ea5d8a3493 Mon Sep 17 00:00:00 2001
From: Jan Travnicek <Jan.Travnicek@fit.cvut.cz>
Date: Mon, 8 Jun 2015 17:06:10 +0200
Subject: [PATCH] + measurement to all algoritm access binaries
---
aarbology2/src/aarbology.cpp | 1 +
acompaction2/src/acompaction.cpp | 29 +++-
acompare2/src/acompare.cpp | 30 +++-
aconversions2/src/ConversionHandler.cpp | 180 ++++++++++++++++++------
aconversions2/src/aconversion.cpp | 15 ++
aconvert2/src/aconvert.cpp | 78 ++++++++--
aderivation2/src/aderivation.cpp | 28 +++-
adeterminize2/src/adeterminize.cpp | 27 +++-
aepsilon2/src/aepsilon.cpp | 106 +++++++++++---
agenerate2/src/agenerate.cpp | 26 +++-
aintegral2/src/aintegral.cpp | 28 +++-
alangop2/src/alangop.cpp | 102 ++++++++++++--
aminimize2/src/aminimize.cpp | 34 ++++-
anormalize2/src/anormalize.cpp | 120 +++++++++++++---
arand2/src/arand.cpp | 58 ++++++--
araw2/src/araw.cpp | 24 ++++
arename2/src/arename.cpp | 28 +++-
areverse2/src/areverse.cpp | 28 +++-
arun2/src/arun.cpp | 48 +++++--
astat2/src/astat.cpp | 41 ++++--
astringology2/src/astringology.cpp | 89 ++++++++++--
atrim2/src/atrim.cpp | 56 ++++++--
tniceprint/src/tniceprint.cpp | 22 +++
23 files changed, 1029 insertions(+), 169 deletions(-)
diff --git a/aarbology2/src/aarbology.cpp b/aarbology2/src/aarbology.cpp
index 4ba348d530..9babf7af9a 100644
--- a/aarbology2/src/aarbology.cpp
+++ b/aarbology2/src/aarbology.cpp
@@ -54,6 +54,7 @@ int main(int argc, char* argv[]) {
std::chrono::measurements::start("Overal", std::chrono::measurements::Type::OVERALL);
std::chrono::measurements::start("Input read", std::chrono::measurements::Type::AUXILARY);
+
std::deque<std::deque<sax::Token>> subjectTokens;
if(subject.isSet()) {
for(const std::string& fileName : subject.getValue()) {
diff --git a/acompaction2/src/acompaction.cpp b/acompaction2/src/acompaction.cpp
index 04c3d201d0..a093feaa6d 100644
--- a/acompaction2/src/acompaction.cpp
+++ b/acompaction2/src/acompaction.cpp
@@ -11,6 +11,7 @@
#include "exception/AlibException.h"
#include "factory/XmlDataFactory.hpp"
#include "automaton/transform/Compaction.h"
+#include <chrono>
int main(int argc, char** argv) {
@@ -20,8 +21,17 @@ int main(int argc, char** argv) {
TCLAP::ValueArg<std::string> input( "i", "input", "Automaton to compactify", false, "-", "file");
cmd.add( input );
+ TCLAP::SwitchArg measure( "m", "measure", "Measure times", false);
+ cmd.add( measure );
+
+ TCLAP::SwitchArg verbose( "v", "verbose", "Be verbose", false);
+ cmd.add( verbose );
+
cmd.parse(argc, argv);
+ std::chrono::measurements::start("Overal", std::chrono::measurements::Type::OVERALL);
+ std::chrono::measurements::start("Input read", std::chrono::measurements::Type::AUXILARY);
+
std::deque<sax::Token> tokens;
if(input.isSet()) {
if(input.getValue() == "-") {
@@ -33,9 +43,24 @@ int main(int argc, char** argv) {
sax::SaxParseInterface::parseStdin(tokens);
}
- alib::XmlDataFactory::toStdout(automaton::transform::Compaction::convert(alib::XmlDataFactory::fromTokens<automaton::Automaton>(tokens)));
- return 0;
+ automaton::Automaton automaton = alib::XmlDataFactory::fromTokens<automaton::Automaton>(tokens);
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Algorithm", std::chrono::measurements::Type::MAIN);
+
+ automaton::Automaton res = automaton::transform::Compaction::convert(automaton);
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Output write", std::chrono::measurements::Type::AUXILARY);
+
+ alib::XmlDataFactory::toStdout(res);
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::end();
+
+ if(measure.getValue()) std::clog << std::chrono::measurements::results() << std::endl;
+
+ return 0;
} catch (const exception::AlibException& exception) {
alib::XmlDataFactory::toStdout(exception);
return 1;
diff --git a/acompare2/src/acompare.cpp b/acompare2/src/acompare.cpp
index 36e8fa8bd4..d7b1a8650a 100644
--- a/acompare2/src/acompare.cpp
+++ b/acompare2/src/acompare.cpp
@@ -25,8 +25,17 @@ int main(int argc, char** argv) {
TCLAP::UnlabeledValueArg<std::string> input2( "input2", "The second input to compare", true, "-", "file");
cmd.add( input2 );
+ TCLAP::SwitchArg measure( "m", "measure", "Measure times", false);
+ cmd.add( measure );
+
+ TCLAP::SwitchArg verbose( "v", "verbose", "Be verbose", false);
+ cmd.add( verbose );
+
cmd.parse(argc, argv);
+ std::chrono::measurements::start("Overal", std::chrono::measurements::Type::OVERALL);
+ std::chrono::measurements::start("Input read", std::chrono::measurements::Type::AUXILARY);
+
std::deque<sax::Token> tokens1;
if(input1.isSet()) {
if(input1.getValue() == "-") {
@@ -57,23 +66,32 @@ int main(int argc, char** argv) {
if(alib::XmlDataFactory::first<exception::AlibException>(tokens2)) std::cerr << alib::XmlDataFactory::fromTokens<exception::AlibException>(tokens2).getCause() << std::endl;
if(alib::XmlDataFactory::first<exception::AlibException>(tokens1) || alib::XmlDataFactory::first<exception::AlibException>(tokens2)) return 0;
+ int res;
+
if(alib::XmlDataFactory::first<automaton::Automaton>(tokens1) && alib::XmlDataFactory::first<automaton::Automaton>(tokens2)) {
automaton::Automaton automaton1 = alib::XmlDataFactory::fromTokens<automaton::Automaton>(tokens1);
automaton::Automaton automaton2 = alib::XmlDataFactory::fromTokens<automaton::Automaton>(tokens2);
- return AutomatonCompare::compare(automaton1, automaton2);
- }
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Compare", std::chrono::measurements::Type::MAIN);
- if(alib::XmlDataFactory::first<grammar::Grammar>(tokens1) && alib::XmlDataFactory::first<grammar::Grammar>(tokens2)) {
+ res = AutomatonCompare::compare(automaton1, automaton2);
+ } else if(alib::XmlDataFactory::first<grammar::Grammar>(tokens1) && alib::XmlDataFactory::first<grammar::Grammar>(tokens2)) {
grammar::Grammar grammar1 = alib::XmlDataFactory::fromTokens<grammar::Grammar>(tokens1);
grammar::Grammar grammar2 = alib::XmlDataFactory::fromTokens<grammar::Grammar>(tokens2);
- return GrammarCompare::compare(grammar1, grammar2);
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Compare", std::chrono::measurements::Type::MAIN);
+
+ res = GrammarCompare::compare(grammar1, grammar2);
+ } else {
+ throw exception::AlibException("Only automata and grammars can be compared.");
}
- throw exception::AlibException("Only automata and grammars can be compared.");
+ std::chrono::measurements::end();
+ std::chrono::measurements::end();
- return 2;
+ return res;
} catch (const exception::AlibException& exception) {
alib::XmlDataFactory::toStdout(exception);
return 1;
diff --git a/aconversions2/src/ConversionHandler.cpp b/aconversions2/src/ConversionHandler.cpp
index 2555aaaf09..932abdee54 100644
--- a/aconversions2/src/ConversionHandler.cpp
+++ b/aconversions2/src/ConversionHandler.cpp
@@ -101,14 +101,29 @@ void ConversionHandler::convertFAtoRE( void )
{
const automaton::Automaton automaton = alib::XmlDataFactory::fromTokens<automaton::Automaton>(m_tokens);
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Algorithm", std::chrono::measurements::Type::MAIN);
+
switch( m_algorithm ) {
- case BRZOZOWSKI_ALGEBRAIC:
- alib::XmlDataFactory::toStdout(automaton::convert::ToRegExpAlgebraic::convert( automaton ) );
- break;
+ case BRZOZOWSKI_ALGEBRAIC: {
+ regexp::RegExp regexp = automaton::convert::ToRegExpAlgebraic::convert( automaton );
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Output write", std::chrono::measurements::Type::AUXILARY);
+
+ alib::XmlDataFactory::toStdout(regexp);
+ break;
+ }
case STATE_ELIMINATION:
- case DEFAULT:
- alib::XmlDataFactory::toStdout(automaton::convert::ToRegExpStateElimination::convert(automaton));
- break;
+ case DEFAULT: {
+ regexp::RegExp regexp = automaton::convert::ToRegExpStateElimination::convert(automaton);
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Output write", std::chrono::measurements::Type::AUXILARY);
+
+ alib::XmlDataFactory::toStdout( regexp );
+ break;
+ }
default:
throw exception::AlibException( "ConversionHandler: Invalid algorithm." );
}
@@ -118,14 +133,29 @@ void ConversionHandler::convertFAtoRG( void )
{
const automaton::Automaton fsm = alib::XmlDataFactory::fromTokens<automaton::Automaton>( m_tokens );
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Algorithm", std::chrono::measurements::Type::MAIN);
+
switch( m_algorithm ) {
- case INCOMING_TRANSITIONS:
- alib::XmlDataFactory::toStdout(automaton::convert::ToGrammarLeftRG::convert(fsm));
- break;
+ case INCOMING_TRANSITIONS: {
+ grammar::Grammar grammar = automaton::convert::ToGrammarLeftRG::convert(fsm);
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Output write", std::chrono::measurements::Type::AUXILARY);
+
+ alib::XmlDataFactory::toStdout( grammar );
+ break;
+ }
case OUTGOING_TRANSITIONS:
- case DEFAULT:
- alib::XmlDataFactory::toStdout(automaton::convert::ToGrammarRightRG::convert(fsm));
- break;
+ case DEFAULT: {
+ grammar::Grammar grammar = automaton::convert::ToGrammarRightRG::convert(fsm);
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Output write", std::chrono::measurements::Type::AUXILARY);
+
+ alib::XmlDataFactory::toStdout(grammar);
+ break;
+ }
default:
throw exception::AlibException( "ConversionHandler: Invalid algorithm." );
}
@@ -137,17 +167,38 @@ void ConversionHandler::convertREtoFA( void )
{
const regexp::RegExp regexp = alib::XmlDataFactory::fromTokens<regexp::RegExp>(m_tokens);
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Algorithm", std::chrono::measurements::Type::MAIN);
+
switch( m_algorithm ) {
- case BRZOZOWSKI_DERIVATION:
- alib::XmlDataFactory::toStdout(regexp::convert::ToAutomatonDerivation::convert(regexp));
- break;
- case THOMPSON_NFA:
- alib::XmlDataFactory::toStdout(regexp::convert::ToAutomatonThompson::convert(regexp));
- break;
+ case BRZOZOWSKI_DERIVATION: {
+ automaton::Automaton automaton = regexp::convert::ToAutomatonDerivation::convert(regexp);
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Output write", std::chrono::measurements::Type::AUXILARY);
+
+ alib::XmlDataFactory::toStdout(automaton);
+ break;
+ }
+ case THOMPSON_NFA: {
+ automaton::Automaton automaton = regexp::convert::ToAutomatonThompson::convert(regexp);
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Output write", std::chrono::measurements::Type::AUXILARY);
+
+ alib::XmlDataFactory::toStdout(automaton);
+ break;
+ }
case GLUSHKOV_NFA:
- case DEFAULT:
- alib::XmlDataFactory::toStdout(regexp::convert::ToAutomatonGlushkov::convert(regexp));
- break;
+ case DEFAULT: {
+ automaton::NFA automaton = regexp::convert::ToAutomatonGlushkov::convert(regexp);
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Output write", std::chrono::measurements::Type::AUXILARY);
+
+ alib::XmlDataFactory::toStdout(automaton);
+ break;
+ }
default:
throw exception::AlibException( "ConversionHandler: Invalid algorithm." );
}
@@ -157,14 +208,29 @@ void ConversionHandler::convertREtoRG( void )
{
const regexp::RegExp regexp = alib::XmlDataFactory::fromTokens<regexp::RegExp>(m_tokens);
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Algorithm", std::chrono::measurements::Type::MAIN);
+
switch(m_algorithm) {
- case BRZOZOWSKI_DERIVATION:
- alib::XmlDataFactory::toStdout(regexp::convert::ToGrammarRightRGDerivation::convert(regexp));
- break;
+ case BRZOZOWSKI_DERIVATION: {
+ grammar::RightRG grammar = regexp::convert::ToGrammarRightRGDerivation::convert(regexp);
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Output write", std::chrono::measurements::Type::AUXILARY);
+
+ alib::XmlDataFactory::toStdout( grammar );
+ break;
+ }
case GLUSHKOV_NFA:
- case DEFAULT:
- alib::XmlDataFactory::toStdout(regexp::convert::ToGrammarRightRGGlushkov::convert(regexp));
- break;
+ case DEFAULT: {
+ grammar::Grammar grammar = regexp::convert::ToGrammarRightRGGlushkov::convert(regexp);
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Output write", std::chrono::measurements::Type::AUXILARY);
+
+ alib::XmlDataFactory::toStdout( grammar );
+ break;
+ }
default:
throw exception::AlibException( "ConversionHandler: Invalid algorithm." );
}
@@ -174,10 +240,20 @@ void ConversionHandler::convertREtoRG( void )
void ConversionHandler::convertRGtoFA( void ) {
const grammar::Grammar grammar = alib::XmlDataFactory::fromTokens<grammar::Grammar>(m_tokens);
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Algorithm", std::chrono::measurements::Type::MAIN);
+
switch( m_algorithm ) {
- case DEFAULT:
- alib::XmlDataFactory::toStdout(grammar::convert::ToAutomaton::convert(grammar));
- break;
+ case DEFAULT: {
+ automaton::Automaton automaton = grammar::convert::ToAutomaton::convert(grammar);
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Output write", std::chrono::measurements::Type::AUXILARY);
+
+ alib::XmlDataFactory::toStdout( automaton );
+ break;
+ }
default:
throw exception::AlibException( "ConversionHandler: Invalid algorithm." );
}
@@ -186,11 +262,20 @@ void ConversionHandler::convertRGtoFA( void ) {
void ConversionHandler::convertRGtoRE( void ) {
const grammar::Grammar grammar = alib::XmlDataFactory::fromTokens<grammar::Grammar>(m_tokens);
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Algorithm", std::chrono::measurements::Type::MAIN);
+
switch( m_algorithm ) {
case BRZOZOWSKI_ALGEBRAIC:
- case DEFAULT:
- alib::XmlDataFactory::toStdout(grammar::convert::ToRegExpAlgebraic::convert(grammar));
- break;
+ case DEFAULT: {
+ regexp::RegExp regexp = grammar::convert::ToRegExpAlgebraic::convert(grammar);
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Output write", std::chrono::measurements::Type::AUXILARY);
+
+ alib::XmlDataFactory::toStdout( regexp );
+ break;
+ }
default:
throw exception::AlibException( "ConversionHandler: Invalid algorithm." );
}
@@ -199,14 +284,30 @@ void ConversionHandler::convertRGtoRE( void ) {
void ConversionHandler::convertCFGtoPDA( void )
{
const grammar::Grammar grammar = alib::XmlDataFactory::fromTokens<grammar::Grammar>(m_tokens);
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Algorithm", std::chrono::measurements::Type::MAIN);
+
switch( m_algorithm )
{
- case TOP_DOWN:
- alib::XmlDataFactory::toStdout(grammar::convert::ToAutomaton::convert(grammar));
- break;
- case BOTTOM_UP:
- alib::XmlDataFactory::toStdout(grammar::convert::ToAutomatonBottomUp::convert(grammar));
- break;
+ case TOP_DOWN: {
+ automaton::Automaton automaton = grammar::convert::ToAutomaton::convert(grammar);
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Output write", std::chrono::measurements::Type::AUXILARY);
+
+ alib::XmlDataFactory::toStdout( automaton );
+ break;
+ }
+ case BOTTOM_UP: {
+ automaton::Automaton automaton = grammar::convert::ToAutomatonBottomUp::convert(grammar);
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Output write", std::chrono::measurements::Type::AUXILARY);
+
+ alib::XmlDataFactory::toStdout( automaton );
+ break;
+ }
default:
throw exception::AlibException( "ConversionHandler: Invalid algorithm." );
}
@@ -238,7 +339,6 @@ ConversionHandler::TFormalism ConversionHandler::parseFormalismFromTokens( void
if( alib::XmlDataFactory::first<grammar::Grammar>(m_tokens) )
return REGULAR_GRAMMAR;
-
throw exception::AlibException( "ConversionHandler: Invalid input formalism." );
}
diff --git a/aconversions2/src/aconversion.cpp b/aconversions2/src/aconversion.cpp
index 25c0e320fe..9a19de88ff 100644
--- a/aconversions2/src/aconversion.cpp
+++ b/aconversions2/src/aconversion.cpp
@@ -31,8 +31,17 @@ int main(int argc, char* argv[])
TCLAP::ValueArg<std::string> input( "i", "input", "input to convert", false, "-", "file");
cmd.add( input );
+ TCLAP::SwitchArg measure( "m", "measure", "Measure times", false);
+ cmd.add( measure );
+
+ TCLAP::SwitchArg verbose( "v", "verbose", "Be verbose", false);
+ cmd.add( verbose );
+
cmd.parse(argc, argv);
+ std::chrono::measurements::start("Overal", std::chrono::measurements::Type::OVERALL);
+ std::chrono::measurements::start("Input read", std::chrono::measurements::Type::AUXILARY);
+
std::deque<sax::Token> inputTokens;
if(input.isSet()) {
if(input.getValue() == "-") {
@@ -46,6 +55,12 @@ int main(int argc, char* argv[])
ConversionHandler conv( inputTokens, target.getValue(), algorithm.getValue() );
conv.convert( );
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::end();
+
+ if(measure.getValue()) std::clog << std::chrono::measurements::results() << std::endl;
+
return 0;
} catch(const exception::AlibException& exception) {
alib::XmlDataFactory::toStdout(exception);
diff --git a/aconvert2/src/aconvert.cpp b/aconvert2/src/aconvert.cpp
index 885ac7b7c6..eb03aa481c 100644
--- a/aconvert2/src/aconvert.cpp
+++ b/aconvert2/src/aconvert.cpp
@@ -17,44 +17,92 @@
#include "GasTexConverter.h"
void automatonFromString(std::istream& in, std::ostream& out) {
- alib::XmlDataFactory::toStream(alib::StringDataFactory::fromStream<automaton::Automaton>(in), out);
+ automaton::Automaton automaton = alib::StringDataFactory::fromStream<automaton::Automaton>(in);
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Output write", std::chrono::measurements::Type::AUXILARY);
+
+ alib::XmlDataFactory::toStream( automaton, out);
}
void grammarFromString(std::istream& in, std::ostream& out) {
- alib::XmlDataFactory::toStream(alib::StringDataFactory::fromStream<grammar::Grammar>(in), out);
+ grammar::Grammar grammar = alib::StringDataFactory::fromStream<grammar::Grammar>(in);
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Output write", std::chrono::measurements::Type::AUXILARY);
+
+ alib::XmlDataFactory::toStream( grammar, out);
}
void regexpFromString(std::istream& in, std::ostream& out) {
- alib::XmlDataFactory::toStream(alib::StringDataFactory::fromStream<regexp::RegExp>(in), out);
+ regexp::RegExp regexp = alib::StringDataFactory::fromStream<regexp::RegExp>(in);
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Output write", std::chrono::measurements::Type::AUXILARY);
+
+ alib::XmlDataFactory::toStream( regexp, out );
}
void stringFromString(std::istream& in, std::ostream& out) {
- alib::XmlDataFactory::toStream(alib::StringDataFactory::fromStream<string::String>(in), out);
+ string::String string = alib::StringDataFactory::fromStream<string::String>(in);
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Output write", std::chrono::measurements::Type::AUXILARY);
+
+ alib::XmlDataFactory::toStream(string, out);
}
void automatonToString(std::istream& in, std::ostream& out) {
- alib::StringDataFactory::toStream(alib::XmlDataFactory::fromStream<automaton::Automaton>(in), out);
+ automaton::Automaton automaton = alib::XmlDataFactory::fromStream<automaton::Automaton>(in);
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Output write", std::chrono::measurements::Type::AUXILARY);
+
+ alib::StringDataFactory::toStream( automaton, out);
}
void grammarToString(std::istream& in, std::ostream& out) {
- alib::StringDataFactory::toStream(alib::XmlDataFactory::fromStream<grammar::Grammar>(in), out);
+ grammar::Grammar grammar = alib::XmlDataFactory::fromStream<grammar::Grammar>(in);
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Output write", std::chrono::measurements::Type::AUXILARY);
+
+ alib::StringDataFactory::toStream( grammar, out);
}
void regexpToString(std::istream& in, std::ostream& out) {
- alib::StringDataFactory::toStream(alib::XmlDataFactory::fromStream<regexp::RegExp>(in), out);
+ regexp::RegExp regexp = alib::XmlDataFactory::fromStream<regexp::RegExp>(in);
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Output write", std::chrono::measurements::Type::AUXILARY);
+
+ alib::StringDataFactory::toStream( regexp, out);
}
void stringToString(std::istream& in, std::ostream& out) {
- alib::StringDataFactory::toStream(alib::XmlDataFactory::fromStream<string::String>(in), out);
+ string::String string = alib::XmlDataFactory::fromStream<string::String>(in);
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Output write", std::chrono::measurements::Type::AUXILARY);
+
+ alib::StringDataFactory::toStream( string, out);
}
void automatonToDot(std::istream& in, std::ostream& out) {
automaton::Automaton automaton = alib::XmlDataFactory::fromStream<automaton::Automaton>(in);
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Output write", std::chrono::measurements::Type::AUXILARY);
+
DotConverter::convert(automaton, out);
}
void automatonToGasTex(std::istream& in, std::ostream& out) {
automaton::Automaton automaton = alib::XmlDataFactory::fromStream<automaton::Automaton>(in);
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Output write", std::chrono::measurements::Type::AUXILARY);
+
GasTexConverter::convert(automaton, out);
}
@@ -95,8 +143,17 @@ int main(int argc, char* argv[]) {
TCLAP::ValueArg<std::string> input( "i", "input", "Input file", false, "-", "file");
cmd.add( input );
+ TCLAP::SwitchArg measure( "m", "measure", "Measure times", false);
+ cmd.add( measure );
+
+ TCLAP::SwitchArg verbose( "v", "verbose", "Be verbose", false);
+ cmd.add( verbose );
+
cmd.parse(argc, argv);
+ std::chrono::measurements::start("Overal", std::chrono::measurements::Type::OVERALL);
+ std::chrono::measurements::start("Input read", std::chrono::measurements::Type::AUXILARY);
+
std::istream* in = NULL;
if(input.isSet()) {
if(input.getValue() == "-") {
@@ -134,6 +191,11 @@ int main(int argc, char* argv[]) {
delete in;
}
+ std::chrono::measurements::end();
+ std::chrono::measurements::end();
+
+ if(measure.getValue()) std::clog << std::chrono::measurements::results() << std::endl;
+
return 0;
} catch (const exception::AlibException& exception) {
alib::XmlDataFactory::toStdout(exception);
diff --git a/aderivation2/src/aderivation.cpp b/aderivation2/src/aderivation.cpp
index c1da231f41..625ff05d61 100644
--- a/aderivation2/src/aderivation.cpp
+++ b/aderivation2/src/aderivation.cpp
@@ -21,8 +21,17 @@ int main(int argc, char** argv) {
TCLAP::ValueArg<std::string> regexp( "r", "regexp", "Regexp to derivate", false, "-", "file");
cmd.add( regexp );
+ TCLAP::SwitchArg measure( "m", "measure", "Measure times", false);
+ cmd.add( measure );
+
+ TCLAP::SwitchArg verbose( "v", "verbose", "Be verbose", false);
+ cmd.add( verbose );
+
cmd.parse(argc, argv);
+ std::chrono::measurements::start("Overal", std::chrono::measurements::Type::OVERALL);
+ std::chrono::measurements::start("Input read", std::chrono::measurements::Type::AUXILARY);
+
std::deque<sax::Token> stringTokens;
if(string.isSet()) {
if(string.getValue() == "-") {
@@ -45,7 +54,24 @@ int main(int argc, char** argv) {
sax::SaxParseInterface::parseStdin(regexpTokens);
}
- alib::XmlDataFactory::toStdout(regexp::RegExpDerivation::derivation(alib::XmlDataFactory::fromTokens<regexp::RegExp>(regexpTokens), alib::XmlDataFactory::fromTokens<string::LinearString>(stringTokens)));
+ string::LinearString stringData = alib::XmlDataFactory::fromTokens<string::LinearString>(stringTokens);
+ regexp::RegExp regexpData = alib::XmlDataFactory::fromTokens<regexp::RegExp>(regexpTokens);
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Algorithm", std::chrono::measurements::Type::MAIN);
+
+ regexp::RegExp result = regexp::RegExpDerivation::derivation(regexpData, stringData);
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Output write", std::chrono::measurements::Type::AUXILARY);
+
+ alib::XmlDataFactory::toStdout(result);
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::end();
+
+ if(measure.getValue()) std::clog << std::chrono::measurements::results() << std::endl;
+
return 0;
} catch(const exception::AlibException& exception) {
alib::XmlDataFactory::toStdout(exception);
diff --git a/adeterminize2/src/adeterminize.cpp b/adeterminize2/src/adeterminize.cpp
index ec5c98a694..8a8ff3543b 100644
--- a/adeterminize2/src/adeterminize.cpp
+++ b/adeterminize2/src/adeterminize.cpp
@@ -19,8 +19,17 @@ int main(int argc, char** argv) {
TCLAP::ValueArg<std::string> input( "i", "input", "Automaton to determinize", false, "-", "file");
cmd.add( input );
+ TCLAP::SwitchArg measure( "m", "measure", "Measure times", false);
+ cmd.add( measure );
+
+ TCLAP::SwitchArg verbose( "v", "verbose", "Be verbose", false);
+ cmd.add( verbose );
+
cmd.parse(argc, argv);
+ std::chrono::measurements::start("Overal", std::chrono::measurements::Type::OVERALL);
+ std::chrono::measurements::start("Input read", std::chrono::measurements::Type::AUXILARY);
+
std::deque<sax::Token> tokens;
if(input.isSet()) {
if(input.getValue() == "-") {
@@ -32,7 +41,23 @@ int main(int argc, char** argv) {
sax::SaxParseInterface::parseStdin(tokens);
}
- alib::XmlDataFactory::toStdout(automaton::determinize::Determinize::determinize(alib::XmlDataFactory::fromTokens<automaton::Automaton>(tokens)));
+ automaton::Automaton automaton = alib::XmlDataFactory::fromTokens<automaton::Automaton>(tokens);
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Algorithm", std::chrono::measurements::Type::MAIN);
+
+ automaton::Automaton res = automaton::determinize::Determinize::determinize(automaton);
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Output write", std::chrono::measurements::Type::AUXILARY);
+
+ alib::XmlDataFactory::toStdout(res);
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::end();
+
+ if(measure.getValue()) std::clog << std::chrono::measurements::results() << std::endl;
+
return 0;
} catch (const exception::AlibException& exception) {
alib::XmlDataFactory::toStdout(exception);
diff --git a/aepsilon2/src/aepsilon.cpp b/aepsilon2/src/aepsilon.cpp
index 32e8ec60cb..d643140a5c 100644
--- a/aepsilon2/src/aepsilon.cpp
+++ b/aepsilon2/src/aepsilon.cpp
@@ -32,8 +32,17 @@ int main(int argc, char** argv) {
TCLAP::SwitchArg efficient( "e", "efficient", "Use efficient implementation", false);
cmd.add( efficient );
+ TCLAP::SwitchArg measure( "m", "measure", "Measure times", false);
+ cmd.add( measure );
+
+ TCLAP::SwitchArg verbose( "v", "verbose", "Be verbose", false);
+ cmd.add( verbose );
+
cmd.parse(argc, argv);
+ std::chrono::measurements::start("Overal", std::chrono::measurements::Type::OVERALL);
+ std::chrono::measurements::start("Input read", std::chrono::measurements::Type::AUXILARY);
+
std::deque<sax::Token> tokens;
if(input.isSet()) {
if(input.getValue() == "-") {
@@ -46,30 +55,93 @@ int main(int argc, char** argv) {
}
if(algorithm.getValue() == "outgoing") {
- if(efficient.getValue())
- alib::XmlDataFactory::toStdout(automaton::simplify::efficient::EpsilonRemoverOutgoing::remove(alib::XmlDataFactory::fromTokens<automaton::Automaton>(tokens)));
- else
- alib::XmlDataFactory::toStdout(automaton::simplify::EpsilonRemoverOutgoing::remove(alib::XmlDataFactory::fromTokens<automaton::Automaton>(tokens)));
+ automaton::Automaton automaton = alib::XmlDataFactory::fromTokens<automaton::Automaton>(tokens);
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Algorithm", std::chrono::measurements::Type::MAIN);
+
+ if(efficient.getValue()) {
+ automaton::Automaton res = automaton::simplify::efficient::EpsilonRemoverOutgoing::remove(automaton);
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Output write", std::chrono::measurements::Type::AUXILARY);
+
+ alib::XmlDataFactory::toStdout(res);
+ } else {
+ automaton::Automaton res = automaton::simplify::EpsilonRemoverOutgoing::remove(automaton);
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Output write", std::chrono::measurements::Type::AUXILARY);
+
+ alib::XmlDataFactory::toStdout(res);
+ }
} else if(algorithm.getValue() == "incoming") {
- if(efficient.getValue())
- alib::XmlDataFactory::toStdout(automaton::simplify::efficient::EpsilonRemoverIncoming::remove(alib::XmlDataFactory::fromTokens<automaton::Automaton>(tokens)));
- else
- alib::XmlDataFactory::toStdout(automaton::simplify::EpsilonRemoverIncoming::remove(alib::XmlDataFactory::fromTokens<automaton::Automaton>(tokens)));
+ automaton::Automaton automaton = alib::XmlDataFactory::fromTokens<automaton::Automaton>(tokens);
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Algorithm", std::chrono::measurements::Type::MAIN);
+
+ if(efficient.getValue()) {
+ automaton::Automaton res = automaton::simplify::efficient::EpsilonRemoverIncoming::remove(automaton);
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Output write", std::chrono::measurements::Type::AUXILARY);
+
+ alib::XmlDataFactory::toStdout(res);
+ } else {
+ automaton::Automaton res = automaton::simplify::EpsilonRemoverIncoming::remove(automaton);
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Output write", std::chrono::measurements::Type::AUXILARY);
+
+ alib::XmlDataFactory::toStdout(res);
+ }
} else if(algorithm.getValue() == "default") {
- if(alib::XmlDataFactory::first<automaton::Automaton>(tokens))
- if(efficient.getValue())
- alib::XmlDataFactory::toStdout(automaton::simplify::EpsilonRemoverIncoming::remove(alib::XmlDataFactory::fromTokens<automaton::Automaton>(tokens)));
- else
- alib::XmlDataFactory::toStdout(automaton::simplify::efficient::EpsilonRemoverIncoming::remove(alib::XmlDataFactory::fromTokens<automaton::Automaton>(tokens)));
- else if(alib::XmlDataFactory::first<grammar::Grammar>(tokens))
- alib::XmlDataFactory::toStdout(grammar::simplify::EpsilonRemover::remove(alib::XmlDataFactory::fromTokens<grammar::Grammar>(tokens)));
- else
+ if(alib::XmlDataFactory::first<automaton::Automaton>(tokens)) {
+ automaton::Automaton automaton = alib::XmlDataFactory::fromTokens<automaton::Automaton>(tokens);
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Algorithm", std::chrono::measurements::Type::MAIN);
+
+ if(efficient.getValue()) {
+ automaton::Automaton res = automaton::simplify::EpsilonRemoverIncoming::remove(automaton);
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Output write", std::chrono::measurements::Type::AUXILARY);
+
+ alib::XmlDataFactory::toStdout(res);
+ } else {
+ automaton::Automaton res = automaton::simplify::efficient::EpsilonRemoverIncoming::remove(automaton);
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Output write", std::chrono::measurements::Type::AUXILARY);
+
+ alib::XmlDataFactory::toStdout(res);
+ }
+ } else if(alib::XmlDataFactory::first<grammar::Grammar>(tokens)) {
+ grammar::Grammar grammar = alib::XmlDataFactory::fromTokens<grammar::Grammar>(tokens);
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Algorithm", std::chrono::measurements::Type::MAIN);
+
+ grammar::Grammar res = grammar::simplify::EpsilonRemover::remove(grammar);
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Output write", std::chrono::measurements::Type::AUXILARY);
+
+ alib::XmlDataFactory::toStdout(res);
+ } else
throw exception::AlibException("Invalid formalism");
} else {
throw exception::AlibException("Invalid algorithm");
}
- return 0;
+ std::chrono::measurements::end();
+ std::chrono::measurements::end();
+
+ if(measure.getValue()) std::clog << std::chrono::measurements::results() << std::endl;
+
+ return 0;
} catch (const exception::AlibException& exception) {
alib::XmlDataFactory::toStdout(exception);
return 1;
diff --git a/agenerate2/src/agenerate.cpp b/agenerate2/src/agenerate.cpp
index 7d040e0054..f0e0af1f7c 100644
--- a/agenerate2/src/agenerate.cpp
+++ b/agenerate2/src/agenerate.cpp
@@ -24,8 +24,17 @@ int main(int argc, char* argv[]) {
TCLAP::ValueArg<std::string> grammar( "g", "grammar", "Grammar to use", false, "-", "file");
cmd.add( grammar );
+ TCLAP::SwitchArg measure( "m", "measure", "Measure times", false);
+ cmd.add( measure );
+
+ TCLAP::SwitchArg verbose( "v", "verbose", "Be verbose", false);
+ cmd.add( verbose );
+
cmd.parse(argc, argv);
+ std::chrono::measurements::start("Overal", std::chrono::measurements::Type::OVERALL);
+ std::chrono::measurements::start("Input read", std::chrono::measurements::Type::AUXILARY);
+
std::deque<sax::Token> grammarTokens;
if(grammar.isSet()) {
if(grammar.getValue() == "-") {
@@ -39,13 +48,26 @@ int main(int argc, char* argv[]) {
if( upto.isSet() ) {
grammar::Grammar grammar = alib::XmlDataFactory::fromTokens<grammar::Grammar>(grammarTokens);
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Algorithm", std::chrono::measurements::Type::MAIN);
+
std::set<string::LinearString> res = grammar::generate::GenerateUpToLength::generate(grammar, upto.getValue());
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Output write", std::chrono::measurements::Type::AUXILARY);
+
alib::XmlDataFactory::toStdout( res );
- return 0;
} else {
throw exception::AlibException( "Invalid run type" );
- return 1;
}
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::end();
+
+ if(measure.getValue()) std::clog << std::chrono::measurements::results() << std::endl;
+
+ return 0;
} catch ( const exception::AlibException & exception ) {
alib::XmlDataFactory::toStdout( exception );
return 1;
diff --git a/aintegral2/src/aintegral.cpp b/aintegral2/src/aintegral.cpp
index 30621e0b6d..ee69721452 100644
--- a/aintegral2/src/aintegral.cpp
+++ b/aintegral2/src/aintegral.cpp
@@ -21,8 +21,17 @@ int main(int argc, char** argv) {
TCLAP::ValueArg<std::string> regexp( "r", "regexp", "Regexp to derivate", false, "-", "file");
cmd.add( regexp );
+ TCLAP::SwitchArg measure( "m", "measure", "Measure times", false);
+ cmd.add( measure );
+
+ TCLAP::SwitchArg verbose( "v", "verbose", "Be verbose", false);
+ cmd.add( verbose );
+
cmd.parse(argc, argv);
+ std::chrono::measurements::start("Overal", std::chrono::measurements::Type::OVERALL);
+ std::chrono::measurements::start("Input read", std::chrono::measurements::Type::AUXILARY);
+
std::deque<sax::Token> stringTokens;
if(string.isSet()) {
if(string.getValue() == "-") {
@@ -45,7 +54,24 @@ int main(int argc, char** argv) {
sax::SaxParseInterface::parseStdin(regexpTokens);
}
- alib::XmlDataFactory::toStdout(regexp::RegExpIntegral::integral(alib::XmlDataFactory::fromTokens<regexp::RegExp>(regexpTokens), alib::XmlDataFactory::fromTokens<string::LinearString>(stringTokens)));
+ string::LinearString stringData = alib::XmlDataFactory::fromTokens<string::LinearString>(stringTokens);
+ regexp::RegExp regexpData = alib::XmlDataFactory::fromTokens<regexp::RegExp>(regexpTokens);
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Algorithm", std::chrono::measurements::Type::MAIN);
+
+ regexp::RegExp res = regexp::RegExpIntegral::integral(regexpData, stringData);
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Output write", std::chrono::measurements::Type::AUXILARY);
+
+ alib::XmlDataFactory::toStdout(res);
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::end();
+
+ if(measure.getValue()) std::clog << std::chrono::measurements::results() << std::endl;
+
return 0;
} catch(const exception::AlibException& exception) {
alib::XmlDataFactory::toStdout(exception);
diff --git a/alangop2/src/alangop.cpp b/alangop2/src/alangop.cpp
index d6dea3a435..a2808c7652 100644
--- a/alangop2/src/alangop.cpp
+++ b/alangop2/src/alangop.cpp
@@ -43,8 +43,17 @@ int main(int argc, char* argv[]) {
cmd.add( a1 );
cmd.add( a2 );
+ TCLAP::SwitchArg measure( "m", "measure", "Measure times", false);
+ cmd.add( measure );
+
+ TCLAP::SwitchArg verbose( "v", "verbose", "Be verbose", false);
+ cmd.add( verbose );
+
cmd.parse(argc,argv);
+ std::chrono::measurements::start("Overal", std::chrono::measurements::Type::OVERALL);
+ std::chrono::measurements::start("Input read", std::chrono::measurements::Type::AUXILARY);
+
std::deque<sax::Token> a1Tokens, a2Tokens;
if(a1.isSet()) {
if(a1.getValue() == "-") {
@@ -70,34 +79,97 @@ int main(int argc, char* argv[]) {
if( algorithm.getValue() == "unionEpsilon") {
automaton::Automaton automaton2 = alib::XmlDataFactory::fromTokens<automaton::Automaton>(a2Tokens);
- alib::XmlDataFactory::toStdout(automaton::transform::AutomataUnionEpsilonTransition::unification(automaton1, automaton2));
- return 0;
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Algorithm", std::chrono::measurements::Type::MAIN);
+
+ automaton::Automaton res = automaton::transform::AutomataUnionEpsilonTransition::unification(automaton1, automaton2);
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Output write", std::chrono::measurements::Type::AUXILARY);
+
+ alib::XmlDataFactory::toStdout( res );
+
} else if( algorithm.getValue() == "unionCartesian") {
automaton::Automaton automaton2 = alib::XmlDataFactory::fromTokens<automaton::Automaton>(a2Tokens);
- alib::XmlDataFactory::toStdout(automaton::transform::AutomataUnionCartesianProduct::unification(automaton1, automaton2));
- return 0;
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Algorithm", std::chrono::measurements::Type::MAIN);
+
+ automaton::Automaton res = automaton::transform::AutomataUnionCartesianProduct::unification(automaton1, automaton2);
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Output write", std::chrono::measurements::Type::AUXILARY);
+
+ alib::XmlDataFactory::toStdout( res );
} else if( algorithm.getValue() == "concatenationEpsilon") {
automaton::Automaton automaton2 = alib::XmlDataFactory::fromTokens<automaton::Automaton>(a2Tokens);
- alib::XmlDataFactory::toStdout(automaton::transform::AutomataConcatenationEpsilonTransition::concatenation(automaton1, automaton2));
- return 0;
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Algorithm", std::chrono::measurements::Type::MAIN);
+
+ automaton::Automaton res = automaton::transform::AutomataConcatenationEpsilonTransition::concatenation(automaton1, automaton2);
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Output write", std::chrono::measurements::Type::AUXILARY);
+
+ alib::XmlDataFactory::toStdout( res );
} else if( algorithm.getValue() == "concatenation") {
automaton::Automaton automaton2 = alib::XmlDataFactory::fromTokens<automaton::Automaton>(a2Tokens);
- alib::XmlDataFactory::toStdout(automaton::transform::AutomataConcatenation::concatenation(automaton1, automaton2));
- return 0;
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Algorithm", std::chrono::measurements::Type::MAIN);
+
+ automaton::Automaton res = automaton::transform::AutomataConcatenation::concatenation(automaton1, automaton2);
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Output write", std::chrono::measurements::Type::AUXILARY);
+
+ alib::XmlDataFactory::toStdout( res );
} else if( algorithm.getValue() == "intersectionCartesian") {
automaton::Automaton automaton2 = alib::XmlDataFactory::fromTokens<automaton::Automaton>(a2Tokens);
- alib::XmlDataFactory::toStdout(automaton::transform::AutomataIntersectionCartesianProduct::intersection(automaton1, automaton2));
- return 0;
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Algorithm", std::chrono::measurements::Type::MAIN);
+
+ automaton::Automaton res = automaton::transform::AutomataIntersectionCartesianProduct::intersection(automaton1, automaton2);
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Output write", std::chrono::measurements::Type::AUXILARY);
+
+ alib::XmlDataFactory::toStdout( res );
} else if( algorithm.getValue() == "iteration") {
- alib::XmlDataFactory::toStdout(automaton::transform::AutomatonIteration::iteration(automaton1));
- return 0;
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Algorithm", std::chrono::measurements::Type::MAIN);
+
+ automaton::Automaton res = automaton::transform::AutomatonIteration::iteration(automaton1);
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Output write", std::chrono::measurements::Type::AUXILARY);
+
+ alib::XmlDataFactory::toStdout( res );
} else if( algorithm.getValue() == "iterationEpsilon") {
- alib::XmlDataFactory::toStdout(automaton::transform::AutomatonIterationEpsilonTransition::iteration(automaton1));
- return 0;
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Algorithm", std::chrono::measurements::Type::MAIN);
+
+ automaton::Automaton res = automaton::transform::AutomatonIterationEpsilonTransition::iteration(automaton1);
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Output write", std::chrono::measurements::Type::AUXILARY);
+
+ alib::XmlDataFactory::toStdout( res );
} else {
throw exception::AlibException( "Invalid algorithm" );
- return 1;
}
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::end();
+
+ if(measure.getValue()) std::clog << std::chrono::measurements::results() << std::endl;
+
+ return 0;
} catch( const exception::AlibException & exception ) {
alib::XmlDataFactory::toStdout( exception );
return 1;
diff --git a/aminimize2/src/aminimize.cpp b/aminimize2/src/aminimize.cpp
index 1290a94677..430faf5993 100644
--- a/aminimize2/src/aminimize.cpp
+++ b/aminimize2/src/aminimize.cpp
@@ -26,8 +26,17 @@ int main(int argc, char** argv) {
TCLAP::ValueArg<std::string> algorithm( "a", "algorithm", "Use specific algorithm. Hopcroft default.", false, "hopcroft", &algorithmVals);
cmd.add( algorithm );
+ TCLAP::SwitchArg measure( "m", "measure", "Measure times", false);
+ cmd.add( measure );
+
+ TCLAP::SwitchArg verbose( "v", "verbose", "Be verbose", false);
+ cmd.add( verbose );
+
cmd.parse(argc, argv);
+ std::chrono::measurements::start("Overal", std::chrono::measurements::Type::OVERALL);
+ std::chrono::measurements::start("Input read", std::chrono::measurements::Type::AUXILARY);
+
std::deque<sax::Token> tokens;
if(input.isSet()) {
if(input.getValue() == "-") {
@@ -39,16 +48,35 @@ int main(int argc, char** argv) {
sax::SaxParseInterface::parseStdin(tokens);
}
+ automaton::Automaton automaton = alib::XmlDataFactory::fromTokens<automaton::Automaton>(tokens);
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Algorithm", std::chrono::measurements::Type::MAIN);
+
if(algorithm.getValue() == "hopcroft") {
- alib::XmlDataFactory::toStdout(automaton::simplify::Minimize::minimize(alib::XmlDataFactory::fromTokens<automaton::Automaton>(tokens)));
+ automaton::Automaton res = automaton::simplify::Minimize::minimize(automaton);
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Output write", std::chrono::measurements::Type::AUXILARY);
+
+ alib::XmlDataFactory::toStdout(res);
} else if(algorithm.getValue() == "brzozowski") {
- alib::XmlDataFactory::toStdout(automaton::simplify::MinimizeBrzozowski::minimize(alib::XmlDataFactory::fromTokens<automaton::Automaton>(tokens)));
+ automaton::Automaton res = automaton::simplify::MinimizeBrzozowski::minimize(automaton);
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Output write", std::chrono::measurements::Type::AUXILARY);
+
+ alib::XmlDataFactory::toStdout(res);
} else {
throw exception::AlibException("Unknown algorithm selected.");
}
- return 0;
+ std::chrono::measurements::end();
+ std::chrono::measurements::end();
+
+ if(measure.getValue()) std::clog << std::chrono::measurements::results() << std::endl;
+ return 0;
} catch (const exception::AlibException& exception) {
alib::XmlDataFactory::toStdout(exception);
return 1;
diff --git a/anormalize2/src/anormalize.cpp b/anormalize2/src/anormalize.cpp
index b70a34215e..f7626cead5 100644
--- a/anormalize2/src/anormalize.cpp
+++ b/anormalize2/src/anormalize.cpp
@@ -43,8 +43,17 @@ int main(int argc, char** argv) {
TCLAP::ValueArg<std::string> alphabet( "a", "alphabet", "Normalize alphabet", false, "", &inputTypeVals2);
cmd.add( alphabet );
+ TCLAP::SwitchArg measure( "m", "measure", "Measure times", false);
+ cmd.add( measure );
+
+ TCLAP::SwitchArg verbose( "v", "verbose", "Be verbose", false);
+ cmd.add( verbose );
+
cmd.parse(argc, argv);
+ std::chrono::measurements::start("Overal", std::chrono::measurements::Type::OVERALL);
+ std::chrono::measurements::start("Input read", std::chrono::measurements::Type::AUXILARY);
+
std::deque<sax::Token> tokens;
if(input.isSet()) {
if(input.getValue() == "-") {
@@ -57,32 +66,111 @@ int main(int argc, char** argv) {
}
if(labels.getValue() == "automaton") {
- alib::XmlDataFactory::toStdout(automaton::simplify::Normalize::normalize(alib::XmlDataFactory::fromTokens<automaton::Automaton>(tokens)));
- return 0;
+ automaton::Automaton automaton = alib::XmlDataFactory::fromTokens<automaton::Automaton>(tokens);
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Algorithm", std::chrono::measurements::Type::MAIN);
+
+ automaton::Automaton res = automaton::simplify::Normalize::normalize(automaton);
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Output write", std::chrono::measurements::Type::AUXILARY);
+
+ alib::XmlDataFactory::toStdout(res);
} else if(labels.getValue() == "grammar") {
-// alib::XmlDataFactory::toStdout(automaton::simplify::Normalize::normalize(alib::XmlDataFactory::fromTokens<automaton::Automaton>(tokens)));
- return 0;
+// grammar::Grammar grammar = alib::XmlDataFactory::fromTokens<grammar::Grammar>( tokens );
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Algorithm", std::chrono::measurements::Type::MAIN);
+
+// grammar::Grammar res = grammar::simplify::Normalize::normalize(grammar);
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Output write", std::chrono::measurements::Type::AUXILARY);
+
+// alib::XmlDataFactory::toStdout(res);
} else if(alphabet.getValue() == "string") {
- alib::XmlDataFactory::toStdout(string::simplify::NormalizeAlphabet::normalize(alib::XmlDataFactory::fromTokens<string::String>(tokens)));
- return 0;
+ string::String string = alib::XmlDataFactory::fromTokens<string::String>(tokens);
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Algorithm", std::chrono::measurements::Type::MAIN);
+
+ string::String res = string::simplify::NormalizeAlphabet::normalize(string);
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Output write", std::chrono::measurements::Type::AUXILARY);
+
+ alib::XmlDataFactory::toStdout(res);
} else if(form.getValue() == "leftRG") {
- alib::XmlDataFactory::toStdout(grammar::convert::ToGrammarLeftRG::convert(alib::XmlDataFactory::fromTokens<grammar::Grammar>( tokens )));
- return 0;
+ grammar::Grammar grammar = alib::XmlDataFactory::fromTokens<grammar::Grammar>( tokens );
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Algorithm", std::chrono::measurements::Type::MAIN);
+
+ grammar::LeftRG res = grammar::convert::ToGrammarLeftRG::convert(grammar);
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Output write", std::chrono::measurements::Type::AUXILARY);
+
+ alib::XmlDataFactory::toStdout(res);
} else if(form.getValue() == "rightRG") {
- alib::XmlDataFactory::toStdout(grammar::convert::ToGrammarRightRG::convert(alib::XmlDataFactory::fromTokens<grammar::Grammar>( tokens )));
- return 0;
+ grammar::Grammar grammar = alib::XmlDataFactory::fromTokens<grammar::Grammar>( tokens );
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Algorithm", std::chrono::measurements::Type::MAIN);
+
+ grammar::RightRG res = grammar::convert::ToGrammarRightRG::convert(grammar);
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Output write", std::chrono::measurements::Type::AUXILARY);
+
+ alib::XmlDataFactory::toStdout(res);
} else if(form.getValue() == "singleInitialState") {
- alib::XmlDataFactory::toStdout(automaton::simplify::SingleInitialState::convert(alib::XmlDataFactory::fromTokens<automaton::Automaton>(tokens)));
- return 0;
+ automaton::Automaton automaton = alib::XmlDataFactory::fromTokens<automaton::Automaton>(tokens);
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Algorithm", std::chrono::measurements::Type::MAIN);
+
+ automaton::Automaton res = automaton::simplify::SingleInitialState::convert(automaton);
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Output write", std::chrono::measurements::Type::AUXILARY);
+
+ alib::XmlDataFactory::toStdout(res);
} else if(form.getValue() == "CNF") {
- alib::XmlDataFactory::toStdout(grammar::simplify::ToCNF::convert(alib::XmlDataFactory::fromTokens<grammar::Grammar>( tokens )));
- return 0;
+ grammar::Grammar grammar = alib::XmlDataFactory::fromTokens<grammar::Grammar>( tokens );
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Algorithm", std::chrono::measurements::Type::MAIN);
+
+ grammar::Grammar res = grammar::simplify::ToCNF::convert(grammar);
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Output write", std::chrono::measurements::Type::AUXILARY);
+
+ alib::XmlDataFactory::toStdout(res);
} else if(form.getValue() == "GNF") {
- alib::XmlDataFactory::toStdout(grammar::simplify::ToGNF::convert(alib::XmlDataFactory::fromTokens<grammar::Grammar>( tokens )));
- return 0;
+ grammar::Grammar grammar = alib::XmlDataFactory::fromTokens<grammar::Grammar>( tokens );
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Algorithm", std::chrono::measurements::Type::MAIN);
+
+ grammar::Grammar res = grammar::simplify::ToGNF::convert(grammar);
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Output write", std::chrono::measurements::Type::AUXILARY);
+
+ alib::XmlDataFactory::toStdout(res);
} else {
throw exception::AlibException("Invalid normalize command");
}
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::end();
+
+ if(measure.getValue()) std::clog << std::chrono::measurements::results() << std::endl;
+
+ return 0;
} catch (const exception::AlibException& exception) {
alib::XmlDataFactory::toStdout(exception);
return 1;
diff --git a/arand2/src/arand.cpp b/arand2/src/arand.cpp
index 8779ef1bc0..63117b7c08 100644
--- a/arand2/src/arand.cpp
+++ b/arand2/src/arand.cpp
@@ -60,64 +60,92 @@ int main(int argc, char* argv[]) {
TCLAP::ValueArg<int> maxRank( "", "rank", "Maximal rank of tree nodes", false, 5, "integer");
cmd.add( maxRank );
+ TCLAP::SwitchArg measure( "m", "measure", "Measure times", false);
+ cmd.add( measure );
+
+ TCLAP::SwitchArg verbose( "v", "verbose", "Be verbose", false);
+ cmd.add( verbose );
+
cmd.parse(argc,argv);
+ std::chrono::measurements::start("Overal", std::chrono::measurements::Type::OVERALL);
+
if(!type.isSet()) throw exception::AlibException("Type is not defined.");
if( type.getValue() == "FSM" ) {
-
- if(!density.isSet()) throw exception::AlibException("Density is not defined.");
if( density.getValue() < 1 || density.getValue() > 100 )
{
//TODO: floating point arithmetic
throw exception::AlibException("You must specify density as a number between 1 and 100.");
}
- if(!states.isSet()) throw exception::AlibException("Number of states is not defined.");
- if(!alphabetSize.isSet()) throw exception::AlibException("Alphabet size is not defined.");
+ std::chrono::measurements::start("Algorithm", std::chrono::measurements::Type::MAIN);
automaton::NFA res = automaton::generate::RandomAutomatonFactory::generateNFA( states.getValue(), alphabetSize.getValue(), randomizedAlphabet.getValue(), density.getValue() );
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Output write", std::chrono::measurements::Type::AUXILARY);
+
alib::XmlDataFactory::toStdout(res);
} else if( type.getValue() == "CFG" ) {
-
- if(!density.isSet()) throw exception::AlibException("Density is not defined.");
if( density.getValue() < 1 || density.getValue() > 100 )
{
//TODO: floating point arithmetic
throw exception::AlibException("You must specify density as a number between 1 and 100.");
}
- if(!nonterminals.isSet()) throw exception::AlibException("Number of nonterminals is not defined.");
- if(!alphabetSize.isSet()) throw exception::AlibException("Alphabet size is not defined.");
+ std::chrono::measurements::start("Algorithm", std::chrono::measurements::Type::MAIN);
grammar::CFG res = grammar::generate::RandomGrammarFactory::generateCFG( nonterminals.getValue(), alphabetSize.getValue(), randomizedAlphabet.getValue(), density.getValue() );
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Output write", std::chrono::measurements::Type::AUXILARY);
+
alib::XmlDataFactory::toStdout(res);
} else if( type.getValue() == "RE" ) {
+ std::chrono::measurements::start("Algorithm", std::chrono::measurements::Type::MAIN);
- if(!height.isSet()) throw exception::AlibException("Height is not defined.");
+ regexp::UnboundedRegExp res = regexp::generate::RandomRegExpFactory::generateUnboundedRegExp(terminalNodes.getValue(), height.getValue(), alphabetSize.getValue(), randomizedAlphabet.getValue() );
- if(!terminalNodes.isSet()) throw exception::AlibException("Number of terminal nodes is not defined.");
- if(!alphabetSize.isSet()) throw exception::AlibException("Alphabet size is not defined.");
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Output write", std::chrono::measurements::Type::AUXILARY);
- regexp::UnboundedRegExp res = regexp::generate::RandomRegExpFactory::generateUnboundedRegExp(terminalNodes.getValue(), height.getValue(), alphabetSize.getValue(), randomizedAlphabet.getValue() );
alib::XmlDataFactory::toStdout(res);
} else if( type.getValue() == "ST" ) {
+ std::chrono::measurements::start("Algorithm", std::chrono::measurements::Type::MAIN);
- if(!length.isSet()) throw exception::AlibException("Size is not defined.");
+ string::LinearString res = string::generate::RandomStringFactory::generateLinearString(length.getValue(), alphabetSize.getValue(), randomizedAlphabet.getValue() );
- if(!alphabetSize.isSet()) throw exception::AlibException("Alphabet size is not defined.");
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Output write", std::chrono::measurements::Type::AUXILARY);
- string::LinearString res = string::generate::RandomStringFactory::generateLinearString(length.getValue(), alphabetSize.getValue(), randomizedAlphabet.getValue() );
alib::XmlDataFactory::toStdout(res);
} else if( type.getValue() == "UT" ) {
+ std::chrono::measurements::start("Algorithm", std::chrono::measurements::Type::MAIN);
+
tree::UnrankedTree res = tree::generate::RandomTreeFactory::generateUnrankedTree(height.getValue(), nodes.getValue(), alphabetSize.getValue(), randomizedAlphabet.getValue(), maxRank.getValue());
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Output write", std::chrono::measurements::Type::AUXILARY);
+
alib::XmlDataFactory::toStdout(res);
} else if( type.getValue() == "RT" ) {
+ std::chrono::measurements::start("Algorithm", std::chrono::measurements::Type::MAIN);
+
tree::RankedTree res = tree::generate::RandomTreeFactory::generateRankedTree(height.getValue(), nodes.getValue(), alphabetSize.getValue(), randomizedAlphabet.getValue(), maxRank.getValue());
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Output write", std::chrono::measurements::Type::AUXILARY);
+
alib::XmlDataFactory::toStdout(res);
} else {
throw exception::AlibException("Invalid type.");
}
+ std::chrono::measurements::end();
+ std::chrono::measurements::end();
+
+ if(measure.getValue()) std::clog << std::chrono::measurements::results() << std::endl;
+
return 0;
} catch( const exception::AlibException & exception ) {
alib::XmlDataFactory::toStdout( exception );
diff --git a/araw2/src/araw.cpp b/araw2/src/araw.cpp
index 356a1138bd..dca118b4e5 100644
--- a/araw2/src/araw.cpp
+++ b/araw2/src/araw.cpp
@@ -39,7 +39,17 @@ int main(int argc, char** argv) {
TCLAP::SwitchArg matrix_to_raw( "", "matrix_to_raw", "Convert string to raw representation (csv)");
cmd.add( matrix_to_raw );
+ TCLAP::SwitchArg measure( "m", "measure", "Measure times", false);
+ cmd.add( measure );
+
+ TCLAP::SwitchArg verbose( "v", "verbose", "Be verbose", false);
+ cmd.add( verbose );
+
cmd.parse(argc, argv);
+
+ std::chrono::measurements::start("Overal", std::chrono::measurements::Type::OVERALL);
+ std::chrono::measurements::start("Input read", std::chrono::measurements::Type::AUXILARY);
+
if(tree_from_raw.getValue()) {
std::deque<sax::Token> tokens;
if(input.isSet()) {
@@ -54,6 +64,10 @@ int main(int argc, char** argv) {
std::deque<sax::Token>::iterator iter = tokens.begin();
tree::Tree tree = alib::FromRawParsers::treeParser.parseTree(iter);
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Output write", std::chrono::measurements::Type::AUXILARY);
+
alib::XmlDataFactory::toStdout(tree);
} else if(tree_to_raw.getValue()) {
std::deque<sax::Token> tokens;
@@ -68,12 +82,22 @@ int main(int argc, char** argv) {
}
tree::Tree tree = alib::XmlDataFactory::fromTokens<tree::Tree>(tokens);
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Output write", std::chrono::measurements::Type::AUXILARY);
+
std::deque<sax::Token> tokens2;
alib::ToRawComposers::treeComposer.compose(tokens2, tree);
sax::SaxComposeInterface::printStdout(tokens2);
} else {
throw exception::AlibException("Invalid input format specified");
}
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::end();
+
+ if(measure.getValue()) std::clog << std::chrono::measurements::results() << std::endl;
+
return 0;
} catch(const exception::AlibException& exception) {
alib::XmlDataFactory::toStdout(exception);
diff --git a/arename2/src/arename.cpp b/arename2/src/arename.cpp
index af46fc99d6..34d69a3bd8 100644
--- a/arename2/src/arename.cpp
+++ b/arename2/src/arename.cpp
@@ -19,8 +19,17 @@ int main(int argc, char** argv) {
TCLAP::ValueArg<std::string> input( "i", "input", "Automaton to rename", false, "-", "file");
cmd.add( input );
+ TCLAP::SwitchArg measure( "m", "measure", "Measure times", false);
+ cmd.add( measure );
+
+ TCLAP::SwitchArg verbose( "v", "verbose", "Be verbose", false);
+ cmd.add( verbose );
+
cmd.parse(argc, argv);
+ std::chrono::measurements::start("Overal", std::chrono::measurements::Type::OVERALL);
+ std::chrono::measurements::start("Input read", std::chrono::measurements::Type::AUXILARY);
+
std::deque<sax::Token> tokens;
if(input.isSet()) {
if(input.getValue() == "-") {
@@ -32,9 +41,24 @@ int main(int argc, char** argv) {
sax::SaxParseInterface::parseStdin(tokens);
}
- alib::XmlDataFactory::toStdout(automaton::simplify::Rename::rename(alib::XmlDataFactory::fromTokens<automaton::Automaton>(tokens)));
- return 0;
+ automaton::Automaton automaton = alib::XmlDataFactory::fromTokens<automaton::Automaton>(tokens);
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Algorithm", std::chrono::measurements::Type::MAIN);
+
+ automaton::Automaton res = automaton::simplify::Rename::rename(automaton);
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Output write", std::chrono::measurements::Type::AUXILARY);
+
+ alib::XmlDataFactory::toStdout(res);
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::end();
+
+ if(measure.getValue()) std::clog << std::chrono::measurements::results() << std::endl;
+
+ return 0;
} catch (const exception::AlibException& exception) {
alib::XmlDataFactory::toStdout(exception);
return 1;
diff --git a/areverse2/src/areverse.cpp b/areverse2/src/areverse.cpp
index 1ced05b837..da282230ee 100644
--- a/areverse2/src/areverse.cpp
+++ b/areverse2/src/areverse.cpp
@@ -20,8 +20,17 @@ int main(int argc, char** argv) {
TCLAP::ValueArg<std::string> input( "i", "input", "Automaton to reverse", false, "-", "file");
cmd.add( input );
+ TCLAP::SwitchArg measure( "m", "measure", "Measure times", false);
+ cmd.add( measure );
+
+ TCLAP::SwitchArg verbose( "v", "verbose", "Be verbose", false);
+ cmd.add( verbose );
+
cmd.parse(argc, argv);
+ std::chrono::measurements::start("Overal", std::chrono::measurements::Type::OVERALL);
+ std::chrono::measurements::start("Input read", std::chrono::measurements::Type::AUXILARY);
+
std::deque<sax::Token> tokens;
if(input.isSet()) {
if(input.getValue() == "-") {
@@ -33,9 +42,24 @@ int main(int argc, char** argv) {
sax::SaxParseInterface::parseStdin(tokens);
}
- alib::XmlDataFactory::toStdout(automaton::transform::Reverse::convert(alib::XmlDataFactory::fromTokens<automaton::Automaton>(tokens)));
- return 0;
+ automaton::Automaton automaton = alib::XmlDataFactory::fromTokens<automaton::Automaton>(tokens);
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Algorithm", std::chrono::measurements::Type::MAIN);
+
+ automaton::Automaton res = automaton::transform::Reverse::convert(automaton);
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Output write", std::chrono::measurements::Type::AUXILARY);
+
+ alib::XmlDataFactory::toStdout(res);
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::end();
+
+ if(measure.getValue()) std::clog << std::chrono::measurements::results() << std::endl;
+
+ return 0;
} catch (const exception::AlibException& exception) {
alib::XmlDataFactory::toStdout(exception);
return 1;
diff --git a/arun2/src/arun.cpp b/arun2/src/arun.cpp
index d08b2b3b79..3271cf66ac 100644
--- a/arun2/src/arun.cpp
+++ b/arun2/src/arun.cpp
@@ -39,8 +39,17 @@ int main(int argc, char* argv[]) {
TCLAP::ValueArg<std::string> automaton( "a", "automaton", "Automaton to run", false, "-", "file");
cmd.add( automaton );
+ TCLAP::SwitchArg measure( "m", "measure", "Measure times", false);
+ cmd.add( measure );
+
+ TCLAP::SwitchArg verbose( "v", "verbose", "Be verbose", false);
+ cmd.add( verbose );
+
cmd.parse(argc, argv);
+ std::chrono::measurements::start("Overal", std::chrono::measurements::Type::OVERALL);
+ std::chrono::measurements::start("Input read", std::chrono::measurements::Type::AUXILARY);
+
std::deque<sax::Token> inputTokens;
if(input.isSet()) {
if(input.getValue() == "-") {
@@ -63,26 +72,43 @@ int main(int argc, char* argv[]) {
sax::SaxParseInterface::parseStdin(automatonTokens);
}
+ alib::Object inputData = alib::XmlDataFactory::fromTokens<alib::Object>(inputTokens);
+ automaton::Automaton automatonData = alib::XmlDataFactory::fromTokens<automaton::Automaton>(automatonTokens);
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Algorithm", std::chrono::measurements::Type::MAIN);
+
if( type.getValue() == "occurrences") {
- alib::Object input = alib::XmlDataFactory::fromTokens<alib::Object>(inputTokens);
- automaton::Automaton automaton = alib::XmlDataFactory::fromTokens<automaton::Automaton>(automatonTokens);
- std::set<unsigned> res = automaton::run::Occurrences::occurrences(automaton, input);
+ std::set<unsigned> res = automaton::run::Occurrences::occurrences(automatonData, inputData);
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Output write", std::chrono::measurements::Type::AUXILARY);
+
alib::XmlDataFactory::toStdout( res );
- return 0;
} else if( type.getValue() == "accept") {
- alib::Object input = alib::XmlDataFactory::fromTokens<alib::Object>(inputTokens);
- automaton::Automaton automaton = alib::XmlDataFactory::fromTokens<automaton::Automaton>(automatonTokens);
- bool res = automaton::run::Accept::accept(automaton, input);
+ bool res = automaton::run::Accept::accept(automatonData, inputData);
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Output write", std::chrono::measurements::Type::AUXILARY);
+
alib::XmlDataFactory::toStdout( res );
} else if( type.getValue() == "result") {
- alib::Object input = alib::XmlDataFactory::fromTokens<alib::Object>(inputTokens);
- automaton::Automaton automaton = alib::XmlDataFactory::fromTokens<automaton::Automaton>(automatonTokens);
- label::Label res = automaton::run::Result::result(automaton, input);
+ label::Label res = automaton::run::Result::result(automatonData, inputData);
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Output write", std::chrono::measurements::Type::AUXILARY);
+
alib::XmlDataFactory::toStdout( res );
} else {
throw exception::AlibException( "Invalid run type" );
- return 1;
}
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::end();
+
+ if(measure.getValue()) std::clog << std::chrono::measurements::results() << std::endl;
+
+ return 0;
} catch ( const exception::AlibException & exception ) {
alib::XmlDataFactory::toStdout( exception );
return 1;
diff --git a/astat2/src/astat.cpp b/astat2/src/astat.cpp
index e5da34a233..9e40a770be 100644
--- a/astat2/src/astat.cpp
+++ b/astat2/src/astat.cpp
@@ -56,8 +56,17 @@ int main(int argc, char* argv[]) {
TCLAP::ValueArg<std::string> file( "i", "input", "Read from file", false, "-", "file");
cmd.add( file );
+ TCLAP::SwitchArg measure( "m", "measure", "Measure times", false);
+ cmd.add( measure );
+
+ TCLAP::SwitchArg verbose( "v", "verbose", "Be verbose", false);
+ cmd.add( verbose );
+
cmd.parse(argc, argv);
+ std::chrono::measurements::start("Overal", std::chrono::measurements::Type::OVERALL);
+ std::chrono::measurements::start("Input read", std::chrono::measurements::Type::AUXILARY);
+
PrintingOptions printingOption = translatePrintingOptions(presentation.getValue());
std::deque<sax::Token> tokens;
@@ -92,29 +101,43 @@ int main(int argc, char* argv[]) {
}
automaton::Automaton automaton = alib::XmlDataFactory::fromTokens<automaton::Automaton>(tokens);
- AutomataStat::stat(automaton, settings);
- return 0;
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Stats print", std::chrono::measurements::Type::MAIN);
+
+ AutomataStat::stat(automaton, settings);
} else if( alib::XmlDataFactory::first<grammar::Grammar>(tokens) /* && grammar.isSet() */) {
- grammar::Grammar grammar = alib::XmlDataFactory::fromTokens<grammar::Grammar>(tokens);
- return 0;
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Stats print", std::chrono::measurements::Type::MAIN);
+
+ grammar::Grammar grammar = alib::XmlDataFactory::fromTokens<grammar::Grammar>(tokens);
} else if( alib::XmlDataFactory::first<regexp::RegExp>(tokens) /* && regexp.isSet() */) {
- regexp::RegExp regexp = alib::XmlDataFactory::fromTokens<regexp::RegExp>(tokens);
- return 0;
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Stats print", std::chrono::measurements::Type::MAIN);
+
+ regexp::RegExp regexp = alib::XmlDataFactory::fromTokens<regexp::RegExp>(tokens);
} else if( alib::XmlDataFactory::first<container::ObjectsSet>(tokens) && setContainer.isSet()) {
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Stats print", std::chrono::measurements::Type::MAIN);
+
SetSettings settings = {PrintingOptions::NOOP};
settings.general = printingOption;
container::ObjectsSet data = alib::XmlDataFactory::fromTokens<container::ObjectsSet>(tokens);
SetStat::stat(data, settings);
-
- return 0;
} else {
throw exception::AlibException( "Input not recognized." );
- return 1;
}
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::end();
+
+ if(measure.getValue()) std::clog << std::chrono::measurements::results() << std::endl;
+
+ return 0;
} catch ( const exception::AlibException & exception ) {
alib::XmlDataFactory::toStdout( exception );
return 1;
diff --git a/astringology2/src/astringology.cpp b/astringology2/src/astringology.cpp
index fee3b130ed..79cd933851 100644
--- a/astringology2/src/astringology.cpp
+++ b/astringology2/src/astringology.cpp
@@ -47,6 +47,12 @@ int main(int argc, char* argv[]) {
TCLAP::MultiArg<std::string> pattern( "p", "pattern", "Pattern string from file", false, "file");
cmd.add( pattern );
+ TCLAP::SwitchArg measure( "m", "measure", "Measure times", false);
+ cmd.add( measure );
+
+ TCLAP::SwitchArg verbose( "v", "verbose", "Be verbose", false);
+ cmd.add( verbose );
+
cmd.parse(argc,argv);
int needPattern = 0;
@@ -70,6 +76,9 @@ int main(int argc, char* argv[]) {
} else {
}
+ std::chrono::measurements::start("Overal", std::chrono::measurements::Type::OVERALL);
+ std::chrono::measurements::start("Input read", std::chrono::measurements::Type::AUXILARY);
+
std::deque<std::deque<sax::Token>> subjectTokens;
if(subject.isSet()) {
for(const std::string& fileName : subject.getValue()) {
@@ -107,52 +116,114 @@ int main(int argc, char* argv[]) {
if( algorithm.getValue() == "exactFactorMatch") {
string::String subject = alib::XmlDataFactory::fromTokens<string::String>(subjectTokens.front());
string::String pattern = alib::XmlDataFactory::fromTokens<string::String>(patternTokens.front());
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Algorithm", std::chrono::measurements::Type::MAIN);
+
std::set<unsigned> res = stringology::exact::ExactFactorMatch::match(subject, pattern);
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Output write", std::chrono::measurements::Type::AUXILARY);
+
alib::XmlDataFactory::toStdout(res);
- return 0;
} else if( algorithm.getValue() == "boyerMooreHorspool") {
string::String subject = alib::XmlDataFactory::fromTokens<string::String>(subjectTokens.front());
string::String pattern = alib::XmlDataFactory::fromTokens<string::String>(patternTokens.front());
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Algorithm", std::chrono::measurements::Type::MAIN);
+
std::set<unsigned> res = stringology::exact::BoyerMooreHorspool::match(subject, pattern);
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Output write", std::chrono::measurements::Type::AUXILARY);
+
alib::XmlDataFactory::toStdout(res);
- return 0;
} else if( algorithm.getValue() == "exactMatchingAutomaton") {
string::String pattern = alib::XmlDataFactory::fromTokens<string::String>(patternTokens.front());
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Algorithm", std::chrono::measurements::Type::MAIN);
+
automaton::Automaton automaton = stringology::exact::ExactMatchingAutomaton::construct(pattern);
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Output write", std::chrono::measurements::Type::AUXILARY);
+
alib::XmlDataFactory::toStdout(automaton);
- return 0;
} else if( algorithm.getValue() == "exactFactorAutomaton") {
string::String subject = alib::XmlDataFactory::fromTokens<string::String>(subjectTokens.front());
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Algorithm", std::chrono::measurements::Type::MAIN);
+
automaton::Automaton automaton = stringology::exact::ExactFactorAutomaton::construct(subject);
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Output write", std::chrono::measurements::Type::AUXILARY);
+
alib::XmlDataFactory::toStdout(automaton);
- return 0;
} else if( algorithm.getValue() == "exactSubsequenceAutomaton") {
string::String subject = alib::XmlDataFactory::fromTokens<string::String>(subjectTokens.front());
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Algorithm", std::chrono::measurements::Type::MAIN);
+
automaton::Automaton automaton = stringology::exact::ExactSubsequenceAutomaton::construct(subject);
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Output write", std::chrono::measurements::Type::AUXILARY);
+
alib::XmlDataFactory::toStdout(automaton);
- return 0;
} else if( algorithm.getValue() == "exactNondeterministicSubsequenceAutomaton") {
string::String subject = alib::XmlDataFactory::fromTokens<string::String>(subjectTokens.front());
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Algorithm", std::chrono::measurements::Type::MAIN);
+
automaton::Automaton automaton = stringology::exact::ExactNondeterministicSubsequenceAutomaton::construct(subject);
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Output write", std::chrono::measurements::Type::AUXILARY);
+
alib::XmlDataFactory::toStdout(automaton);
- return 0;
} else if( algorithm.getValue() == "exactMultiNondeterministicSubsequenceAutomaton") {
std::set<string::String> subjects;
for(std::deque<sax::Token>& tokens : subjectTokens) {
subjects.insert(alib::XmlDataFactory::fromTokens<string::String>(tokens));
}
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Algorithm", std::chrono::measurements::Type::MAIN);
+
automaton::Automaton automaton = stringology::exact::ExactMultiNondeterministicSubsequenceAutomaton::construct(subjects);
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Output write", std::chrono::measurements::Type::AUXILARY);
+
alib::XmlDataFactory::toStdout(automaton);
- return 0;
} else if( algorithm.getValue() == "borderArray") {
string::String subject = alib::XmlDataFactory::fromTokens<string::String>(subjectTokens.front());
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Algorithm", std::chrono::measurements::Type::MAIN);
+
std::vector<unsigned> borderArray = stringology::exact::BorderArray::construct(subject);
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Output write", std::chrono::measurements::Type::AUXILARY);
+
alib::XmlDataFactory::toStdout(borderArray);
- return 0;
} else {
throw exception::AlibException( "Invalid algorithm" );
- return 1;
}
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::end();
+
+ if(measure.getValue()) std::clog << std::chrono::measurements::results() << std::endl;
+
+ return 0;
} catch( const exception::AlibException & exception ) {
alib::XmlDataFactory::toStdout( exception );
return 1;
diff --git a/atrim2/src/atrim.cpp b/atrim2/src/atrim.cpp
index 55363ffc7b..66141dc2f1 100644
--- a/atrim2/src/atrim.cpp
+++ b/atrim2/src/atrim.cpp
@@ -74,8 +74,17 @@ int main(int argc, char* argv[]) {
TCLAP::SwitchArg efficient( "e", "efficient", "Use efficient implementation", false);
cmd.add( efficient );
+ TCLAP::SwitchArg measure( "m", "measure", "Measure times", false);
+ cmd.add( measure );
+
+ TCLAP::SwitchArg verbose( "v", "verbose", "Be verbose", false);
+ cmd.add( verbose );
+
cmd.parse(argc, argv);
+ std::chrono::measurements::start("Overal", std::chrono::measurements::Type::OVERALL);
+ std::chrono::measurements::start("Input read", std::chrono::measurements::Type::AUXILARY);
+
std::deque<sax::Token> tokens;
if(input.isSet()) {
if(input.getValue() == "-") {
@@ -90,29 +99,58 @@ int main(int argc, char* argv[]) {
if( alib::XmlDataFactory::first<automaton::Automaton>(tokens)) {
automaton::Automaton automaton = alib::XmlDataFactory::fromTokens<automaton::Automaton>(tokens);
- if(efficient.getValue())
- alib::XmlDataFactory::toStdout( efficientTrimAutomaton(automaton, unreachable.getValue(), useless.getValue() ) );
- else
- alib::XmlDataFactory::toStdout( trimAutomaton(automaton, unreachable.getValue(), useless.getValue() ) );
- return 0;
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Algorithm", std::chrono::measurements::Type::MAIN);
+
+ if(efficient.getValue()) {
+ automaton::Automaton res = efficientTrimAutomaton(automaton, unreachable.getValue(), useless.getValue() );
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Output write", std::chrono::measurements::Type::AUXILARY);
+
+ alib::XmlDataFactory::toStdout( res );
+ } else {
+ automaton::Automaton res = trimAutomaton(automaton, unreachable.getValue(), useless.getValue() );
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Output write", std::chrono::measurements::Type::AUXILARY);
+
+ alib::XmlDataFactory::toStdout( res );
+ }
} else if( alib::XmlDataFactory::first<grammar::Grammar>(tokens)) {
grammar::Grammar grammar = alib::XmlDataFactory::fromTokens<grammar::Grammar>(tokens);
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Algorithm", std::chrono::measurements::Type::MAIN);
+
grammar::Grammar res = trimGrammar(grammar, unreachable.getValue(), useless.getValue() );
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Output write", std::chrono::measurements::Type::AUXILARY);
+
alib::XmlDataFactory::toStdout( res );
- return 0;
} else if( alib::XmlDataFactory::first<regexp::RegExp>(tokens)) {
regexp::RegExp regexp = alib::XmlDataFactory::fromTokens<regexp::RegExp>(tokens);
- regexp::RegExp res = optimizeRegExp(regexp );
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Algorithm", std::chrono::measurements::Type::MAIN);
+
+ regexp::RegExp res = optimizeRegExp( regexp );
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Output write", std::chrono::measurements::Type::AUXILARY);
alib::XmlDataFactory::toStdout( res );
- return 0;
} else {
throw exception::AlibException( "Input not recognized." );
- return 1;
}
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::end();
+
+ if(measure.getValue()) std::clog << std::chrono::measurements::results() << std::endl;
+
+ return 0;
} catch( const exception::AlibException & exception ) {
alib::XmlDataFactory::toStdout( exception );
return 1;
diff --git a/tniceprint/src/tniceprint.cpp b/tniceprint/src/tniceprint.cpp
index 676884a3b8..28d94650a8 100644
--- a/tniceprint/src/tniceprint.cpp
+++ b/tniceprint/src/tniceprint.cpp
@@ -20,8 +20,17 @@ int main(int argc, char** argv) {
TCLAP::ValueArg<std::string> input( "i", "input", "Input to nice print", false, "-", "file");
cmd.add( input );
+ TCLAP::SwitchArg measure( "m", "measure", "Measure times", false);
+ cmd.add( measure );
+
+ TCLAP::SwitchArg verbose( "v", "verbose", "Be verbose", false);
+ cmd.add( verbose );
+
cmd.parse(argc, argv);
+ std::chrono::measurements::start("Overal", std::chrono::measurements::Type::OVERALL);
+ std::chrono::measurements::start("Input read", std::chrono::measurements::Type::AUXILARY);
+
std::deque<sax::Token> tokens;
if(input.isSet()) {
if(input.getValue() == "-") {
@@ -35,12 +44,25 @@ int main(int argc, char** argv) {
if (alib::XmlDataFactory::first<tree::RankedTree>(tokens)) {
const tree::RankedTree & tree = alib::XmlDataFactory::fromTokens<tree::RankedTree>(tokens);
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Output write", std::chrono::measurements::Type::AUXILARY);
+
tree.nicePrint(std::cout);
} else if (alib::XmlDataFactory::first<tree::UnrankedTree>(tokens)) {
const tree::UnrankedTree & tree = alib::XmlDataFactory::fromTokens<tree::UnrankedTree>(tokens);
+
+ std::chrono::measurements::end();
+ std::chrono::measurements::start("Output write", std::chrono::measurements::Type::AUXILARY);
+
tree.nicePrint(std::cout);
} else throw exception::AlibException("no tree on input");
+ std::chrono::measurements::end();
+ std::chrono::measurements::end();
+
+ if(measure.getValue()) std::clog << std::chrono::measurements::results() << std::endl;
+
return 0;
} catch(const exception::AlibException& exception) {
alib::XmlDataFactory::toStdout(exception);
--
GitLab