random.hh

Go to the documentation of this file.

// random.hh: this file is part of the Vaucanson project.
//
// Vaucanson, a generic library for finite state machines.
//
// Copyright (C) 2001, 2002, 2003, 2004, 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.
//
#ifndef VCSN_MISC_RANDOM_HH
# define VCSN_MISC_RANDOM_HH

# include <vaucanson/algebra/implementation/letter/range.hh>
# include <vaucanson/algebra/implementation/semiring/q_number.hh>

namespace vcsn {
  namespace misc {

    namespace random {


      template<typename T>
      T generate ();

      template<typename T>
      T generate (T min, T max);


      template<>
      char generate<char> ();

      template<>
      char generate<char> (char min, char max);

      char generate_letter ();

      char generate_digit ();

      template<>
      bool generate<bool> ();

      template<>
      int generate<int> ();

      template<>
      int generate<int> (int min, int max);

      template<>
      unsigned generate<unsigned> ();

      template<>
      unsigned generate<unsigned> (unsigned min, unsigned max);

      template<>
      float generate<float> ();

      template<>
      float generate<float> (float min, float max);

      template<>
      double generate<double> ();

      template<>
      double generate<double> (double min, double max);

      template <class IteratorValueType, class InputIterator, class OutputIterator>
      void sample_n (const IteratorValueType&, InputIterator first, InputIterator end,
                     OutputIterator out, unsigned n);

      template<>
      vcsn::algebra::RationalNumber generate<vcsn::algebra::RationalNumber> ();

      template<>
      vcsn::algebra::RationalNumber
      generate<vcsn::algebra::RationalNumber>
      (const vcsn::algebra::RationalNumber min,
       const vcsn::algebra::RationalNumber max);

# define DECLARE_PAIR_SPECIALIZATION(TYPE1, TYPE2) \
      template <> \
      std::pair<TYPE1, TYPE2> generate<std::pair<TYPE1, TYPE2> >()

      DECLARE_PAIR_SPECIALIZATION(char, char);
      DECLARE_PAIR_SPECIALIZATION(char, int);
      DECLARE_PAIR_SPECIALIZATION(int,  int);
      DECLARE_PAIR_SPECIALIZATION(int,  char);

# undef DECLARE_PAIR_SPECIALIZATION


      typedef
      vcsn::algebra::static_char_interval<'a', 'z'>
      small_alpha_interval_t;

      typedef
      vcsn::algebra::static_ranged<char, small_alpha_interval_t>
      small_alpha_letter_t;

      template <>
      small_alpha_letter_t
      generate<small_alpha_letter_t> ();
    }
  } // end of namespace misc.
} // end of namespace vcsn.


# if !defined VCSN_USE_INTERFACE_ONLY || defined VCSN_USE_LIB
#  include <vaucanson/misc/random.hxx>
# endif // VCSN_USE_INTERFACE_ONLY


#endif // ! VCSN_MISC_RANDOM_HH