TMrg32k3a.h

// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
//-----------------------------------------------------------------------------
// Copyright 2000-2026 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 */
/*                                                                           */
/* This file defines the class template TMrg32k3a as well as the associated  */
/* class 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;
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // namespace Arcane::random
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif