transducer_functions.thxx

//                                                      -*- C++ -*-
// transducer_functions.thxx: this file is part of the Vaucanson project.
//
// Vaucanson, a generic library for finite state machines.
//
// Copyright (C) 2004, 2005, 2006 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.
//

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

namespace vcsn
{

  namespace VCSN_CONTEXT_NAMESPACE
  {

    /*-----------------.
    | make_automaton() |
    `-----------------*/

    template <class InputIterator>
    automaton_t
    make_automaton(InputIterator input_alphabet_begin,
                   InputIterator input_alphabet_end,
                   InputIterator output_alphabet_begin,
                   InputIterator output_alphabet_end)
    {
      alphabet_t                input_alpha;
      alphabet_t                output_alpha;

      for (InputIterator e = input_alphabet_begin;
           e != input_alphabet_end; ++e)
        input_alpha.insert(*e);

      for (InputIterator e = output_alphabet_begin;
           e != output_alphabet_end; ++e)
        output_alpha.insert(*e);

      monoid_t                  output_freemonoid (output_alpha);
      typename output_series_set_t::semiring_t  semiring;
      output_series_set_t       output_series (semiring, output_freemonoid);
      monoid_t                  freemonoid (input_alpha);
      series_set_t              series (output_series, freemonoid);
      automata_set_t            automata_set (series);

      return automaton_t (automata_set);
    }


    template <class T>
    automaton_t make_automaton(const T& input_alphabet,
                               const T& output_alphabet)
    {
      return make_automaton(input_alphabet.begin(),
                            input_alphabet.end(),
                            output_alphabet.begin(),
                            output_alphabet.end());
    }


    template <typename TransStruct,
              typename TransImpl,
              typename MonoidStruct,
              typename MonoidImpl>
    output_series_set_elt_t
    do_evaluation(const vcsn::TransducerBase<TransStruct>&,
                  const TransImpl&,
                  const vcsn::algebra::FreeMonoidBase<MonoidStruct>&,
                  const MonoidImpl& input,
                  const Element<TransStruct, TransImpl>& t,
                  const Element<MonoidStruct, MonoidImpl>&)
    {
      return eval(t, input);
    }


    template <typename TransStruct,
              typename TransImpl,
              typename SeriesStruct,
              typename SeriesImpl,
              typename S,
              typename T>
    output_series_set_elt_t
    do_evaluation(const vcsn::TransducerBase<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().alphabet());
      AUTOMATON_CONTEXT::gen_automaton_t result (w.structure());
      standard_of(w, input);
      evaluation(quotient(w), t, result);
      return aut_to_exp(quotient(realtime(trim(result))), DMChooser());
    }


    template <typename TransStruct,
              typename TransImpl,
              typename ArgStruct,
              typename ArgImpl>
    output_series_set_elt_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 namespace VCSN_CONTEXT_NAMESPACE.

} // End of namespace vcsn.

---