random.h

Go to the documentation of this file.

// -*- C++ -*-

// PLearn (A C++ Machine Learning Library)
// Copyright (C) 1998 Pascal Vincent
// Copyright (C) 1999-2002 Pascal Vincent, Yoshua Bengio and University of Montreal, all rights reserved
//

// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
// 
//  1. Redistributions of source code must retain the above copyright
//     notice, this list of conditions and the following disclaimer.
// 
//  2. Redistributions in binary form must reproduce the above copyright
//     notice, this list of conditions and the following disclaimer in the
//     documentation and/or other materials provided with the distribution.
// 
//  3. The name of the authors may not be used to endorse or promote
//     products derived from this software without specific prior written
//     permission.
// 
// THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN
// NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
// TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// 
// This file is part of the PLearn library. For more information on the PLearn
// library, go to the PLearn Web site at www.plearn.org

/* *******************************************************      
   * $Id: random.h,v 1.7 2004/04/12 00:36:28 yoshua Exp $
   ******************************************************* */

#ifndef RANDOM_H
#define RANDOM_H

#include "TMat.h"

namespace PLearn {
using namespace std;

  /*

  Special functions.
  -----------------
  */

real  log_gamma(real x);

real log_beta(real x, real y);

real incomplete_beta(real z, real x, real y);
//double incbet(double x, double y, double z);

real student_t_cdf(real t, int nb_degrees_of_freedom);

  void  seed();
  void  manual_seed(long x);
  long  get_seed();

  real  uniform_sample();
  real  bounded_uniform(real a,real b);

  real  expdev();
  real  gaussian_01();
  inline real normal_sample() { return gaussian_01(); }

  real  gaussian_mu_sigma(real mu, real sigma);

  real  gaussian_mixture_mu_sigma(Vec& w, const Vec& mu, const Vec& sigma);

  real  gamdev(int ia);
  real  poidev(real xm);
  real  bnldev(real pp, int n=1);
  inline real binomial_sample(real prob1) { return bnldev(prob1); }

  int  multinomial_sample(const Vec& distribution);

  int uniform_multinomial_sample(int N);

  template <class T>
  void bootstrap_rows(const TMat<T>& source, TMat<T> destination)
  {
    int N=source.length();
    destination.resize(N,source.width());
    for (int i=0;i<N;i++)
    {
      int j = uniform_multinomial_sample(N);
      destination(i) << source(j);
    }
  }

  void fill_random_uniform(const Vec& dest, real minval=0, real maxval=1);

  void fill_random_discrete(const Vec& dest, const Vec& set);

  void fill_random_normal(const Vec& dest, real mean=0, real stdev=1);

  void fill_random_normal(const Vec& dest, const Vec& mean, const Vec& stdev);

  void fill_random_uniform(const Mat& dest, real minval=0, real maxval=1);
  void fill_random_normal(const Mat& dest, real mean=0, real sdev=1);


template<class T>
void shuffleElements(const TVec<T>& vec)
{
  T* v = vec.data();
  for(int i=0; i<vec.length(); i++)
    {
      int j = i+(int)(uniform_sample()*(vec.length()-i));
      // int j=(int)floor(i+uniform_sample()*(length()-i-1e-5));
      if(j!=i)
        {
          T tmp = v[i];
          v[i] = v[j];
          v[j] = tmp;
        }
    }
}


// Performs a random permutation of all the rows of this Mat
template<class T>
void shuffleRows(const TMat<T>& mat)
{
  for(int i=0; i<mat.length(); i++)
    {
      int j = i+int(uniform_sample()*(mat.length()-i));
      mat.swapRows(i,j);
    }
}

template<class T>
void computeRanks(const TMat<T>& mat, TMat<T>& ranks)
{
  int width=mat.width();
  int n=mat.length();
  ranks.resize(n,width);
  TVec<Mat> sorted(width); 
  // sort all the y's
  for (int j=0;j<width;j++)
    sorted[j].resize(n,2);
  for (int i=0;i<n;i++)
  {
    for (int j=0;j<width;j++)
    {
      sorted[j](i,0)=mat(i,j);
      sorted[j](i,1)=i;
    }
  }
  for (int j=0;j<width;j++)
  {
    shuffleRows(sorted[j]); // to randomly permute the order of elements which have the same value, i.e. their rank within their category
    sortRows(sorted[j]);
  }
  // compute the ranks
  for (int i=0;i<n;i++)
    for (int j=0;j<width;j++)
      ranks(int(sorted[j](i,1)),j) = i;
}

} // end of namespace PLearn

#endif

---