// ===================================================================
// $Id: detrnd.cpp,v 1.2 2003/11/04 15:27:18 havran Exp $
//
// detrnd.h:
//    A set of function to generate random number given a seed and
//    dimension for multidimensional setting. Thus deterministic
//    random generator.
//
// Licence and usage conditions in November 2003:
// This file can be used and modified only with written permission of
// Vlastimil Havran, Pohodli 27, 57001 Litomysl, the Czech Republic.
// This library is granted to be used by Polina Kondratieva within
// her MPI HIWI job working on BRDFLIB library. The usage condition
// may change in the next version of the library. At the moment,
// the library development is supported by Max-Planck-Institut for
// Informatik, Stuhlsatzenhausweg 85, 66123 Saarbruecken Germany
// See WWW: http://www.mpi-sb.mpg.de
// REPLACEMENT_STRING
//
// Initial coding by Vlastimil Havran, October 2003.
//
// Given to BRDFLIB project for the Polina Kondratieva's
// HIWI JOB assignment in November 2003.

// BRDFLIB headers
#include "config.h"
#include "detrnd.h"

// standard headers
#include <cstdlib>


__BEGIN_BRDFLIB_SOURCE

// -------------------------------------------------------------------------
// constructor
CMultDimRNDGen_ANSIC::CMultDimRNDGen_ANSIC():
  CMultDimRNDGen(), _seed(0)
{

}

// Note that this was taken from random.c written by the University
// of California, Berkeley.

/*
 * Copyright (c) 1983 Regents of the University of California.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms are permitted
 * provided that the above copyright notice and this paragraph are
 * duplicated in all such forms and that any documentation,
 * advertising materials, and other materials related to such
 * distribution and use acknowledge that the software was developed
 * by the University of California, Berkeley.  The name of the
 * University may not be used to endorse or promote products derived
 * from this software without specific prior written permission.
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
 * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 */

/*
 * For each of the currently supported random number generators, we have a
 * break value on the amount of state information (you need at least this
 * many bytes of state info to support this random number generator), a degree
 * for the polynomial (actually a trinomial) that the R.N.G. is based on, and
 * the separation between the two lower order coefficients of the trinomial.
 */

#define         TYPE_0          0               /* linear congruential */
#define         BREAK_0         8
#define         DEG_0           0
#define         SEP_0           0

#define         TYPE_1          1               /* x**7 + x**3 + 1 */
#define         BREAK_1         32
#define         DEG_1           7
#define         SEP_1           3

#define         TYPE_2          2               /* x**15 + x + 1 */
#define         BREAK_2         64
#define         DEG_2           15
#define         SEP_2           1

#define         TYPE_3          3               /* x**31 + x**3 + 1 */
#define         BREAK_3         128
#define         DEG_3           31
#define         SEP_3           3

#define         TYPE_4          4               /* x**63 + x + 1 */
#define         BREAK_4         256
#define         DEG_4           63
#define         SEP_4           1

/*
 * Initially, everything is set up as if from :
 *              initstate( 1, &randtbl, 128 );
 * Note that this initialization takes advantage of the fact that srandom()
 * advances the front and rear pointers 10*rand_deg times, and hence the
 * rear pointer which starts at 0 will also end up at zero; thus the zeroeth
 * element of the state information, which contains info about the current
 * position of the rear pointer is just
 *      MAX_TYPES*(rptr - state) + TYPE_3 == TYPE_3.
 */

static  long            randtbl[ DEG_3 + 1 ]    = { TYPE_3,
                            0x9a319039, 0x32d9c024, 0x9b663182, 0x5da1f342, 
                            0xde3b81e0, 0xdf0a6fb5, 0xf103bc02, 0x48f340fb, 
                            0x7449e56b, 0xbeb1dbb0, 0xab5c5918, 0x946554fd, 
                            0x8c2e680f, 0xeb3d799f, 0xb11ee0b7, 0x2d436b86, 
                            0xda672e2a, 0x1588ca88, 0xe369735d, 0x904f35f7, 
                            0xd7158fd6, 0x6fa6f051, 0x616e6b96, 0xac94efdc, 
                            0x36413f93, 0xc622c298, 0xf5a42ab8, 0x8a88d77b, 
                                        0xf5ad9d0e, 0x8999220b, 0x27fb47b9 };

