wrapped_generator.h

Go to the documentation of this file.

/* 
 * Scythe Statistical Library
 * Copyright (C) 2000-2002 Andrew D. Martin and Kevin M. Quinn;
 * 2002-present Andrew D. Martin, Kevin M. Quinn, and Daniel
 * Pemstein.  All Rights Reserved.
 *
 * This program is free software; you can redistribute it and/or modify
 * under the terms of the GNU General Public License as published by
 * Free Software Foundation; either version 2 of the License, or (at
 * your option) any later version.  See the text files COPYING
 * and LICENSE, distributed with this source code, for further
 * information.
 * --------------------------------------------------------------------
 * scythestat/rng/wrapped_generator.h
 *
 * Provides a class definition that allows users to adapt non-Scythe
 * pseudo-random number generators to Scythe's rng interface.
 * Specifically, wraps any functor that generators uniform variates on
 * (0, 1).
 *
 */

#ifndef SCYTHE_WRAPPED_GENERATOR_H
#define SCYTHE_WRAPPED_GENERATOR_H

#ifdef SCYTHE_COMPILE_DIRECT
#include "rng.h"
#else
#include "scythestat/rng.h"
#endif

namespace scythe {

  template <typename ENGINE>
  class wrapped_generator: public rng<wrapped_generator<ENGINE> >
  {
    public:

      wrapped_generator (ENGINE& e)
        : rng<wrapped_generator<ENGINE> > (),
          engine (e)
      {}

      wrapped_generator(const wrapped_generator& wg)
        : rng<wrapped_generator<ENGINE> > (),
          engine (wg.engine)
      {}

      inline double runif()
      {
        return engine();
      }

      /* We have to override the overloaded forms of runif because
       * overloading the no-arg runif() hides the base class
       * definition; C++ stops looking once it finds the above.
       */
      template <matrix_order O, matrix_style S>
      inline Matrix<double,O> runif(unsigned int rows,
                                    unsigned int cols)
      {
        return rng<wrapped_generator<ENGINE> >::runif<O, S>(rows, cols);
      }

      Matrix<double,Col,Concrete> runif (unsigned int rows,
                                         unsigned int cols)
      {
        return rng<wrapped_generator<ENGINE> >::runif<Col,Concrete>(rows, 
            cols);
      }

    protected:
      ENGINE& engine; // The wrapped runif engine
  };
} // end namespace scythe

#endif /* SCYTHE_WRAPPED_GENERATOR_H */