TKiss.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
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* TKiss.h                                                     (C) 2000-2025 */
/*                                                                           */
/* This file defines the TKiss class template and the associated class Kiss. */
/*---------------------------------------------------------------------------*/
#ifndef ARCANE_CORE_RANDOM_TKISS_H
#define ARCANE_CORE_RANDOM_TKISS_H
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/utils/FatalErrorException.h"
 
#include "arcane/core/random/RandomGlobal.h"
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane::random
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

template <typename UIntType, UIntType val>
class TKiss
{
 public:
 
  typedef UIntType result_type;
  typedef UIntType state_type;
  static const bool has_fixed_range = true;
  static const result_type min_value = 0;
  static const result_type max_value = 4294967295U;
 
  /*---------------------------------------------------------------------------*/
  /*---------------------------------------------------------------------------*/

  result_type min() const { return min_value; }
 
  /*---------------------------------------------------------------------------*/
  /*---------------------------------------------------------------------------*/

  result_type max() const { return max_value; }
 
  /*---------------------------------------------------------------------------*/
  /*---------------------------------------------------------------------------*/

  explicit TKiss(UIntType x0 = 30903, UIntType y0 = 30903, UIntType z0 = 30903, UIntType w0 = 30903, UIntType carry0 = 0)
  {
    _state[0] = x0;
    _state[1] = y0;
    _state[2] = z0;
    _state[3] = w0;
    _state[4] = carry0;
  }
 
  /*---------------------------------------------------------------------------*/
  /*---------------------------------------------------------------------------*/

  void seed(UIntType* state)
  {
    for (Integer i = 0; i < 5; i++)
      _state[i] = state[i];
  }
 
  /*---------------------------------------------------------------------------*/
  /*---------------------------------------------------------------------------*/

  void seed(UIntType x0)
  {
    for (Integer i = 0; i < 4; i++)
      _state[i] = x0;
    _state[4] = 0;
  }
 
  /*---------------------------------------------------------------------------*/
  /*---------------------------------------------------------------------------*/

  void seed(UIntType x0, UIntType y0, UIntType z0, UIntType w0, UIntType carry0)
  {
    _state[0] = x0;
    _state[1] = y0;
    _state[2] = z0;
    _state[3] = w0;
    _state[4] = carry0;
  }
 
  /*---------------------------------------------------------------------------*/
  /*---------------------------------------------------------------------------*/

  UIntType getState(Integer i) const { return _state[i]; }
 
  /*---------------------------------------------------------------------------*/
  /*---------------------------------------------------------------------------*/

  UIntType operator()()
  {
    UIntType t;
    _state[0] = _state[0] * 69069 + 1;
    _state[1] ^= _state[1] << 13;
    _state[1] ^= _state[1] >> 17;
    _state[1] ^= _state[1] << 5;
 
    t = (_state[3] << 1) + _state[2] + _state[4];
    _state[4] = ((_state[2] >> 2) + (_state[3] >> 3) + (_state[4] >> 2)) >> 30;
    _state[2] = _state[3];
    _state[3] = t;
    return (_state[0] + _state[1] + _state[2]);
  }
 
  /*---------------------------------------------------------------------------*/
  /*---------------------------------------------------------------------------*/

  bool validation(UIntType x) const { return val == x; }
 
  /*---------------------------------------------------------------------------*/
  /*---------------------------------------------------------------------------*/

  bool operator==(const TKiss& 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]);
  }
 
 private:
 
  state_type _state[5];
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
typedef TKiss<UInt32, 0> Kiss;
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // namespace Arcane::random
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif