random.hxx

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

# include <vaucanson/misc/random.hh>
# include <vaucanson/misc/limits.hh>

# include <cmath>
# include <cstdlib>
# include <vector>

namespace utility {
  namespace random {

    template<>
    inline char generate<char>()
    {
      // We do not want any 0, because it could generate errors in strings.
      return char (1 + unsigned(rand()) % ((1 << (sizeof(char) * 8)) - 1));
    }

    template<>
    inline char generate<char>(char min, char max)
    {
      unsigned range = unsigned(max - min) + 1;
      return char(min + rand() % range);
    }

    inline char generate_letter()
    {
      return generate<char>('a', 'z');
    }

    inline char generate_digit()
    {
      return generate<char>('0', '9');
    }

    template<>
    inline bool generate<bool>()
    {
      return static_cast<bool>(rand() & 1);
    }

    template<>
    inline int generate<int>()
    {
      int res = rand() % utility::limits<int>::max();
      return generate<bool>() ? res : res * -1;
    }

    template<>
    inline int generate<int>(int min, int max)
    {
      unsigned range = unsigned(max - min) + 1;
      return min + rand() % range;
    }

    template<>
    inline unsigned generate<unsigned>()
    {
      return rand() % utility::limits<unsigned>::max();
    }

    template<>
    inline unsigned generate<unsigned>(unsigned min, unsigned max)
    {
      unsigned range = unsigned(max - min) + 1;
      return min + rand() % range;
    }

    template<>
    inline float generate<float>()
    {
      // This formula comes from the caml stdlib. It generates numbers
      // between -2 and 2 (values that can be starable or not).
      return (((static_cast<float> (rand()) / RAND_MAX +
                static_cast<float> (rand())) / RAND_MAX +
               static_cast<float> (rand())) / RAND_MAX) * 4 - 2;
    }

    template<>
    inline float generate<float>(float min, float max)
    {
      float range = float(max - min);
      float generate_one = ((static_cast<float> (rand()) / RAND_MAX +
                              static_cast<float> (rand())) / RAND_MAX +
                             static_cast<float> (rand())) / RAND_MAX;

      return min + generate_one * range;;
    }

    template<>
    inline double generate<double>()
    {
      // This formula comes from the caml stdlib. It generates numbers
      // between -2 and 2 (values that can be starable or not).
      return (((static_cast<double> (rand()) / RAND_MAX +
               static_cast<double> (rand())) / RAND_MAX +
              static_cast<double> (rand())) / RAND_MAX) * 4 - 2;
    }

    template<>
    inline double generate<double>(double min, double max)
    {
      double range = double(max - min);
      double generate_one = ((static_cast<double> (rand()) / RAND_MAX +
                              static_cast<double> (rand())) / RAND_MAX +
                             static_cast<double> (rand())) / RAND_MAX;

      return min + generate_one * range;;
    }

    template <class Iterator, class OutputIterator>
    void sample_n(Iterator first, Iterator end,
                  OutputIterator out, unsigned n)
    {
      std::vector<int> from;
      for (Iterator i = first; i != end; ++i)
          from.push_back(*i);

      while ((from.size () > 0) && (n > 0))
        {
          int  c = generate<int>(0, from.size() - 1);
          *out = from[c];
          ++out;
          from.erase(from.begin() + c);
          --n;
        }
    }

    template<>
    inline
    vcsn::algebra::RationalNumber
    generate<vcsn::algebra::RationalNumber>()
    {
      const int num = generate<int>();
      const unsigned denom =
        generate<unsigned>(1, utility::limits<unsigned>::max());
      return vcsn::algebra::RationalNumber(num, denom);
    }

    template<>
    inline
    vcsn::algebra::RationalNumber
    generate<vcsn::algebra::RationalNumber>
    (const vcsn::algebra::RationalNumber min,
     const vcsn::algebra::RationalNumber max)
    {
      const int denom = vcsn::algebra::lcm(min.denom(), max.denom());
      const int num1 = min.num()*denom/min.denom();
      const int num2 = max.num()*denom/max.denom();
      const int maxi = std::max(std::max(abs(num1), abs(num2)),denom);
      const int ratio = (utility::limits<int>::max()-1)/maxi;
      return
        vcsn::algebra::RationalNumber(generate<int>(num1*ratio, num2*ratio),
                                      denom * ratio);
    }

    template <>
    inline
    std::pair<char, int> generate<std::pair<char, int> >()
    {
      return std::make_pair(generate<char>(), generate<int>());
    }

    template <>
    inline
    small_alpha_letter_t
    generate<small_alpha_letter_t>()
    {
      return generate<char>(small_alpha_interval_t::from_value,
                            small_alpha_interval_t::to_value);
    }

  } // Random

} // vcsn

#endif // ! VCSN_MISC_RANDOM_HXX

---