InversiveCongruential.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
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* InversiveCongruential.h                                     (C) 2000-2025 */
/*                                                                           */
/* Ce fichier définit le patron de classe InversiveCongruential ainsi qu'une */
/* classe associée Hellekalek1995.  Il est une version adaptée du fichier    */
/* InversiveCongruential.hpp provenant de la bibliothèque BOOST              */
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
#ifndef ARCANE_CORE_RANDOM_INVERSIVECONGRUENTIAL_H
#define ARCANE_CORE_RANDOM_INVERSIVECONGRUENTIAL_H
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/utils/FatalErrorException.h"
 
#include "arcane/core/random/RandomGlobal.h"
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane::random
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template<typename IntType, IntType a, IntType c, IntType m, IntType val>
class InversiveCongruential
{
 public:
  typedef IntType result_type;
  static const bool has_fixed_range = true;
  static const result_type min_value = ( c == 0 ? 1 : 0 );
  static const result_type max_value = m-1;
  /*---------------------------------------------------------------------------*/
  /*---------------------------------------------------------------------------*/
  result_type min() const { return c == 0 ? 1 : 0; }
  /*---------------------------------------------------------------------------*/
  /*---------------------------------------------------------------------------*/
  result_type max() const { return m-1; }
  /*---------------------------------------------------------------------------*/
  /*---------------------------------------------------------------------------*/  
  explicit InversiveCongruential(IntType x0 = 1)
    : _x(x0)
  { 
  }
  /*---------------------------------------------------------------------------*/
  /*---------------------------------------------------------------------------*/
  void seed(IntType x0) { _x = x0; }
  /*---------------------------------------------------------------------------*/
  /*---------------------------------------------------------------------------*/
  IntType getState() const { return _x; }
  /*---------------------------------------------------------------------------*/
  /*---------------------------------------------------------------------------*/
  IntType operator()()
  {
    _x = apply(_x);
    return _x;
  }
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
  static IntType apply(IntType x)
  {
    typedef utils::const_mod<IntType, m> do_mod;
    return x = do_mod::mult_add(a,do_mod::invert(x), c);
  }
  /*---------------------------------------------------------------------------*/
  /*---------------------------------------------------------------------------*/
  bool validation(IntType x) const { return val == x; }
  /*---------------------------------------------------------------------------*/
  /*---------------------------------------------------------------------------*/
  bool operator==(const InversiveCongruential& rhs) const
    { return _x == rhs._x; }
 
 private:
 
  IntType _x;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
typedef InversiveCongruential<Int32, 9102, 2147483647-36884165,
  2147483647, 0> Hellekalek1995;
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif