Minimize.cc

Go to the documentation of this file.

#include <cstdlib>
#include<iostream>
#include<fstream>
#include<regex>
#include<boost/program_options.hpp>

#include<diades/automata/experimental/AutFile.hh>
#include<diades/automata/experimental/DdAutFile.hh>
#include<diades/automata/experimental/DdAutFileDescriptor.hh>
#include<diades/automata/experimental/Printer.hh>
#include<diades/automata/experimental/StateMachine.hh>
#include<diades/automata/experimental/Determine.hh>
#include<diades/automata/experimental/Minimize.hh>
#include"../AutomataInterface.hh"

using namespace std;
using namespace Diades::Automata::Experimental;
using namespace Diades::Utils;
using namespace Diades::CmdInterface;

namespace Poptions = boost::program_options;



const string program("dd-minimize");

/*
 * File suffixes
 */
FileSuffixes suffixes({"aut", "ddaut"});

void
initialiseOptions(int argc, char * argv[],
                                  Poptions::options_description & desc,
                                  Poptions::variables_map & vm)
{
        desc.add_options()
                        ("help,h", "produce help message")
                        ("file,f", Poptions::value< string >(), "automaton file (.aut/.ddaut format)")
                        ("output,o", Poptions::value< string >(), "outfile name (.aut/.ddaut format)");
        Poptions::positional_options_description p;
        p.add("file", 1);
        Poptions::store(Poptions::command_line_parser(argc, argv).options(desc).positional(p).run(), vm);
        Poptions::notify(vm);
}


using Diades::Automata::Experimental::DdAutFsm;
using Diades::Automata::Experimental::DdAutEventManager;
using Diades::Automata::Experimental::DdAutStateManager;
using Diades::Automata::Experimental::AutFsm;

size_t
minimizeAut(const std::string & fileName, const std::string & output)
{

        AutFsm fsm;
        ifstream file(fileName.c_str());
        if(file.is_open())
        {
                auto loaded = fromAutFile(file, fsm);
                file.close();
                if(!loaded)
                {
                        return printCommandLineError(Msg("Error when loading the automaton file %1%") % fileName);
                }
        }
        else
        {
                return printCommandLineError(Msg("Error when opening the automaton file %1%") % fileName);
        }
        AutFsm minimalFsm;
        if(!isDeterministic(fsm))
        {
                AutFsm detFsm;
                AutStateCreator detCreator(fsm, detFsm);
                determine(fsm,
                                detFsm,
                                detCreator);
                AutStateCreator creator(detFsm, minimalFsm);
                minimize(detFsm,
                                minimalFsm,
                                creator);
        }
        else
        {
                AutStateCreator creator(fsm, minimalFsm);
                minimize(fsm,
                                minimalFsm,
                                creator);
        }

        return writeAut(minimalFsm, output, suffixes);
}

size_t
minimizeDdaut(const std::string & fileName, const std::string & output)
{

        DdAutFileDescriptor descriptor;
        DdAutEventManager eManager;
        DdAutStateManager sManager;
        DdAutStateManager sManagerMin;
        ifstream file(fileName.c_str());
        if(file.is_open())
        {
                auto loaded = descriptor.readStream(file);
                file.close();
                if(!loaded)
                {
                        return printCommandLineError(Msg("Error when loading the 'ddaut' automaton file %1%") % fileName);
                }
        }
        else
        {
                return printCommandLineError(Msg("Error when opening the 'ddaut' automaton file %1%") % fileName);
        }
        if(descriptor.acceptorBegin() != descriptor.acceptorEnd())
        {
                DdAutFA fa;
                DdAutFA minimalFA;
                bool result = faFromDescriptor(descriptor, fa, sManager, eManager);
                if(!result)
                {
                        return printCommandLineError(Msg("Error when loading the ddaut descriptor of file %1% in a finite automaton") % fileName);
                }
                if(!isDeterministic(fa))
                {
                        DdAutFA detFA;

                        DdAutStateManager sManagerDet;
                        ManagedBeliefStateBasedStateCreator<DdAutFA, DdAutDisjunction> detCreator(fa, detFA, sManager, sManagerDet);
                        determine(fa,
                                        detFA,
                                        detCreator);
                        ManagedBeliefStateBasedStateCreator<DdAutFA, DdAutDisjunction> creator(detFA, minimalFA, sManagerDet, sManagerMin);
                        minimize(detFA,
                                        minimalFA,
                                        creator);
                }
                else
                {
                        ManagedBeliefStateBasedStateCreator<DdAutFA, DdAutDisjunction> creator(fa, minimalFA, sManager, sManagerMin);
                        minimize(fa,
                                        minimalFA,
                                        creator);
                }
                return writeFiniteAutomaton({minimalFA, sManagerMin, eManager}, output, suffixes);
        }
        else
        {
                DdAutFsm fsm;
                DdAutFsm minimalFsm;
                bool result = fsmFromDescriptor(descriptor, fsm, sManager, eManager);
                if(!result)
                {
                        return printCommandLineError(Msg("Error when loading the ddaut descriptor of file %1% in a finite machine") % fileName);
                }
                if(!isDeterministic(fsm))
                {
                        DdAutFsm detFsm;

                        DdAutStateManager sManagerDet;
                        ManagedBeliefStateBasedStateCreator<DdAutFsm, DdAutDisjunction> detCreator(fsm, detFsm, sManager, sManagerDet);
                        determine(fsm,
                                        detFsm,
                                        detCreator);
                        ManagedBeliefStateBasedStateCreator<DdAutFsm, DdAutDisjunction> creator(detFsm, minimalFsm, sManagerDet, sManagerMin);
                        minimize(detFsm,
                                        minimalFsm,
                                        creator);
                }
                else
                {
                        ManagedBeliefStateBasedStateCreator<DdAutFsm, DdAutDisjunction> creator(fsm, minimalFsm, sManager, sManagerMin);
                        minimize(fsm,
                                        minimalFsm,
                                        creator);
                }
                return writeFiniteStateMachine({minimalFsm, sManagerMin, eManager}, output, suffixes);
        }
        return false;
}

size_t
minimizeFsm(const std::string & fileName, const std::string & output)
{

        if(suffixes.match(fileName, "aut"))
        {
                return minimizeAut(fileName, output);
        }
        else
        {
                if(suffixes.match(fileName, "ddaut"))
                {
                        return minimizeDdaut(fileName, output);
                }
                else
                {
                        return printCommandLineError(Msg("Expecting a file with a name ending with .aut, but I read %1%") % fileName);
                }
        }
        return ERROR_UNHANDLED_EXCEPTION;
}

int
main(int argc, char** argv)
{
        std::string fileName, output;
        try
        {
                Poptions::options_description desc("Options");
                Poptions::variables_map vm;
                initialiseOptions(argc, argv, desc, vm);
                if(vm.count("help"))
                {
                        return printUsage(program, desc);
                }
                if(vm.count("file"))
                {
                        fileName = vm["file"].as<std::string>();
                }
                if(vm.count("output"))
                {
                        output = vm["output"].as<std::string>();
                }
        }
        catch(Poptions::required_option & e)
        {
                return printCommandLineError(e.what());
        }
        catch(Poptions::error & e)
        {
                return printCommandLineError(e.what());
        }
        return minimizeFsm(fileName, output);
}