InversiveCongruential.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
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* InversiveCongruential.h                                     (C) 2000-2025 */
/*                                                                           */
/* This file defines the InversiveCongruential class pattern as well as a    */
/* associated class Hellekalek1995. It is an adapted version of the file     */
/* InversiveCongruential.hpp from the BOOST library */
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
#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;
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // namespace Arcane::random
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif