TMrg32k3a.h

// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
//-----------------------------------------------------------------------------
// Copyright 2000-2025 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
// See the top-level COPYRIGHT file for details.
// SPDX-License-Identifier: Apache-2.0
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* Mrg32k3a.h                                                  (C) 2000-2025 */
/*                                                                           */
/* Ce fichier définit le patron de classe TMrg32k3a ainsi que la classe      */
/* associée Mrg32k3a.                                                        */ 
/*---------------------------------------------------------------------------*/
#ifndef ARCANE_CORE_RANDOM_MRG32K3A_H
#define ARCANE_CORE_RANDOM_MRG32K3A_H
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/utils/FatalErrorException.h"
 
#include "arcane/core/random/RandomGlobal.h"
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane::random
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

template<typename RealType, Int32 val>
class TMrg32k3a
{
 public:
  typedef RealType result_type;
  typedef RealType state_type;
  static const bool has_fixed_range = true;
  static const Int32 min_value=0;
  static const Int32 max_value=1;
  /*---------------------------------------------------------------------------*/
  /*---------------------------------------------------------------------------*/  
  explicit TMrg32k3a(Int32 x0 = 1)
  {
    seed(x0);
  }
  /*---------------------------------------------------------------------------*/
  /*---------------------------------------------------------------------------*/  
  explicit TMrg32k3a(state_type *state)
  {
    for(Integer  i=0;i<6;i++)
    _state[i] = state[i];
  }
  /*---------------------------------------------------------------------------*/
  /*---------------------------------------------------------------------------*/
  void seed(Int32 x0) { 
    x0 = (x0 | 1);
    _state[0] = (state_type) x0;
    _state[1] = _state[0];
    _state[2] = _state[1];
    _state[3] = _state[2];
    _state[4] = _state[3];
    _state[5] = _state[4]; 
}
  /*---------------------------------------------------------------------------*/
  /*---------------------------------------------------------------------------*/ 
  RealType  getState(Integer i) const { return _state[i]; }
 /*---------------------------------------------------------------------------*/
  /*---------------------------------------------------------------------------*/
  RealType operator()()
  {
    RealType _x;
    _x = apply(_state);
    return _x;
  }
 /*---------------------------------------------------------------------------*/
  /*---------------------------------------------------------------------------*/
  static RealType apply(state_type* state)
  {
    long k;
    Real p;
    p = 1403580.0*state[1] - 810728.0*state[0];
    k = static_cast<long>(p/4294967087.0); p-=k*4294967087.0; if (p <0.0) p+=4294967087.0;
    state[0] = state[1]; state[1]=state[2]; state[2]=p;
 
    p=527612.0*state[5] - 1370589.0*state[3];
    k=static_cast<long>(p/4294944443.0); p-= k*4294944443.0; if(p<0.0) p+=4294944443.0;
    state[3] = state[4]; state[4]=state[5]; state[5]=p;
 
    if(state[2] <= state[5]) return ((state[2]-state[5]+4294967087.0)/4294967087.0);
    else return ((state[2]-state[5]) / 4294967087.0);
  }
  /*---------------------------------------------------------------------------*/
  /*---------------------------------------------------------------------------*/
  result_type min() const  { return static_cast<result_type>(min_value); }
  /*---------------------------------------------------------------------------*/
  /*---------------------------------------------------------------------------*/
  result_type max() const { return static_cast<result_type>(max_value); }
  /*---------------------------------------------------------------------------*/
  /*---------------------------------------------------------------------------*/
  bool validation(RealType x) const { return val == x; }
  /*---------------------------------------------------------------------------*/
  /*---------------------------------------------------------------------------*/
  bool operator==(const TMrg32k3a& rhs) const
  { return (_state[0]  == rhs._state[0]) && (_state[1] == rhs._state[1]) &&  (_state[2] == rhs._state[2])  &&  (_state[3] == rhs._state[3]) &&  (_state[4] == rhs._state[4]) &&  (_state[5] == rhs._state[5]) ; }
 
 private:
 
  state_type _state[6];
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
typedef TMrg32k3a<Real,0> Mrg32k3a;
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif