dolfin team mailing list archive

[Anders Logg <logg@xxxxxxxxx>]

This should be fixed now. srand48() and drand48() are no longer used.

/Anders


On Sun, Dec 11, 2005 at 08:51:15PM -0500, tomtzigt wrote:
>    Kernel/math is calling methods srand48 and drand48 which are not available
>    under Windows. I did a search for a possible Windows replacement and found
>    this reference: (didn't look for the source yet though)
> 
>    1                CLHEP/Random/DRand48Engine.h
> 
>    // $Id: DRand48Engine.h,v 1.12 2000/04/17 22:59:31 mf Exp $
> 
>    // -*- C++ -*-
> 
>    //
> 
>    // -----------------------------------------------------------------------
> 
>    //                             HEP Random
> 
>    //                        --- DRand48Engine ---
> 
>    //                          class header file
> 
>    // -----------------------------------------------------------------------
> 
>    // This file is part of Geant4 (simulation toolkit for HEP).
> 
>    //
> 
>    // Random engine using drand48() and srand48() functions from C standard
> 
>    // library to implement the flat() basic distribution and for setting
> 
>    // seeds.
> 
>    // For Windows/NT platforms (WIN32), the code for drand48 has been
> 
>    // extracted from the GNU C Library 2.0.1 and adapted for the native
> 
>    // types.
> 
>    // Copy constructor and operator= are private for objects of this class.
> 
> 
> 
>    // =======================================================================
> 
>    // G.Cosmo        - Created: 5th September 1995
> 
>    //                - Minor corrections: 31st October 1996
> 
>    //                - Added methods for engine status: 19th November 1996
> 
>    //                - Added srand48(), seed48(), drand48() implementations
> 
>    //                  for Windows/NT: 6th March 1997
> 
>    //                - setSeed(), setSeeds() now have default dummy argument
> 
>    //                  set to zero: 11th July 1997
> 
>    // E.Tcherniaev   - Porting on KCC compiler: 2nd Feb 1998
> 
>    // G.Cosmo        - Private copy constructor and operator=: 26th Feb 1998
> 
>    // J.Marraffino   - Added stream operators and related constructor.
> 
>    //                  Added automatic seed selection from seed table and
> 
>    //                  engine counter: 16th Feb 1998
> 
>    // =======================================================================
> 
> 
> 
>    #ifndef  DRand48Engine_h
> 
>    #define  DRand48Engine_h 1
> 
> 
> 
>    #include  "CLHEP/Random/RandomEngine.h"
> 
> 
> 
>    #if  defined(__KCC)
> 
> 
> 
>    // Those function are available on all unix platform but their
> 
>    // prototypes are not included in stdlib when KCC strict flag is
> 
>    // set
> 
> 
> 
>    extern  "C" {
> 
>      extern  double drand48(void);
> 
>      extern  void  srand48(long);
> 
>      extern  unsigned  short * seed48(unsigned  short  int [3]);
> 
>    }
> 
> 
> 
>    #endif  /* KCC */
> 
> 
> 
>    #ifdef  WIN32
> 
>       // ********************************************************************
> 
>       // Code extracted from GNU C Library 2.0.1
> 
> 
> 
>       /* Data structure for communication with thread safe versions.  */
> 
>       struct drand48_data
> 
>         {
> 
>           unsigned  short  int X[3];     /* Current state.  */
> 
>           unsigned  short  int a[3];     /* Factor in congruential formula.
>    */
> 
>           unsigned  short  int c;        /* Additive const. in congruential
>    formula.  */
> 
>           unsigned  short  int old_X[3]; /* Old state.  */
> 
>           int init;                                /* Flag for initializing.
>    */
> 
>         };
> 
> 
> 
>       /* Internal function to compute next state of the generator.  */
> 
>       extern  "C" { int drand48_iterate (unsigned  short  int xsubi[3],
> 
>                                                            struct
>    drand48_data *buffer); }
> 
> 
> 
>       /* Return non-negative, double-precision floating-point value in
>    [0.0,1.0).  */
> 
>       extern  "C" { int drand48_r (struct drand48_data *buffer, double
>    *result); }
> 
>       extern  "C" { int erand48_r (unsigned  short  int xsubi[3],
> 
>                                                struct drand48_data *buffer,
>    double *result); }
> 
> 
> 
>       /* Seed random number generator.  */
> 
>       extern  "C" { int srand48_r (long seedval, struct drand48_data
>    *buffer); }
> 
>       extern  "C" { int seed48_r  (unsigned  short  int seed16v[3],
> 
>                                                struct drand48_data *buffer);
>    }
> 
> 
> 
>       /* Return non-negative, double-precision floating-point value in
>    [0.0,1.0).  */
> 
>       extern  "C" { double drand48 (void); }
> 
>       extern  "C" { double erand48 (unsigned  short  int xsubi[3]); }
> 
> 
> 
>       /* Seed random number generator.  */
> 
>       extern  "C" { void srand48 (long seedval); }
> 
>       extern  "C" { unsigned  short  int *seed48 (unsigned  short  int
>    seed16v[3]);     }
> 
> 
> 
>       // End Code extracted from GNU C Library 2.0.1
> 
>       // ********************************************************************
> 
>    #endif  /* WIN32 */
> 
> 
> 
>    class DRand48Engine : public HepRandomEngine {
> 
> 
> 
>    public:
> 
> 
> 
>      DRand48Engine(HepStd::istream& is);
> 
>      DRand48Engine();
> 
>      DRand48Engine(long seed);
> 
>      DRand48Engine(HepInt rowIndex, HepInt colIndex);
> 
>      virtual ~DRand48Engine();
> 
>      // Constructors and destructor
> 
> 
> 
>      HepDouble flat();
> 
>      // It returns a pseudo random number between 0 and 1,
> 
>      // according to the standard stdlib random function drand48()
> 
>      // but excluding the end points.
> 
> 
> 
>      void flatArray (const HepInt size, HepDouble* vect);
> 
>      // Fills the array "vect" of specified size with flat random values.
> 
> 
> 
>      void setSeed(long seed, HepInt dum=0);
> 
>      // Sets the state of the algorithm according to seed.
> 
> 
> 
>      void setSeeds(const  long * seeds, HepInt dum=0);
> 
>      // Sets the state of the algorithm according to the zero terminated
> 
>      // array of seeds. Only the first seed is used.
> 
> 
> 
>      void saveStatus( const  char filename[] = "DRand48.conf" ) const;
> 
>      // Saves on file DRand48.conf the current engine status.
> 
> 
> 
>      void restoreStatus( const  char filename[] = "DRand48.conf" );
> 
>      // Reads from file DRand48.conf the last saved engine status
> 
>      // and restores it.
> 
> 
> 
>      void showStatus() const;
> 
>      // Dumps the engine status on the screen.
> 
> 
> 
>      friend HepStd::ostream& operator<< (HepStd::ostream& os, const
>    DRand48Engine& e);
> 
>      friend HepStd::istream& operator>> (HepStd::istream& is,
>    DRand48Engine& e);
> 
> 
> 
>    private:
> 
> 
> 
>      static HepInt  numEngines;
> 
>      static HepInt  maxIndex;
> 
> 
> 
>      DRand48Engine(const DRand48Engine &p);
> 
>      DRand48Engine & operator = (const DRand48Engine &p);
> 
>      // Private copy constructor and assignment operator.
> 
> 
> 
>    };
> 
> 
> 
>    #endif
> 
> 

> _______________________________________________
> DOLFIN-dev mailing list
> DOLFIN-dev@xxxxxxxxxx
> http://www.fenics.org/cgi-bin/mailman/listinfo/dolfin-dev


-- 
Anders Logg
Research Assistant Professor
Toyota Technological Institute at Chicago
http://www.tti-c.org/logg/