fmp_transducer_maker.thxx

//							-*- C++ -*-
// fmp_transducer_maker.thxx: this file is part of the Vaucanson project.
//
// Vaucanson, a generic library for finite state machines.
//
// Copyright (C) 2005, 2006, 2008 The Vaucanson Group.
//
// 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.
//
// The complete GNU General Public Licence Notice can be found as the
// `COPYING' file in the root directory.
//
// The Vaucanson Group consists of people listed in the `AUTHORS' file.
//

/*
 * CPP guard should not be inserted here as
 * VCSN_CONTEXT_NAMESPACE could be changed.
 */

#include <vaucanson/algorithms/minimization_hopcroft.hh>
#include <vaucanson/algorithms/evaluation_fmp.hh>
#include <vaucanson/algorithms/aut_to_exp.hh>
#include <vaucanson/algorithms/trim.hh>
#include <vaucanson/algorithms/realtime.hh>

namespace vcsn
{
  namespace VCSN_GRAPH_IMPL
  {
    VCSN_CONTEXT_NAMESPACE
    {

      template <class FirstInputIterator, class SecondInputIterator>
      automata_set_t make_automata_set(const FirstInputIterator first_begin,
				       const FirstInputIterator first_end,
				       const SecondInputIterator second_begin,
				       const SecondInputIterator second_end)
      {
	first_alphabet_t first_alpha;

	for (FirstInputIterator e = first_begin; e != first_end; ++e)
	  first_alpha.insert(*e);

	second_alphabet_t second_alpha;

	for (SecondInputIterator e = second_begin; e != second_end; ++e)
	  second_alpha.insert(*e);

	semiring_t	semiring;
	first_monoid_t	mA(first_alpha);
	second_monoid_t	mB(second_alpha);
	monoid_t	freemonoidproduct(mA, mB);
	series_set_t	series(semiring, freemonoidproduct);

	return automata_set_t(series);
      }

      template <class FirstInputIterator, class SecondInputIterator>
      automata_set_t make_automata_set(const FirstInputIterator first_begin,
				       const FirstInputIterator first_end,
				       const SecondInputIterator second_begin,
				       const SecondInputIterator second_end,
				       const monoid_rep_t& mrep,
				       const first_monoid_rep_t& mrep1,
				       const second_monoid_rep_t& mrep2,
				       const series_rep_t& srep)
      {
	first_alphabet_t first_alpha;

	for (FirstInputIterator e = first_begin; e != first_end; ++e)
	  first_alpha.insert(*e);

	second_alphabet_t second_alpha;

	for (SecondInputIterator e = second_begin; e != second_end; ++e)
	  second_alpha.insert(*e);

	semiring_t	semiring;
	first_monoid_t	mA(first_alpha, mrep1);
	second_monoid_t	mB(second_alpha, mrep2);
	monoid_t	freemonoidproduct(mA, mB, mrep);
	series_set_t	series(semiring, freemonoidproduct, srep);

	return automata_set_t(series);
      }

      template <class FirstInputIterator, class SecondInputIterator>
      automaton_t make_automaton(const FirstInputIterator first_begin,
				 const FirstInputIterator first_end,
				 const SecondInputIterator second_begin,
				 const SecondInputIterator second_end)
      {
	return automaton_t(make_automata_set(first_begin, first_end,
					     second_begin, second_end));
      }

      template <class FirstInputIterator, class SecondInputIterator>
      automaton_t make_automaton(const FirstInputIterator first_begin,
				 const FirstInputIterator first_end,
				 const SecondInputIterator second_begin,
				 const SecondInputIterator second_end,
				 const monoid_rep_t& mrep,
				 const first_monoid_rep_t& mrep1,
				 const second_monoid_rep_t& mrep2,
				 const series_rep_t& srep)
      {
	return automaton_t(make_automata_set(first_begin, first_end,
					     second_begin, second_end,
					     mrep, mrep1, mrep2,
					     srep));
      }

      template <class T1, class T2>
      automaton_t make_automaton(const T1& first_alphabet,
				 const T2& second_alphabet)
      {
	return make_automaton(first_alphabet.begin(), first_alphabet.end(),
			      second_alphabet.begin(), second_alphabet.end());
      }

      template <class T1, class T2>
      automaton_t make_automaton(const T1& first_alphabet,
				 const T2& second_alphabet,
				 const monoid_rep_t& mrep,
				 const first_monoid_rep_t& mrep1,
				 const second_monoid_rep_t& mrep2,
				 const series_rep_t& srep)
      {
	return make_automaton(first_alphabet.begin(), first_alphabet.end(),
			      second_alphabet.begin(), second_alphabet.end(),
			      mrep, mrep1, mrep2, srep);
      }

      template <class FirstIterator, class SecondIterator>
      monoid_elt_t make_couple(const FirstIterator first_begin,
			       const FirstIterator first_end,
			       const SecondIterator second_begin,
			       const SecondIterator second_end,
			       const first_monoid_elt_value_t& first_exp,
			       const second_monoid_elt_value_t& second_exp)
      {
	first_alphabet_t	first_alpha;
	for (FirstIterator e = first_begin; e != first_end; ++e)
	  first_alpha.insert(*e);

	second_alphabet_t	second_alpha;
	for (SecondIterator e = second_begin; e != second_end; ++e)
	  second_alpha.insert(*e);

	monoid_t		fmp (first_alpha, second_alpha);
	monoid_elt_value_t	fmp_elt_value (first_exp, second_exp);

	return Element<monoid_t, monoid_elt_value_t> (fmp, fmp_elt_value);
      }

      template <class T1, class T2>
      monoid_elt_t make_couple(const T1& first_alphabet,
			       const T2& second_alphabet,
			       const first_monoid_elt_value_t& first_exp,
			       const second_monoid_elt_value_t& second_exp)
      {
	return make_couple(first_alphabet.begin(), first_alphabet.end(),
			   second_alphabet.begin(), second_alphabet.end(),
			   first_exp, second_exp);
      }


      template <typename TransStruct,
	        typename TransImpl,
	        typename SeriesStruct,
	        typename SeriesImpl,
	        typename S,
	        typename T>
      AUTOMATON_CONTEXT::rat_exp_t
      do_evaluation(const vcsn::AutomataBase<TransStruct>&,
		    const TransImpl&,
		    const SeriesStruct&,
		    const vcsn::rat::exp<S, T>& input,
		    const Element<TransStruct, TransImpl>& t,
		    const Element<SeriesStruct, SeriesImpl>&)
      {
	AUTOMATON_CONTEXT::automaton_t w = AUTOMATON_CONTEXT::make_automaton(t.structure().series()
	    .monoid().first_monoid().alphabet());
	AUTOMATON_CONTEXT::automaton_t result = AUTOMATON_CONTEXT::make_automaton(t.structure().series()
	    .monoid().second_monoid().alphabet());
	standard_of(w, input);
	evaluation_fmp(t, quotient(w), result);

	return aut_to_exp(generalized_traits<AUTOMATON_CONTEXT::automaton_t>::generalized(quotient(realtime(trim(result)))),
	    DMChooser());
      }


      template <typename TransStruct,
	        typename TransImpl,
	        typename ArgStruct,
	        typename ArgImpl>
      AUTOMATON_CONTEXT::rat_exp_t
      evaluation(const Element<TransStruct, TransImpl>& t,
		 const Element<ArgStruct, ArgImpl>& input)
      {
	return do_evaluation(t.structure(), t.value(),
			     input.structure(), input.value(),
			     t, input);
      }


    } // End of VCSN_CONTEXT_NAMESPACE.
  } // End of VCSN_GRAPH_IMPL.
} // End of namespace vcsn.