cuda-cccl 0.1.3.1.0.dev1486__cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl

cuda/cccl/headers/include/thrust/random/detail/subtract_with_carry_engine.inl

@@ -0,0 +1,201 @@
+/*
+ *  Copyright 2008-2021 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <thrust/random/detail/mod.h>
+#include <thrust/random/detail/random_core_access.h>
+#include <thrust/random/linear_congruential_engine.h>
+#include <thrust/random/subtract_with_carry_engine.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace random
+{
+
+template <typename UIntType, size_t w, size_t s, size_t r>
+_CCCL_HOST_DEVICE subtract_with_carry_engine<UIntType, w, s, r>::subtract_with_carry_engine(result_type value)
+{
+  seed(value);
+} // end subtract_with_carry_engine::subtract_with_carry_engine()
+
+template <typename UIntType, size_t w, size_t s, size_t r>
+_CCCL_HOST_DEVICE void subtract_with_carry_engine<UIntType, w, s, r>::seed(result_type value)
+{
+  thrust::random::linear_congruential_engine<result_type, 40014u, 0u, 2147483563u> e(
+    value == 0u ? default_seed : value);
+
+  // initialize state
+  for (size_t i = 0; i < long_lag; ++i)
+  {
+    m_x[i] = detail::mod<UIntType, 1, 0, modulus>(e());
+  } // end for i
+
+  m_carry = (m_x[long_lag - 1] == 0);
+  m_k     = 0;
+} // end subtract_with_carry_engine::seed()
+
+template <typename UIntType, size_t w, size_t s, size_t r>
+_CCCL_HOST_DEVICE typename subtract_with_carry_engine<UIntType, w, s, r>::result_type
+subtract_with_carry_engine<UIntType, w, s, r>::operator()(void)
+{
+  // XXX we probably need to cache these m_x[m_k] in a register
+  //     maybe we need to cache the use of all member variables
+  int short_index = m_k - short_lag;
+  if (short_index < 0)
+  {
+    short_index += long_lag;
+  }
+  result_type xi;
+  if (m_x[short_index] >= m_x[m_k] + m_carry)
+  {
+    // x(n) >= 0
+    xi      = m_x[short_index] - m_x[m_k] - m_carry;
+    m_carry = 0;
+  }
+  else
+  {
+    // x(n) < 0
+    xi      = modulus - m_x[m_k] - m_carry + m_x[short_index];
+    m_carry = 1;
+  }
+  m_x[m_k] = xi;
+  ++m_k;
+  if (m_k >= long_lag)
+  {
+    m_k = 0;
+  }
+  return xi;
+} // end subtract_with_carry_engine::operator()()
+
+template <typename UIntType, size_t w, size_t s, size_t r>
+_CCCL_HOST_DEVICE void subtract_with_carry_engine<UIntType, w, s, r>::discard(unsigned long long z)
+{
+  for (; z > 0; --z)
+  {
+    this->operator()();
+  } // end for
+} // end subtract_with_carry_engine::discard()
+
+template <typename UIntType, size_t w, size_t s, size_t r>
+template <typename CharT, typename Traits>
+std::basic_ostream<CharT, Traits>&
+subtract_with_carry_engine<UIntType, w, s, r>::stream_out(std::basic_ostream<CharT, Traits>& os) const
+{
+  using ostream_type = std::basic_ostream<CharT, Traits>;
+  using ios_base     = typename ostream_type::ios_base;
+
+  const typename ios_base::fmtflags flags = os.flags();
+  const CharT fill                        = os.fill();
+  const CharT space                       = os.widen(' ');
+  os.flags(ios_base::dec | ios_base::fixed | ios_base::left);
+  os.fill(space);
+
+  const UIntType long_lag_ = r;
+
+  for (size_t i = 0; i < r; ++i)
+  {
+    os << m_x[(i + m_k) % long_lag_] << space;
+  }
+  os << m_carry;
+
+  os.flags(flags);
+  os.fill(fill);
+  return os;
+}
+
+template <typename UIntType, size_t w, size_t s, size_t r>
+template <typename CharType, typename Traits>
+std::basic_istream<CharType, Traits>&
+subtract_with_carry_engine<UIntType, w, s, r>::stream_in(std::basic_istream<CharType, Traits>& is)
+{
+  using istream_type = std::basic_istream<CharType, Traits>;
+  using ios_base     = typename istream_type::ios_base;
+
+  const typename ios_base::fmtflags flags = is.flags();
+  is.flags(ios_base::dec | ios_base::skipws);
+
+  for (size_t i = 0; i < r; ++i)
+  {
+    is >> m_x[i];
+  }
+  is >> m_carry;
+
+  m_k = 0;
+
+  is.flags(flags);
+  return is;
+}
+
+template <typename UIntType, size_t w, size_t s, size_t r>
+_CCCL_HOST_DEVICE bool
+subtract_with_carry_engine<UIntType, w, s, r>::equal(const subtract_with_carry_engine<UIntType, w, s, r>& rhs) const
+{
+  const UIntType long_lag_ = r;
+
+  bool result = true;
+  for (size_t i = 0; i < r; ++i)
+  {
+    result &= (m_x[(i + m_k) % long_lag_] == rhs.m_x[(i + rhs.m_k) % long_lag_]);
+  }
+
+  // XXX not sure if this last check is necessary
+  result &= (m_carry == rhs.m_carry);
+
+  return result;
+}
+
+template <typename UIntType, size_t w, size_t s, size_t r, typename CharT, typename Traits>
+std::basic_ostream<CharT, Traits>&
+operator<<(std::basic_ostream<CharT, Traits>& os, const subtract_with_carry_engine<UIntType, w, s, r>& e)
+{
+  return thrust::random::detail::random_core_access::stream_out(os, e);
+}
+
+template <typename UIntType, size_t w, size_t s, size_t r, typename CharType, typename Traits>
+std::basic_istream<CharType, Traits>&
+operator>>(std::basic_istream<CharType, Traits>& is, subtract_with_carry_engine<UIntType, w, s, r>& e)
+{
+  return thrust::random::detail::random_core_access::stream_in(is, e);
+}
+
+template <typename UIntType, size_t w, size_t s, size_t r>
+_CCCL_HOST_DEVICE bool operator==(const subtract_with_carry_engine<UIntType, w, s, r>& lhs,
+                                  const subtract_with_carry_engine<UIntType, w, s, r>& rhs)
+{
+  return thrust::random::detail::random_core_access::equal(lhs, rhs);
+}
+
+template <typename UIntType, size_t w, size_t s, size_t r>
+_CCCL_HOST_DEVICE bool operator!=(const subtract_with_carry_engine<UIntType, w, s, r>& lhs,
+                                  const subtract_with_carry_engine<UIntType, w, s, r>& rhs)
+{
+  return !(lhs == rhs);
+}
+
+} // namespace random
+
+THRUST_NAMESPACE_END

cuda/cccl/headers/include/thrust/random/detail/uniform_int_distribution.inl

@@ -0,0 +1,198 @@
+/*
+ *  Copyright 2008-2021 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <thrust/detail/type_traits.h>
+#include <thrust/random/uniform_int_distribution.h>
+#include <thrust/random/uniform_real_distribution.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace random
+{
+
+template <typename IntType>
+_CCCL_HOST_DEVICE uniform_int_distribution<IntType>::uniform_int_distribution(IntType a, IntType b)
+    : m_param(a, b)
+{} // end uniform_int_distribution::uniform_int_distribution()
+
+template <typename IntType>
+_CCCL_HOST_DEVICE uniform_int_distribution<IntType>::uniform_int_distribution(const param_type& parm)
+    : m_param(parm)
+{} // end uniform_int_distribution::uniform_int_distribution()
+
+template <typename IntType>
+_CCCL_HOST_DEVICE void uniform_int_distribution<IntType>::reset()
+{} // end uniform_int_distribution::reset()
+
+template <typename IntType>
+template <typename UniformRandomNumberGenerator>
+_CCCL_HOST_DEVICE typename uniform_int_distribution<IntType>::result_type
+uniform_int_distribution<IntType>::operator()(UniformRandomNumberGenerator& urng)
+{
+  return operator()(urng, m_param);
+} // end uniform_int_distribution::operator()()
+
+template <typename IntType>
+template <typename UniformRandomNumberGenerator>
+_CCCL_HOST_DEVICE typename uniform_int_distribution<IntType>::result_type
+uniform_int_distribution<IntType>::operator()(UniformRandomNumberGenerator& urng, const param_type& parm)
+{
+  // XXX this implementation is somewhat hacky and will skip
+  //     values if the range of the RNG is smaller than the range of the distribution
+  //     we should improve this implementation in a later version
+
+  using float_type = typename thrust::detail::largest_available_float::type;
+
+  const float_type real_min(static_cast<float_type>(parm.first));
+  const float_type real_max(static_cast<float_type>(parm.second));
+
+  // add one to the right end of the interval because it is half-open
+  // XXX adding 1.0 to a potentially large floating point number seems like a bad idea
+  uniform_real_distribution<float_type> real_dist(real_min, real_max + float_type(1));
+
+  return static_cast<result_type>(real_dist(urng));
+} // end uniform_int_distribution::operator()()
+
+template <typename IntType>
+_CCCL_HOST_DEVICE typename uniform_int_distribution<IntType>::result_type uniform_int_distribution<IntType>::a() const
+{
+  return m_param.first;
+} // end uniform_int_distribution<IntType>::a()
+
+template <typename IntType>
+_CCCL_HOST_DEVICE typename uniform_int_distribution<IntType>::result_type uniform_int_distribution<IntType>::b() const
+{
+  return m_param.second;
+} // end uniform_int_distribution::b()
+
+template <typename IntType>
+_CCCL_HOST_DEVICE typename uniform_int_distribution<IntType>::param_type uniform_int_distribution<IntType>::param() const
+{
+  return m_param;
+} // end uniform_int_distribution::param()
+
+template <typename IntType>
+_CCCL_HOST_DEVICE void uniform_int_distribution<IntType>::param(const param_type& parm)
+{
+  m_param = parm;
+} // end uniform_int_distribution::param()
+
+template <typename IntType>
+_CCCL_HOST_DEVICE typename uniform_int_distribution<IntType>::result_type uniform_int_distribution<IntType>::min
+THRUST_PREVENT_MACRO_SUBSTITUTION() const
+{
+  return a();
+} // end uniform_int_distribution::min()
+
+template <typename IntType>
+_CCCL_HOST_DEVICE typename uniform_int_distribution<IntType>::result_type uniform_int_distribution<IntType>::max
+THRUST_PREVENT_MACRO_SUBSTITUTION() const
+{
+  return b();
+} // end uniform_int_distribution::max()
+
+template <typename IntType>
+_CCCL_HOST_DEVICE bool uniform_int_distribution<IntType>::equal(const uniform_int_distribution& rhs) const
+{
+  return param() == rhs.param();
+}
+
+template <typename IntType>
+template <typename CharT, typename Traits>
+std::basic_ostream<CharT, Traits>&
+uniform_int_distribution<IntType>::stream_out(std::basic_ostream<CharT, Traits>& os) const
+{
+  using ostream_type = std::basic_ostream<CharT, Traits>;
+  using ios_base     = typename ostream_type::ios_base;
+
+  // save old flags and fill character
+  const typename ios_base::fmtflags flags = os.flags();
+  const CharT fill                        = os.fill();
+
+  const CharT space = os.widen(' ');
+  os.flags(ios_base::dec | ios_base::fixed | ios_base::left);
+  os.fill(space);
+
+  os << a() << space << b();
+
+  // restore old flags and fill character
+  os.flags(flags);
+  os.fill(fill);
+  return os;
+}
+
+template <typename IntType>
+template <typename CharT, typename Traits>
+std::basic_istream<CharT, Traits>& uniform_int_distribution<IntType>::stream_in(std::basic_istream<CharT, Traits>& is)
+{
+  using istream_type = std::basic_istream<CharT, Traits>;
+  using ios_base     = typename istream_type::ios_base;
+
+  // save old flags
+  const typename ios_base::fmtflags flags = is.flags();
+
+  is.flags(ios_base::skipws);
+
+  is >> m_param.first >> m_param.second;
+
+  // restore old flags
+  is.flags(flags);
+  return is;
+}
+
+template <typename IntType>
+_CCCL_HOST_DEVICE bool
+operator==(const uniform_int_distribution<IntType>& lhs, const uniform_int_distribution<IntType>& rhs)
+{
+  return thrust::random::detail::random_core_access::equal(lhs, rhs);
+}
+
+template <typename IntType>
+_CCCL_HOST_DEVICE bool
+operator!=(const uniform_int_distribution<IntType>& lhs, const uniform_int_distribution<IntType>& rhs)
+{
+  return !(lhs == rhs);
+}
+
+template <typename IntType, typename CharT, typename Traits>
+std::basic_ostream<CharT, Traits>&
+operator<<(std::basic_ostream<CharT, Traits>& os, const uniform_int_distribution<IntType>& d)
+{
+  return thrust::random::detail::random_core_access::stream_out(os, d);
+}
+
+template <typename IntType, typename CharT, typename Traits>
+std::basic_istream<CharT, Traits>&
+operator>>(std::basic_istream<CharT, Traits>& is, uniform_int_distribution<IntType>& d)
+{
+  return thrust::random::detail::random_core_access::stream_in(is, d);
+}
+
+} // namespace random
+
+THRUST_NAMESPACE_END

cuda/cccl/headers/include/thrust/random/detail/uniform_real_distribution.inl

@@ -0,0 +1,198 @@
+/*
+ *  Copyright 2008-2021 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <thrust/random/uniform_real_distribution.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace random
+{
+
+template <typename RealType>
+_CCCL_HOST_DEVICE uniform_real_distribution<RealType>::uniform_real_distribution(RealType a, RealType b)
+    : m_param(a, b)
+{} // end uniform_real_distribution::uniform_real_distribution()
+
+template <typename RealType>
+_CCCL_HOST_DEVICE uniform_real_distribution<RealType>::uniform_real_distribution(const param_type& parm)
+    : m_param(parm)
+{} // end uniform_real_distribution::uniform_real_distribution()
+
+template <typename RealType>
+_CCCL_HOST_DEVICE void uniform_real_distribution<RealType>::reset()
+{} // end uniform_real_distribution::reset()
+
+template <typename RealType>
+template <typename UniformRandomNumberGenerator>
+_CCCL_HOST_DEVICE typename uniform_real_distribution<RealType>::result_type
+uniform_real_distribution<RealType>::operator()(UniformRandomNumberGenerator& urng)
+{
+  return operator()(urng, m_param);
+} // end uniform_real::operator()()
+
+template <typename RealType>
+template <typename UniformRandomNumberGenerator>
+_CCCL_HOST_DEVICE typename uniform_real_distribution<RealType>::result_type
+uniform_real_distribution<RealType>::operator()(UniformRandomNumberGenerator& urng, const param_type& parm)
+{
+  // call the urng & map its result to [0,1)
+  result_type result = static_cast<result_type>(urng() - UniformRandomNumberGenerator::min);
+
+  // adding one to the denominator ensures that the interval is half-open at 1.0
+  // XXX adding 1.0 to a potentially large floating point number seems like a bad idea
+  // XXX OTOH adding 1 to what is potentially UINT_MAX also seems like a bad idea
+  // XXX we could statically check if 1u + (max - min) is representable and do that, otherwise use the current
+  // implementation
+  result /=
+    (result_type(1) + static_cast<result_type>(UniformRandomNumberGenerator::max - UniformRandomNumberGenerator::min));
+
+  return (result * (parm.second - parm.first)) + parm.first;
+} // end uniform_real::operator()()
+
+template <typename RealType>
+_CCCL_HOST_DEVICE typename uniform_real_distribution<RealType>::result_type
+uniform_real_distribution<RealType>::a() const
+{
+  return m_param.first;
+} // end uniform_real::a()
+
+template <typename RealType>
+_CCCL_HOST_DEVICE typename uniform_real_distribution<RealType>::result_type
+uniform_real_distribution<RealType>::b() const
+{
+  return m_param.second;
+} // end uniform_real_distribution::b()
+
+template <typename RealType>
+_CCCL_HOST_DEVICE typename uniform_real_distribution<RealType>::param_type
+uniform_real_distribution<RealType>::param() const
+{
+  return m_param;
+  ;
+} // end uniform_real_distribution::param()
+
+template <typename RealType>
+_CCCL_HOST_DEVICE void uniform_real_distribution<RealType>::param(const param_type& parm)
+{
+  m_param = parm;
+} // end uniform_real_distribution::param()
+
+template <typename RealType>
+_CCCL_HOST_DEVICE typename uniform_real_distribution<RealType>::result_type uniform_real_distribution<RealType>::min
+THRUST_PREVENT_MACRO_SUBSTITUTION() const
+{
+  return a();
+} // end uniform_real_distribution::min()
+
+template <typename RealType>
+_CCCL_HOST_DEVICE typename uniform_real_distribution<RealType>::result_type uniform_real_distribution<RealType>::max
+THRUST_PREVENT_MACRO_SUBSTITUTION() const
+{
+  return b();
+} // end uniform_real_distribution::max()
+
+template <typename RealType>
+_CCCL_HOST_DEVICE bool uniform_real_distribution<RealType>::equal(const uniform_real_distribution& rhs) const
+{
+  return m_param == rhs.param();
+}
+
+template <typename RealType>
+template <typename CharT, typename Traits>
+std::basic_ostream<CharT, Traits>&
+uniform_real_distribution<RealType>::stream_out(std::basic_ostream<CharT, Traits>& os) const
+{
+  using ostream_type = std::basic_ostream<CharT, Traits>;
+  using ios_base     = typename ostream_type::ios_base;
+
+  // save old flags and fill character
+  const typename ios_base::fmtflags flags = os.flags();
+  const CharT fill                        = os.fill();
+
+  const CharT space = os.widen(' ');
+  os.flags(ios_base::dec | ios_base::fixed | ios_base::left);
+  os.fill(space);
+
+  os << a() << space << b();
+
+  // restore old flags and fill character
+  os.flags(flags);
+  os.fill(fill);
+  return os;
+}
+
+template <typename RealType>
+template <typename CharT, typename Traits>
+std::basic_istream<CharT, Traits>& uniform_real_distribution<RealType>::stream_in(std::basic_istream<CharT, Traits>& is)
+{
+  using istream_type = std::basic_istream<CharT, Traits>;
+  using ios_base     = typename istream_type::ios_base;
+
+  // save old flags
+  const typename ios_base::fmtflags flags = is.flags();
+
+  is.flags(ios_base::skipws);
+
+  is >> m_param.first >> m_param.second;
+
+  // restore old flags
+  is.flags(flags);
+  return is;
+}
+
+template <typename RealType>
+_CCCL_HOST_DEVICE bool
+operator==(const uniform_real_distribution<RealType>& lhs, const uniform_real_distribution<RealType>& rhs)
+{
+  return thrust::random::detail::random_core_access::equal(lhs, rhs);
+}
+
+template <typename RealType>
+_CCCL_HOST_DEVICE bool
+operator!=(const uniform_real_distribution<RealType>& lhs, const uniform_real_distribution<RealType>& rhs)
+{
+  return !(lhs == rhs);
+}
+
+template <typename RealType, typename CharT, typename Traits>
+std::basic_ostream<CharT, Traits>&
+operator<<(std::basic_ostream<CharT, Traits>& os, const uniform_real_distribution<RealType>& d)
+{
+  return thrust::random::detail::random_core_access::stream_out(os, d);
+}
+
+template <typename RealType, typename CharT, typename Traits>
+std::basic_istream<CharT, Traits>&
+operator>>(std::basic_istream<CharT, Traits>& is, uniform_real_distribution<RealType>& d)
+{
+  return thrust::random::detail::random_core_access::stream_in(is, d);
+}
+
+} // namespace random
+
+THRUST_NAMESPACE_END