/***************************************************************************
                          main.C  -  description
                             -------------------
    begin                : mer oct  9 19:14:09 CEST 2002
    copyright            : (C) 2002 by Yann Esposito
    email                : esposito@cmi.univ-mrs.fr
***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/

#include "interface.H"
#include "test.H"
#include "main.H"

// #define MAXFLOAT 3.40282347e+38F

/// ########################################################################## ///
// --- Les variables globales d'entrées qui parametre l'expérimentation

// Les fichier

string temporary_directory= "/tmp/dees/"; // le répertoire temporaire

string ficffaA   = temporary_directory + "A";	// Fichier du ffa A
string ficffaB   = temporary_directory + "B";	// Fichier du ffa B
string ficdotA   = temporary_directory + "A.dot";	// Le fichier dot associé à A
string ficdotB   = temporary_directory + "B.dot";	// Le fichier dot associé à B
string ficech    = temporary_directory + "A.ech";	// Le fichier échantillon généré par A
string ficechpre = temporary_directory + "A.ecp";	// Le fichier échantillon préfixe généré par A
string ficpsA    = temporary_directory + "A.ps";	// La fichier de visualisation de A
string ficpsB    = temporary_directory + "B.ps";	// Le fichier de visualisation de B

// Les Èchantillons
Sample S;			// main sample
Sample Stest;		// test sample
int num_ech = 0;		// Le numero de l'Èchantillon
int num_ech_test = 1;		// Le numbero de l'Èchantillon test
int taille_ech = 1000;		// La taille de l'Èchantillon
int taille_ech_test = 1000;	// La taille de l'Èchantillon test

// Le PFA alÈatoire
int numPFA = 0;			// Le numero du PFA gÈnÈrÈ
int nb_etats = 5;		// Le nombre d'Ètats du PFA gÈnÈrÈ
int nb_lettres = 2;		// Le nombre de lettres du PFA gÈnÈrÈ

// Les prÈcisions
double precision = 0.5;		// la prÈcision (0 -> prefix tree, 1 -> single state)
double precpow = -1;		// La prÈcision en mode exponentiel
double epsprime = 0;		// La valeur de suppression des transitions (0 delete nothing, 1 delete all)
unsigned int seuil = 0;		// le seuil en dessous duquel un prefixe n'est plus pris en compte dans l'apprentissage
double seuilbm = .0001 ;    // Le seuil pour le test de convergence de BM
unsigned int maxmots = INT_MAX; // le nombre maximal de mots à ajouter à l'ensemble de test à chaque étapes

// L'affichage
string nom_A = "A";		// le nom du PFA A
string nom_B = "B";		// le nom du PFA B
bool affiche_A = true;		// affiche l'automate source ou non
bool affiche_B = true;		// affiche l'automate destination
bool verbose = false;		// mode verbose pour le test
bool affiche_etats = false;  // affiche les Ètats dans le .dot
int  viewprec=3;			// precision des parametres a l'affichage
bool viewstates=false;		// on met le numero des etats
bool viewmultipletransitions=false; // vrai pour ne plus regrouper les transitions
bool interactive=false;     // interactive mode

// L'apprentissage
T_ModeReturn moderet = ::end;	// Le mode de retour des arÍtes (end ou begin)
T_ModeEpsilon modeeps = variable;	// Le mode d'apprentissage avec epsilon fixe ou variable (epsfixed ou variable)
float test_proportion = 0.2;	// la proportion de l'echantillon attribuee au test
int nb_tours = 100;	// Le nombre d'itÈrations pour Baum Welch
int nb_essais = 10; // le nombre d'essais pour le best learning
int max_states = INT_MAX; // le nombre maximal d'etats pour DEES
bool stepssave = false; // vrai si on veut enregistrer toutes les étapes de l'apprentissage.

// L'exportation de fichier
string format = "ffa";

// les distances
bool smooth = false;

string cmd;
PPRFA A;
PPRFA B;

stringstream convert;		// variable qui permet de convertir les stream en entiers ou flottants

/// ########################################################################## ///


// affiche un mot
string
affiche (const Word & w, const Dictionnaire & alph)
{
    Word::const_iterator a;
    string res;
    for (a = w.begin (); a != w.end (); ++a)
    {
        res += alph.find (*a)->second;
        res += ' ';
    }
    return res;
}


void show(MA A) {	
	string dotfile;
	string pdffile;
	stringstream trad;
	trad << temporary_directory << "pfa"<< int(time(NULL));
	trad >> pdffile;
	dotfile=pdffile;
	pdffile += ".pdf";
	dotfile += ".dot";
	A.save_dot(dotfile, viewprec, viewstates, viewmultipletransitions);
	string cmd;
    cmd += "dot -Tepdf ";
    cmd += dotfile;
	cmd += ">";
	cmd += pdffile;
	system(cmd.c_str());
    show_ps(pdffile);
}



// La procÈdure qui initialise le random
int
randomize (void)
{
    // mise a jour du random
    unsigned int i = 0;
    char c;
    ifstream dev_rnd ("/dev/urandom");
    if (dev_rnd != NULL)
    {
        for (int k = 0; k < 4; k++)
        {
            dev_rnd.get (c);
            i = i << 8 | c;
        }
        srand (i);
        return i;
    }
    else
    {
        srand (num_ech);
        return num_ech;
    }
}

int
affiche_utilisation (void)
{
    string fichelp = "./help/";
    fichelp += "help.txt";
    ifstream fh (fichelp.c_str ());
    if (fh == NULL)
    {
        cout << "DEES : ";
        cout << "WARNING: " << fichelp << " not found." << endl;
    }
    else
    {
        cout << fh.rdbuf ();
        fh.close ();
        cout << endl;
    }
    return 0;
}

int
affiche_options (void)
{
    string fichelp = "/Users/esposito/dees/help/";
    fichelp += "/help_options.txt";
    ifstream fh (fichelp.c_str ());
    if (fh == NULL)
    {
        cout << "DEES : ";
        cout << "WARNING: " << fichelp << " not found." << endl;
    }
    else
    {
        cout << fh.rdbuf ();
        fh.close ();
        cout << endl;
    }
    return 0;
}


RESULT
export_to_pdf (const MA & A,
              const string & fic_pdf,
              const string & fic_tmp,
              const int precision,
              const bool noms_etats,
              const bool multiples_trans)
{
    A.save_dot (fic_tmp, precision, noms_etats, multiples_trans);	// On l'enregistre dans un fichier dot
    // on Ècrit la commande
    string cmd;
    cmd = "dot -Tepdf ";
    cmd += fic_tmp;
    cmd += " > ";
	cmd += fic_pdf;
	
    // on execute la transformation
    system (cmd.c_str ());
    return 0;
}

void
show_ps (string & fic_pdf)
{
    string cmd;
    cmd += "open ";
    cmd += fic_pdf;
    cmd += "&";
    system (cmd.c_str ());
}


// Affiche toutes les distances entre A et B
void
affiche_distance (PFA & A, const PFA & B, const int taille_ech_test,
                  const string & flag)
{
    double pA, pB;
    A.genere_echantillon (taille_ech_test, S, num_ech_test);
	cerr << "Test_Sample_size\t";
	cerr << "precision\t";
	cerr << "perplex A\t";
	cerr << "perplex B\t";
	cerr << "KL div\t";
	cerr << "d_2\t";
	cerr << "L_1\t";
	cerr << "d_2(nlog)\t";
	cerr << "L_1(nlog)\t";
    cout << taille_ech_test << "\t";
    cout << precision << "\t";
    cout << (pA = A.perplexite (S)) << "\t";
    cout << (pB = B.perplexite (S)) << "\t";
    cout << pB - pA << "\t";
    cout << A.d_2 (B, S) << "\t";
    cout << A.L_1 (B, S) << "\t";
    cout << A.d_2nlog (B, S) << "\t";
    cout << A.L_1nlog (B, S) << "\t";
    cout << flag << endl;
}

void
affiche_distance (PFA & A, const PFA & B, const int taille_ech,
                  const char *flag)
{
    string s_flag = flag;
    affiche_distance (A, B, taille_ech, s_flag);
}

void
affiche_classe (PFA & A)
{
    if (!A.coherent ())
    {
        cout << "uncoherent MA" << endl;
    }
    else if (!A.isSPFA ())
    {
        cout << "MA" << endl;
    }
    else if (!A.isPFA ())
    {
        cout << "SPFA" << endl;
    }
    else if (!A.isPRFA ())
    {
        cout << "PFA" << endl;
    }
    else if (!A.isPDFA ())
    {
        cout << "PRFA" << endl;
    }
    else
    {
        cout << "PDFA" << endl;
    }
}


// Crossed validation learning
// Apprentissage avec validation croisÈe

void Alergia(PFA &A, float prec, string ficsample, bool verbose) {
	stringstream AL;
	string ficsampletmp=temporary_directory + "tmpsample.alergia";
	Sample S;
	S.load(ficsample);
	S.save(ficsampletmp, alergia);
	AL << "alergia";
	AL << " -a " << prec;
	AL << " -o " << ficffaA;
	AL << " -f " << ficsampletmp;
	if (verbose) {
		cout << ":: " << AL.str() << endl;
	}
	system(AL.str().c_str());

	stringstream MOD;
	string fictmp=temporary_directory + "alergia.tmp";
	MOD << "echo %Alergia > " << fictmp;
	MOD << " && cat " << ficffaA << " >> " << fictmp;
	if (verbose) {
		cout << "transformation de l'automate avec :\n";
		cout << MOD.str() << endl;
	}
	system(MOD.str().c_str()); // on ajoute %Alergia au dÈbut du fichier

	if (verbose) {
		cout << "on charge le fichier : " << fictmp << endl;
	}

	A.load(fictmp);
}

void MDI(PFA &A, float prec, string ficsample, bool verbose) {
	string ficsampletmp=temporary_directory + "tmpsample.mdi";
	Sample S;
	S.load(ficsample);
	S.save(ficsampletmp, mdi);
	stringstream MDI;
	MDI << "mdi";
	MDI << " -b";
	if (verbose) {
		MDI << " -v";
	}
	MDI << " -c " << prec / double(taille_ech);
	MDI << " -o " << ficffaA;
	MDI << " -i " << ficsampletmp;
	if (verbose) {
		cout << ":: " << MDI.str() << endl;
	}
	system(MDI.str().c_str());	

	stringstream MOD;
	string fictmp=temporary_directory + "mdi.tmp";
	MOD << "echo %MDI > " << fictmp;
	MOD << " && cat " << ficffaA << " >> " << fictmp;

	if (verbose) {
		cout << "transformation de l'automate avec :\n";
		cout << MOD.str() << endl;
	}
	system(MOD.str().c_str()); // on ajoute %MDI au dÈbut du fichier

	if (verbose) {
		cout << "on charge le fichier : " << fictmp << endl;
	}

	A.load(fictmp);
}

// --- La procedure pour debbugger ---
float fonction (float val, float moy, float ecart)
{
    float constante = 1/(ecart * sqrt(2 * 3.1415));
    return constante * exp(- ((val - moy)*(val - moy)) / ecart);
}

void BaumWelch(PFA A, Sample S, int nb_turns, string output) {
	TransitionFunction T;
	SFunc Iota, Tau;
	double val, oldval;
	A.allTransitions(T);
	A.allStates(Iota);
	A.allStates(Tau);
	oldval=A.Likelihood(S);
	for (int i=0 ; i < nb_turns ; i++) {
		A.BaumWelch(S,T,Iota,Tau,3,true);
		val=A.Likelihood(S);
		//if (abs(val-oldval)<.1) {
		//	break;
		//}
		oldval=val;
		if (verbose) {
			cout << "Likelihood: " << A.Likelihood(S) << "\n";
		}
	}
	cout << endl;
	
	A.erase_bad_states();
	A.save(output);
}


// génère un PA complet

RESULT generate_complete_random_pfa(int argc, char **argv, int i) {
	
	if (argc < i + 2) {
		cerr << "dees --grp nbstates nbletters file" << endl;
		cerr << "generate a complete random automaton with 'nbstates' states\n";
		cerr << "'nbletters' letters and save it in file\n";
		cerr << "usefull option:\n";
		cerr << "--numPFA : the number of the ma by default random number is choosen.\n";
		return -1;
	}
	
	int nbstates=atoi(argv[i++]);
	int nbletters=atoi(argv[i++]);
	string output=argv[i++];
	
	int num_graphe=0;      //cout << "num graphe: ";    cin >> num_graphe;
	float min_trans=0.01;     //cout << "min_trans: ";     cin >> min_trans;
	float max_trans=1;     //cout << "max_trans: ";     cin >> max_trans;
	float prob_init=1;     //cout << "prob_init: ";     cin >> prob_init;
	float prob_trans=1;    //cout << "prob_trans: ";    cin >> prob_trans;
	float prob_term=1;     //cout << "prob_term: ";     cin >> prob_term;

	if (verbose) {
		cout << "num graphe: "    << num_graphe    << endl;
		cout << "prob_trans: "   << prob_trans    << endl;
		cout << "prob_init: "    << prob_init     << endl;
		cout << "prob_term: "    << prob_term     << endl;
		cout << "min_trans: "     << min_trans     << endl;
		cout << "max_trans: "     << max_trans     << endl;
	}				
	
	A.becomeRandom (nbstates, nbletters, numPFA, prob_trans, prob_init, prob_term, min_trans, max_trans);
				
	return A.save (output);
}

RESULT generate_random_pfa(int argc, char **argv, int i) {
	if (argc < i+3) {
		cerr << "dees --random nbstates nbletters file\n";
		cerr << "generate a random automaton of class 'class' with 'nbstates' states\n";
		cerr << "'nbletters' letters and save it in file\n";
		cerr << "usefull option:\n";
		cerr << "--numPFA : the number of the ma by default random number is choosen.\n";
		cerr << "--interactive : ask you to enter values\n";
		return -1;
	}
	int nbstates=atoi(argv[i++]);
	int nbletters=atoi(argv[i++]);
	string output=argv[i++];
	
	int num_graphe=0;      
	int max_nb_succ=nbstates;
	int max_nb_init=nbstates;
	int max_nb_term=nbstates;
	float min_trans=0;     
	float max_trans=1;     
	float min_iota=0;      
	float max_iota=1;      
	float min_tau=0;       
	float max_tau=1;       
	float normalization=1; 
	float prob_init=.3;    
	float prob_trans=.3;   
	float prob_term=.3;    
	
	if (interactive) {
		cout << "num graphe (0=random): ";    cin >> num_graphe;
		cout << "max_nb_succ (width of the graph): ";   cin >> max_nb_succ;
		cout << "max_nb_init: ";   cin >> max_nb_init;
		cout << "max_nb_term: ";   cin >> max_nb_term;
		cout << "min_trans (minimal value of a transition): ";     cin >> min_trans;
		cout << "max_trans (maximal value of a transition): ";     cin >> max_trans;
		cout << "min_iota  (minimal initial value): ";      cin >> min_iota;
		cout << "max_iota  (maximal initial value): ";      cin >> max_iota;
		cout << "min_tau   (minimal terminaison value): ";       cin >> min_tau;
		cout << "max_tau   (maximal terminaison value): ";       cin >> max_tau;
		cout << "normalization (value of normalisation mostly 1): "; cin >> normalization;
		cout << "prob_init  (probability for a state to be initial: ";     cin >> prob_init;
		cout << "prob_trans (probability for a terminaison to araise): ";    cin >> prob_trans;
		cout << "prob_term  (probability for a state to be terminal): ";     cin >> prob_term;
	}
	
	A.becomeRandomControl (nbstates, nbletters, num_graphe, max_nb_succ, max_nb_init, max_nb_term, min_trans, max_trans, min_iota, max_iota, min_tau, max_tau, normalization, prob_init, prob_trans, prob_term);
	
	return A.save(output);
}

RESULT show_sample_forward(int argc, char**argv, int i) {
	if (argc < i+2) {
		cerr << "usage : --forward PFA sample\n";
		cerr << "return a list of couple word and its probability for the PFA\n";
		throw 2;
	}
	A.load(argv[i++]);
	S.load(argv[i++]);
	if (A.dictionnaire() != S.dictionnaire()) {
		cerr << "Alphabets of the PFA and of the sample differ !" << endl;
		Dictionnaire D;
		Dictionnaire::const_iterator x;
		cerr << "dictionnaire of the PFA\n";
		D=A.dictionnaire();
		for (x=D.begin() ; x != D.end() ; x++) {
			cout << x->first << ":" << x->second << "\n";
		}
		
		cerr << "dictionnaire of the Sample\n";
		D=S.dictionnaire();
		for (x=D.begin() ; x != D.end() ; x++) {
			cout << x->first << ":" << x->second << "\n";
		}
		throw 2;
	}
	Sample::const_iterator w;
	double somme=0 ;
	double logsomme = 0;
	double val ;
	for (w=S.begin() ; w != S.end() ; w++) {
		cout << A.affiche(w->first) <<  " : ";
		cout.flush();
		val = A.p_bar(w->first);
		somme += val;
		cout << val ;
		val = A.plog_bar(w->first);
		logsomme += val;
		cout << ", log forward : " << val;
        cout << ", exp(log forward) :" << exp(val);
		cout << ", pBarDirect : " << A.p_bar_directe(w->first);
        cout << endl;
	}
	cout << "sum = " << somme << ", somme de exp(log(forward)) : " << logsomme << endl;
	return VAL(0);
}


RESULT show_sample_proba(int argc, char **argv, int i){
	if (argc < i+2) {
		cerr << "usage : --proba PFA sample\n";
		cerr << "return a list of couple word and its probability for the PFA\n";
		throw 2;
	}
	A.load(argv[i++]);
	S.load(argv[i++]);
	if (A.dictionnaire() != S.dictionnaire()) {
		cerr << "Alphabets of the PFA and of the sample differ !" << endl;
		Dictionnaire D;
		Dictionnaire::const_iterator x;
		cerr << "dictionnaire of the PFA\n";
		D=A.dictionnaire();
		for (x=D.begin() ; x != D.end() ; x++) {
			cout << x->first << ":" << x->second << "\n";
		}
		
		cerr << "dictionnaire of the Sample\n";
		D=S.dictionnaire();
		for (x=D.begin() ; x != D.end() ; x++) {
			cout << x->first << ":" << x->second << "\n";
		}
		throw 2;
	}
	Sample::const_iterator w;
	double somme=0 ;
	double logsomme = 0;
	double val ;
	for (w=S.begin() ; w != S.end() ; w++) {
		cout << A.affiche(w->first) <<  " : ";
		cout.flush();
		val = A.p_directe(w->first);
		somme += val;
		cout << val ;
		val = A.plog(w->first);
		logsomme += val;
		cout << ", log p : " << val;
        cout << ", exp(log p) :" << exp(val);
        cout << endl;
	}
	cout << "sum = " << somme << ", somme de exp(log(p)) : " << logsomme << endl;
	return VAL(0);
}

void affiche_PSe(void) {
	SFunc PSe;
	SFunc::const_iterator q;
	int res;
		
	res = A.val_PSe(PSe);
	cout << "res = " << res << endl;
	
	for (q=PSe.begin() ; q != PSe.end() ; q++) {
		cout << "P_" << q->first << "(\\Se) = " << q-> second << endl;
	}
}


/// ############################################################################# ///
/// ###                           INIT COMMAND LINE + MAIN                   #### ///
/// ############################################################################# ///

// initialisation des arguments (ligne de commande)
int
initialise_arguments (int argc, char *argv[])
{
    string arg;
    int i = 1;
    while ((i < argc) && (argv[i][0] == '-'))
    { // pour chaque argument commenÁant par -
        arg = argv[i];
        if ((arg == "-h") || (arg == "--help"))
        {		// affiche l'aide
            throw 1;
        }
		// options muettes
        else if (
				 (arg == "--export") || // exporte vers des formats d'automates differents
				 (arg == "--convert") || // convertit des echantillons
				 (arg == "--dist") || // affiche la distance entre deux ffa
				 (arg == "--class") || // affiche la classe d'un pfa
				 (arg == "--sample") || // genere un Èchantillon
				 (arg == "--grp") ||  // genere un automate probabiliste
				 (arg == "--gcrp") || // genere un automate probabiliste complet
				 (arg == "--mdi") || // algorithme mdi
				 (arg == "--alergia") || // algorithme alergia
				 (arg == "--bm") || // algorithme Baum Welch 
				 (arg == "--affiche") || // affiche un automate sur la sortie standard
				 (arg == "-H") || // affiche l'aide Ètendue (options)
				 (arg == "-Y" || arg == "-I") || // envoie la fonction Y (mode interactif)
				 (arg == "--test") || // fait un test ‡ partir de l'automate
				 (arg == "--random") || // generate a random automaton
				 (arg == "--proba") || // show probabilities of words of a sample
				 (arg == "--forward") || // show forward values of words of a sample
				 (arg == "--deletetransitions") || // delete transitions of some value
				 ((arg == "-P") || (arg == "--showps")) || // affichage postscript
				 (arg == "--PSe")       // Affichage des valeurs de P(\Se) pour chaque état
				 
				 )
		{
		}
		else if (
				 (arg == "--dees")    || // algorithme dees (cible PRFA)
				 (arg == "--deesha")  || // algorithme deesha (cible MA)
				 (arg == "--deesdet") )  // algorithme basé sur dees mais se limitant aux solution déterministes
		{
			precision=1;
		} else if (arg == "--deesbm") // algorithme dees Baum Welch
		{
			precision=2; 
		}
        else if ((arg == "--DEBUG")
                 || (arg == "-d") || (arg == "--debug"))
        {
			// PFA_DEBUG=true;
        }
		else if (arg == "--interactive") 
		{
			interactive=true; 
			++i;
		}
        else if (arg == "--format")
        {
            format = argv[++i];
        }
        else if ((arg == "--VERBOSE") || (arg == "-v") || (arg == "--verbose"))
        {
            verbose = true;
            //      PFA_VERBOSE=true;
        }
        else if ((arg == "--MUTE") || (arg == "-m") || (arg == "--mute"))
        {
            //      PFA_VERBOSE=false;
            verbose = false;
        }
        else if ((arg == "--SAFE") || (arg == "--safe"))
        {
            //      PFA_SAFE=true;
        }
        else if ((arg == "--UNSAFE") || (arg == "--unsafe"))
        {
            //      PFA_SAFE=false;
        }
        else if ((arg == "--taille_ech") || (arg == "-te"))
        {
            convert << argv[++i];
            convert >> taille_ech;            
        }
		else if (arg == "--maxmots") {
			convert << argv[++i];
			convert >> maxmots;
		}
        else if (arg == "--num_ech")
        {
            num_ech = atoi (argv[++i]);
        }
        else if (arg == "--num_ech_test")
        {
            num_ech_test = atoi (argv[++i]);
        }
        else if ((arg == "--ficffaA") || (arg == "-i"))
        {
            ficffaA = argv[++i];
        }
        else if (arg == "--ficffaB")
        {
            ficffaB = argv[++i];
        }
        else if (arg == "-o")
        {
            ficffaA = ficech = ficffaB = ficdotB = ficpsB = argv[++i];
        }
        else if (arg == "--moderet")
        {
            arg = argv[++i];
            if (arg == "begin")
                moderet = ::begin;
            else
                moderet = ::end;
        }
        else if (arg == "--modeeps")
        {
            arg = argv[++i];
            if (arg == "fixed")
                modeeps = epsfixed;
            else if (arg == "variable")
                modeeps = variable;
			else
				cerr << "option for --modeeps can be 'fixed' or 'variable', here it is '" << arg << endl;
        }
        else if (arg == "--ficdotA")
        {
            ficdotA = argv[++i];
        }
        else if (arg == "--ficdotB")
        {
            ficdotB = argv[++i];
        }
        else if (arg == "--ficech")
        {
            ficech = argv[++i];
        }
        else if (arg == "--ficechpre")
        {
            ficechpre = argv[++i];
        }
        else if ((arg == "--precision") || (arg == "-p"))
        {
            precision = atof (argv[++i]);
        }
        else if (arg == "--epsprime")
        {
            epsprime = atof (argv[++i]);
        }
		else if (arg == "--seuil")
		{
			seuil = atoi (argv[++i]);
		}
        else if (arg == "--numPFA")
        {
            numPFA = atoi (argv[++i]);
        }
		else if (arg == "--seuilbm") 
		{
			seuilbm = atof (argv[++i]);
		}
		else if (arg == "--nb_tours") 
		{
			nb_tours = atoi (argv[++i]);
		}
		else if (arg == "--ficps")
        {
            ficpsA = argv[++i];
        }
        else if (arg == "--ficpsB")
        {
            ficpsB = argv[++i];
        }
		else if (arg == "--stepssave")
		{
			stepssave=true ;
		}
        else if (arg == "--nb_etats")
        {
            nb_etats = atoi (argv[++i]);
        }
		else if (arg == "--nb_essais") {
			nb_essais = atoi (argv[++i]);
		}
		else if (arg == "--max_states") {
			max_states = atoi (argv[++i]);
		}
        else if (arg == "--nb_lettres")
        {
            nb_lettres = atoi (argv[++i]);
        }
        else if (arg == "--precpow")
        {
            precpow = atof (argv[++i]);
        }
        else if (arg == "--affiche_A")
        {
            affiche_A = true;
        }
        else if (arg == "--affiche_B")
        {
            affiche_B = true;
        }
        else if (arg == "--blind")
        {
            affiche_A = affiche_B = false;
        }
        else if ((arg == "--taille_ech_test") || (arg == "-tt"))
        {
            taille_ech_test = atoi (argv[++i]);
        }
        else if (arg == "--name")
        {
            nom_A = argv[++i];
        }
        else if (arg == "--nom_B")
        {
            nom_B = argv[++i];
        }
        else if (arg == "--test_proportion")
        {
            test_proportion = atof (argv[++i]);
        }
		else if (arg == "--smooth") {
			smooth=true;
		}
		else if (arg == "--rand") {
			srand( atoi(argv[++i]) );			
		}
		else if (arg == "--viewprec") {
			viewprec=atoi(argv[++i]);
		}
		else if (arg == "--viewstates") {
			viewstates=true;
		}
		else if (arg == "--viewmultipletransitions") {
			viewmultipletransitions=true;
		}
        else
        {
            cerr << "unknow option : " << arg << endl;
        }
        i++;
    }
    return i;
}

// La procedure principale
int
main (int argc, char *argv[])
{
    int i = 0;
	string commande;
	commande = "mkdir " + temporary_directory + ">/dev/null 2>&1";
	system(commande.c_str());
    try
    {
        if (argc < 2)
            throw 1;
        randomize ();
        i = initialise_arguments (argc, argv);

        string arg;
        arg = argv[1];
        if (arg == "-h" || arg == "--help")
        {		// ---------- help ---------------
            throw 1;
        }
        else if (arg == "-H")
        {		// ----------------- HELP with options -------
            affiche_utilisation ();
            affiche_options ();
            cout << "Report bugs or suggestions to Yann Esposito <esposito@cmi.univ-mrs.fr>." << endl;
        }
        else if ((arg == "-Y") || (arg == "-I"))
        { // -------------- interactive mode -------------
            Y ();
        }
		else if (arg == "--test")
		{
			test();
		}
		else if (arg == "--PSe")
		{
            ficffaA = argv[i];
			if (!OK(A.load(ficffaA))) {
				throw string ("Erreur d'ouverture du fichier ") + ficffaA;
			}
			affiche_PSe();
		}
        else if (arg == "--export")
        {		// ---------------- exportation----------------
            if (argc < i + 3) {
				cerr << "export command export some automaton file to another format" << endl;
				cerr << "available format are dot, pdf and ffa." << endl;
				cerr << "usage: dees --export [OPTIONS] format input output" << endl;
                throw 2;
			}
			format = argv[i];
            ficffaA = argv[i+1];
            ficffaB = argv[i + 2];
            if (!OK(A.load (ficffaA))) {
				throw string ("Erreur d'ouverture du fichier ") + ficffaA;
			}
            A.name = nom_A;
            if (format == "dot")
            {	// exportation to dot format
                A.save_dot (ficffaB);
            }
            else if (format == "pdf")
            {	// exportation to ps format
                export_to_pdf (A, ficffaB, temporary_directory + "tmp.dot");
            }
            else if (format == "ffa")
            {	// exportation ffa
                A.save (ficffaB);
            }
            else
            {
				cerr << "export command export some automaton file to another format" << endl;
				cerr << "available format are dot, ps and ffa." << endl;
				cerr << "usage: dees --export [OPTIONS] format input output" << endl;
                throw 4;
            }
        }
        else if (arg == "--affiche")
        {		// ------------------------ affichage -------------------
            if (argc < i + 1) {
				cerr << "--affiche command show the automaton on standart output" << endl;
				cerr << "usage: dees --affiche [OPTIONS] automaton" << endl;
                throw 2;
			}
            A.load (argv[i]);
            A.affiche ();
        }
        else if ((arg == "--showps") || (arg == "-P"))
        {		// --- affichage du postscript ------
            if (argc < i + 1) {
				cerr << "showps or -P command show the automaton in gv" << endl;
				cerr << "you must have dot (part of Graphviz project) and a script named open" << endl;
				cerr << "which is a pdf viewer installed" << endl;
				cerr << "usage: dees <--showps or -P> [OPTIONS] automaton" << endl;
				cerr << "usefull option: --name name" << endl;
                throw 2;	// pas assez d'arguments
			}
            A.load (argv[i]);
            A.name = nom_A;
			show(A);
        }
        else if (arg == "--dist")
        {		// ----------------------- calcul des distances ------------
            if (argc < i + 2) {
				cerr << "dist command show some distances between two automata." << endl;
				cerr << "usage: dees --dist [OPTIONS] automaton_A automaton_B" << endl;
				cerr << "usefull option: --taille_ech_test size" << endl;
				cerr << " --smooth or --no_smooth" << endl;
                throw 2;
			}
            A.load (argv[i]);
            B.load (argv[i + 1]);
			if (smooth == true) {
				B.lisse ();
			}
            affiche_distance (A, B, taille_ech_test, "");
        }
		else if (arg == "--deletetransitions") {
			if (argc < i + 3) {
				cerr << "dees --deletetransitions input_pfa output_pfa min max\n";
				cerr << "delete transitions of the input_pfa which values are between min and max\n";
				cerr << "renormalise and save it in output_pfa file.\n";
				return -1;
			}
			PFA A;
			string input=argv[i++];
			string output=argv[i++];
			double min=atof(argv[i++]);
			double max=atof(argv[i++]);
			A.load(input);
			if (max < min) {
				double tmp = max;
				max=min;
				min=tmp;
				cerr << "Warning max < min !" << endl;
			}
			A.erase_transitions(max,min);
			A.rend_PFA();
			A.save(output);
		}
        else if (arg == "--sample")
        {		// --------------------- generation d'un echantillon ---
            if (argc < i + 3) {
				cerr << "sample command generate a sample from an automaton." << endl;
				cerr << "usage: dees --sample [OPTIONS] automaton size sample" << endl;
				cerr << "usefull options:" << endl;
				cerr << "--format <ffa, alergia or mdi>" << endl;
				cerr << "--num_ech num_sample" << endl;
                throw 2;
			}
            ficffaA = argv[i];			
            taille_ech = atoi (argv[i + 1]);
            ficech = argv[i + 2];
            A.load (ficffaA);
            A.genere_echantillon (taille_ech, S, num_ech);
            if (format == "ffa")
                S.save (ficech, ffa);
            else if (format == "alergia")
                S.save (ficech, alergia);
            else if (format == "mdi")
                S.save (ficech, mdi);
            else
                throw 4;
        }
		else if (arg == "--mdi") {
            if (argc > i)
            {
                ficech = argv[i];
            }
            else
            {
                throw 1;
            }
            if (verbose)
                cout << "loading " << ficech << "..." << endl;

			MDI(A,precision,ficech,verbose);
					
            if (verbose)
                cout << "saving A in " << ficffaA << endl;
            A.save (ficffaA);
            // affichage de l'automate
            if (affiche_A)
            {
                show(A);
            }
		}
		else if (arg == "--alergia") {
			if (argc <= i) 
				throw 1;
			
			ficech = argv[i];
            if (verbose)
                cout << "loading " << ficech << "..." << endl;

			Alergia(A,precision,ficech,verbose);
		
            if (verbose)
                cout << "saving A in " << ficffaA << endl;
			
            A.save (ficffaA);
            // affichage de l'automate
            if (affiche_A)
            {
                show(A);
            }
		}
        else if (arg == "--deesdet")
        {
			
            if (argc > i)
            {
                ficech = argv[i];
            }
            else
            {
				cerr << "--dees command learn an automaton using dees." << endl;
				cerr << "usage: dees --dees [OPTIONS] sample" << endl;
				cerr << "usefull options:" << endl;
				cerr << "-p or --precision float\tthe precision parameter" << endl;
				cerr << "--epsprime float\tnumber under which a transition is deleted" << endl;
				cerr << "-v or --verbose" << endl;
				cerr << "--moderet [begin or end]" << endl;
				cerr <<  "--max_states number" << endl;
				cerr << "--seuil seuil" << endl;
				cerr << "--stepssave\tsave steps of the algorithm" << endl;
                throw 2;
            }
            if (verbose)
                cout << "loading " << ficech << "..." << endl;
            if (!OK (S.load (ficech.c_str ())))
            {
                cerr << "impossible d'ouvrir " << ficech << endl;
                throw 5;
            }
			
			epsprime = precision*pow(double(S.size()),-0.25)/5;
			epsprime = min(sqrt(precision),0.1);
			
            A.DEES (determinist, S, precision, epsprime, verbose, moderet, modeeps, max_states, seuil,10,0,true,stepssave);
            if (verbose)
                cout << "saving A in " << ficffaA << endl;
            A.save (ficffaA);
            // affichage de l'automate
            if (affiche_A)
            {
                show(A);
            }
        }		
        else if (arg == "--dees")
        {

            if (argc > i)
            {
                ficech = argv[i];
            }
            else
            {
				cerr << "--dees command learn an automaton using dees." << endl;
				cerr << "usage: dees --dees [OPTIONS] sample" << endl;
				cerr << "usefull options:" << endl;
				cerr << "-p or --precision float\tthe precision parameter" << endl;
				cerr << "--epsprime float\tnumber under which a transition is deleted" << endl;
				cerr << "-v or --verbose" << endl;
				cerr << "--moderet [begin or end]" << endl;
				cerr <<  "--max_states number" << endl;
				cerr << "--seuil seuil" << endl;
				cerr << "--stepssave\tsave steps of the algorithm" << endl;
                throw 2;
            }
            if (verbose)
                cout << "loading " << ficech << "..." << endl;
            if (!OK (S.load (ficech.c_str ())))
            {
                cerr << "impossible d'ouvrir " << ficech << endl;
                throw 5;
            }

			epsprime = precision*pow(double(S.size()),-0.25)/5;
			epsprime = min(sqrt(precision),0.1);

            A.DEES (positive, S, precision, epsprime, verbose, moderet, modeeps, max_states, seuil,10,0,true,stepssave);
            if (verbose)
                cout << "saving A in " << ficffaA << endl;
            A.save (ficffaA);
            // affichage de l'automate
            if (affiche_A)
            {
                show(A);
            }
        }
		else if (arg == "--deesbm") {
			// --- DEES version Baum Welch ---
            if (argc > i)
            {
                ficech = argv[i];
            }
            else
            {
				cerr << "--deesbm command learn an automaton using deesbm." << endl;
				cerr << "usage: dees --deesbm [OPTIONS] sample" << endl;
				cerr << "usefull options:" << endl;
				cerr << "-p or --precision number" << endl;
				cerr << "-v or --verbose" << endl;
				cerr << "--max_states number\tmaximal number of states" << endl;
				cerr << "--seuil number\tminimal number of suffix do use residual" << endl;
				cerr << "--nb_tours number\tmax number of turns for Baum Welch" << endl;
				cerr << "--seuilbm double\tprecision under which Baum Welch is considered to found the Max Likelihood Model" << endl;
				cerr << "-o or --ficffaA file\ttarget file" << endl;
                throw 2;
            }
            if (verbose)
                cout << "loading " << ficech << "..." << endl;
            if (!OK (S.load (ficech.c_str ())))
            {
                cerr << "impossible d'ouvrir " << ficech <<
                endl;
                throw 5;
            }
						
			epsprime = precision*pow(double(S.size()),-0.25)/5;

            A.DEESBM (S, precision, epsprime, verbose, max_states, seuil, seuilbm, nb_tours);
            if (verbose)
                cout << "saving A in " << ficffaA << endl;
			// A.emmonde();
            A.save (ficffaA);
            // affichage de l'automate
            if (affiche_A)
            {
                show(A);
            }		
		}
		else if (arg == "--deesha")
        {
			
            if (argc > i)
            {
                ficech = argv[i];
            }
            else
            {
                throw 1;
            }
            if (verbose)
                cout << "loading " << ficech << "..." << endl;
            if (!OK (S.load (ficech.c_str ())))
            {
                cerr << "impossible d'ouvrir " << ficech <<
                endl;
                throw 5;
            }
			
			// epsprime = precision/(2*sqrt(sqrt(n)))
			// epsprime est donc un o(precision)
			epsprime = precision*pow(double(S.size()),-0.25)/5;
			
            A.DEES (nonconstrained, S, precision, epsprime, verbose, moderet,modeeps, max_states, seuil, maxmots);
            if (verbose)
                cout << "saving A in " << ficffaA << endl;
			// A.emmonde();
            A.save (ficffaA);
            // affichage de l'automate
            if (affiche_A)
            {
                show(A);
            }
        }		
        else if ((arg == "--generate_complete_random_pfa") || (arg == "--gcrp"))
        {		// --- generation d'un pfa aléatoire complet ---
			generate_complete_random_pfa(argc, argv, i);
        }
        else if ((arg == "--generate_random_pfa") || (arg == "--grp"))
        {
			generate_random_pfa(argc, argv, i);
		}
		else if (arg == "--proba") { // show values of words for an MA
			show_sample_proba(argc, argv, i);
		}
		else if (arg == "--forward") { // show prefix values of words for an MA
			show_sample_forward(argc, argv, i);
		}
        else if (arg == "--class")
        {		// --- show the class of the automaton
            if (argc < 3)
                throw 2;
            A.load (argv[2]);
            affiche_classe (A);
        }
		else if (arg == "--bm") { // Baum Welch Algorithm
			if (argc < i+4) {
				cerr << "dees --bm pfa sample number_of_turns output_pfa\n";
				cerr << "work baum welch using the pfa for initialisation (structure + parameters)\n";
				cerr << "remember Baum Welch never change a 0 valued parameter\n";
				return -1;
			}
			string pfa=argv[i++];
			string sample=argv[i++];
			int nb_turns=atoi(argv[i++]);
			string output=argv[i++];
			
			A.load(pfa);
			S.load(sample);
			BaumWelch(A,S,nb_turns,output);
		}
		else if (arg == "--convert") {
			if (argc < i+3) {
				cerr << "dees --convert format sample output\n";
				cerr << "Change the format of the sample to output.\n";
				cerr << "format could be dees for internal, alergia or mdi\n";
				return -1;
			}
			string format=argv[++i];
			string input=argv[++i];
			string output=argv[++i];
			S.load(input);
			if (format == "alergia") {
				S.save(output, alergia);
			}
			else if (format == "mdi") {
				S.save(output, mdi);
			}
			else {
				S.save(output);
			}
		}
        else
        {		// ---------- choix non traitÈ -------------
            throw 1;
        }
        return EXIT_SUCCESS;
    }
    catch (int err)
    {
        switch (err)
        {
        case 1:
            affiche_utilisation ();
            cout << "Report bugs or suggestions to Yann Esposito <esposito@cmi.univ-mrs.fr>." << endl;
            break;
        case 2:
            cerr << "\nNo enougth arguments" << endl;
            break;
        case 3:
            cerr << "Input error, I cannot read the file." <<
            argv[i] << endl;
            break;
        case 4:
            cerr << format << "is an unknown format." << endl;
            break;
        case 5:
            cerr << "I/O Error !!!" << endl;
            break;
        default:
            cerr << "unknown error occured !" << endl;
        }

        if (err != 1)
        {
            cerr << "use -h, --help or -H option to display help" << endl;
        }
    }
	catch (string erreur) {
		cerr << erreur << endl;
	}
    catch (...)
    {
        cerr << "Unknown error !!!" << endl;
        affiche_utilisation ();
        return -1;
    }
}