transducer_maker.thxx

//                                                      -*- C++ -*-
// transducer_maker.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.
//

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

#include <vaucanson/algorithms/internal/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_GRAPH_IMPL
  {

    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());
      typename output_projection_helper<TransStruct, TransImpl>::ret::set_t 
        ret_set(t.structure().series().semiring());
      AUTOMATON_CONTEXT::gen_automaton_t result (ret_set);
      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 VCSN_CONTEXT_NAMESPACE.
  }// End of VCSN_GRAPH_IMPL.
} // End of namespace vcsn.

---