/*
 * fptr and rptr are two pointers into the state info, a front and a rear
 * pointer.  These two pointers are always rand_sep places aparts, as they cycle
 * cyclically through the state information.  (Yes, this does mean we could get
 * away with just one pointer, but the code for random() is more efficient this
 * way).  The pointers are left positioned as they would be from the call
 *                      initstate( 1, randtbl, 128 )
 * (The position of the rear pointer, rptr, is really 0 (as explained above
 * in the initialization of randtbl) because the state table pointer is set
 * to point to randtbl[1] (as explained below).
 */

static  long            *fptr                   = &randtbl[ SEP_3 + 1 ];
static  long            *rptr                   = &randtbl[ 1 ];


/*
 * The following things are the pointer to the state information table,
 * the type of the current generator, the degree of the current polynomial
 * being used, and the separation between the two pointers.
 * Note that for efficiency of random(), we remember the first location of
 * the state information, not the zeroeth.  Hence it is valid to access
 * state[-1], which is used to store the type of the R.N.G.
 * Also, we remember the last location, since this is more efficient than
 * indexing every time to find the address of the last element to see if
 * the front and rear pointers have wrapped.
 */

static  long            *state                  = &randtbl[ 1 ];

static  int             rand_type               = TYPE_3;
static  int             rand_deg                = DEG_3;
static  int             rand_sep                = SEP_3;

static  long            *end_ptr                = &randtbl[ DEG_3 + 1 ];

// Sets the new seed for the next call of Rand(int dimension)
void
CMultDimRNDGen_ANSIC::SetSeed(unsigned long newSeed)
{
  register  int           i;

  if(  rand_type  ==  TYPE_0  )  {
    state[ 0 ] = (long) newSeed;
  }
  else  {
    state[ 0 ] = (long) newSeed;
    for( i = 1; i < rand_deg; i++ )  {
      state[i] = 1103515245*state[i - 1] + 12345;
    }
    fptr = &state[ rand_sep ];
    rptr = &state[ 0 ];
    for( i = 0; i < 10*rand_deg; i++ )
      Rand01d(0);
  }

  return;
}

// The dimension is ignored since we do not know where to start using
// standard ANSI C generator.
double
CMultDimRNDGen_ANSIC::Rand01d(int /*dimension*/)
{
  long            i;
  
  if(  rand_type  ==  TYPE_0  )  {
    i = state[0] = ( state[0]*1103515245 + 12345 )&0x7fffffff;
  }
  else  {
    *fptr += *rptr;
    i = (*fptr >> 1)&0x7fffffff;        /* chucking least random bit */
    if(  ++fptr  >=  end_ptr  )  {
      fptr = state;
      ++rptr;
    }
    else  {
      if(  ++rptr  >=  end_ptr  )  rptr = state;
    }
  }

  /* divided by 2^32 - it return value in range [0;1) */
  return (double)i * (1.0/4294967296.0); 
}

// ------------------------------------------------------------------------
// ------------------------------------------------------------------------
// CMultDimRNDGen_Halton - classical Halton generator (without scrambling)

int
CMultDimRNDGen_Halton::prime_numbers[CMultDimRNDGen_Halton::MAXDIM] = {
  2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97,101,
  103,107,109,113,127,131,137,139,149,151,157,163,167,173,179,181,191,193,197,
  199,211,223,227,229,233,239,241,251,257,263,269,271,277,281,283,293,307,311,
  313,317,331,337,347,349,353,359,367,373,379,383,389,397
};

CMultDimRNDGen_Halton::CMultDimRNDGen_Halton():
  CMultDimRNDGen(), _seed(0L), base(2)
{
}

double
CMultDimRNDGen_Halton::Rand01d(int dimension)
{
  assert(dimension < MAXDIM);
  base = prime_numbers[dimension];
  double f;
  double factor;
  f = factor = 1.0 / (double)base;

  double h = 0.0;

  // generating the value from the scratch (not incrementally)
  while (_seed > 0) {
    h += (double)(_seed % base) * factor;
    _seed /= base;
    factor *= f;
  }

  _seed++;
  
  return h;
}

__END_BRDFLIB_SOURCE
