Add files using upload-large-folder tool

.gitattributes

@@ -1130,3 +1130,7 @@ infer_4_37_2/lib/python3.10/site-packages/nvidia/cusolver/lib/libcusolver.so.11
 infer_4_37_2/lib/python3.10/site-packages/nvidia/cublas/lib/libcublas.so.12 filter=lfs diff=lfs merge=lfs -text
 infer_4_37_2/lib/python3.10/site-packages/httptools/parser/parser.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
 infer_4_37_2/lib/python3.10/site-packages/httptools/parser/url_parser.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+infer_4_37_2/lib/python3.10/site-packages/pandas/_libs/arrays.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+infer_4_37_2/lib/python3.10/site-packages/pandas/_libs/parsers.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+infer_4_37_2/lib/python3.10/site-packages/nvidia/curand/lib/libcurand.so.10 filter=lfs diff=lfs merge=lfs -text
+infer_4_37_2/lib/python3.10/site-packages/pandas/_libs/algos.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text

infer_4_37_2/lib/python3.10/site-packages/httptools/__init__.py

@@ -0,0 +1,6 @@
+from . import parser
+from .parser import *  # NOQA
+
+from ._version import __version__  # NOQA
+
+__all__ = parser.__all__ + ('__version__',)  # NOQA

infer_4_37_2/lib/python3.10/site-packages/nvidia/curand/include/curand_discrete2.h

@@ -0,0 +1,253 @@
+
+ /* Copyright 2010-2014 NVIDIA Corporation.  All rights reserved.
+  *
+  * NOTICE TO LICENSEE:
+  *
+  * The source code and/or documentation ("Licensed Deliverables") are
+  * subject to NVIDIA intellectual property rights under U.S. and
+  * international Copyright laws.
+  *
+  * The Licensed Deliverables contained herein are PROPRIETARY and
+  * CONFIDENTIAL to NVIDIA and are being provided under the terms and
+  * conditions of a form of NVIDIA software license agreement by and
+  * between NVIDIA and Licensee ("License Agreement") or electronically
+  * accepted by Licensee.  Notwithstanding any terms or conditions to
+  * the contrary in the License Agreement, reproduction or disclosure
+  * of the Licensed Deliverables to any third party without the express
+  * written consent of NVIDIA is prohibited.
+  *
+  * NOTWITHSTANDING ANY TERMS OR CONDITIONS TO THE CONTRARY IN THE
+  * LICENSE AGREEMENT, NVIDIA MAKES NO REPRESENTATION ABOUT THE
+  * SUITABILITY OF THESE LICENSED DELIVERABLES FOR ANY PURPOSE.  THEY ARE
+  * PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY OF ANY KIND.
+  * NVIDIA DISCLAIMS ALL WARRANTIES WITH REGARD TO THESE LICENSED
+  * DELIVERABLES, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY,
+  * NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE.
+  * NOTWITHSTANDING ANY TERMS OR CONDITIONS TO THE CONTRARY IN THE
+  * LICENSE AGREEMENT, IN NO EVENT SHALL NVIDIA BE LIABLE FOR ANY
+  * SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, OR ANY
+  * DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+  * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
+  * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
+  * OF THESE LICENSED DELIVERABLES.
+  *
+  * U.S. Government End Users.  These Licensed Deliverables are a
+  * "commercial item" as that term is defined at 48 C.F.R. 2.101 (OCT
+  * 1995), consisting of "commercial computer software" and "commercial
+  * computer software documentation" as such terms are used in 48
+  * C.F.R. 12.212 (SEPT 1995) and are provided to the U.S. Government
+  * only as a commercial end item.  Consistent with 48 C.F.R.12.212 and
+  * 48 C.F.R. 227.7202-1 through 227.7202-4 (JUNE 1995), all
+  * U.S. Government End Users acquire the Licensed Deliverables with
+  * only those rights set forth herein.
+  *
+  * Any use of the Licensed Deliverables in individual and commercial
+  * software must include, in the user documentation and internal
+  * comments to the code, the above Disclaimer and U.S. Government End
+  * Users Notice.
+  */
+
+
+#if !defined(CURAND_DISCRETE_H_)
+#define CURAND_DISCRETE_H_
+
+/**
+ * \defgroup DEVICE Device API
+ *
+ * @{
+ */
+
+#ifndef __CUDACC_RTC__
+#include <math.h>
+#endif // __CUDACC_RTC__
+
+#include "curand_mrg32k3a.h"
+#include "curand_mtgp32_kernel.h"
+#include "curand_philox4x32_x.h"
+
+
+template <typename T>
+QUALIFIERS unsigned int _curand_discrete(T x, curandDiscreteDistribution_t discrete_distribution){
+    if (discrete_distribution->method == CURAND_M2){
+        return _curand_M2_double(x, discrete_distribution->M2);
+    }
+    return (unsigned int)((discrete_distribution->stddev * _curand_normal_icdf_double(x)) + discrete_distribution->mean + 0.5);
+}
+
+
+template <typename STATE>
+QUALIFIERS unsigned int curand__discrete(STATE state, curandDiscreteDistribution_t discrete_distribution){
+    if (discrete_distribution->method == CURAND_M2){
+        return curand_M2_double(state, discrete_distribution->M2);
+    }
+    return (unsigned int)((discrete_distribution->stddev * curand_normal_double(state)) + discrete_distribution->mean + 0.5); //Round to nearest
+}
+
+template <typename STATE>
+QUALIFIERS uint4 curand__discrete4(STATE state, curandDiscreteDistribution_t discrete_distribution){
+    if (discrete_distribution->method == CURAND_M2){
+        return curand_M2_double4(state, discrete_distribution->M2);
+    }
+    double4 _res;
+    uint4 result;
+    _res = curand_normal4_double(state);
+    result.x = (unsigned int)((discrete_distribution->stddev * _res.x) + discrete_distribution->mean + 0.5); //Round to nearest
+    result.y = (unsigned int)((discrete_distribution->stddev * _res.y) + discrete_distribution->mean + 0.5); //Round to nearest
+    result.z = (unsigned int)((discrete_distribution->stddev * _res.z) + discrete_distribution->mean + 0.5); //Round to nearest
+    result.w = (unsigned int)((discrete_distribution->stddev * _res.w) + discrete_distribution->mean + 0.5); //Round to nearest
+    return result;
+}
+
+/*
+ * \brief Return a discrete distributed unsigned int from a XORWOW generator.
+ *
+ * Return a single discrete distributed unsigned int derived from a
+ * distribution defined by \p discrete_distribution from the XORWOW generator in \p state,
+ * increment position of generator by one.
+ *
+ * \param state - Pointer to state to update
+ * \param discrete_distribution - ancillary structure for discrete distribution
+ *
+ * \return unsigned int distributed by distribution defined by \p discrete_distribution.
+ */
+QUALIFIERS unsigned int curand_discrete(curandStateXORWOW_t *state, curandDiscreteDistribution_t discrete_distribution)
+{
+    return curand__discrete(state, discrete_distribution);
+}
+
+/*
+ * \brief Return a discrete distributed unsigned int from a Philox4_32_10 generator.
+ *
+ * Return a single discrete distributed unsigned int derived from a
+ * distribution defined by \p discrete_distribution from the Philox4_32_10 generator in \p state,
+ * increment position of generator by one.
+ *
+ * \param state - Pointer to state to update
+ * \param discrete_distribution - ancillary structure for discrete distribution
+ *
+ * \return unsigned int distributed by distribution defined by \p discrete_distribution.
+ */
+QUALIFIERS unsigned int curand_discrete(curandStatePhilox4_32_10_t *state, curandDiscreteDistribution_t discrete_distribution)
+{
+    return curand__discrete(state, discrete_distribution);
+}
+
+/*
+ * \brief Return four discrete distributed unsigned ints from a Philox4_32_10 generator.
+ *
+ * Return four single discrete distributed unsigned ints derived from a
+ * distribution defined by \p discrete_distribution from the Philox4_32_10 generator in \p state,
+ * increment position of generator by one.
+ *
+ * \param state - Pointer to state to update
+ * \param discrete_distribution - ancillary structure for discrete distribution
+ *
+ * \return unsigned int distributed by distribution defined by \p discrete_distribution.
+ */
+QUALIFIERS uint4 curand_discrete4(curandStatePhilox4_32_10_t *state, curandDiscreteDistribution_t discrete_distribution)
+{
+    return curand__discrete4(state, discrete_distribution);
+}
+/*
+ * \brief Return a discrete distributed unsigned int from a MRG32k3a generator.
+ *
+ * Re turn a single discrete distributed unsigned int derived from a
+ * distribution defined by \p discrete_distribution from the MRG32k3a generator in \p state,
+ * increment position of generator by one.
+ *
+ * \param state - Pointer to state to update
+ * \param discrete_distribution - ancillary structure for discrete distribution
+ *
+ * \return unsigned int distributed by distribution defined by \p discrete_distribution.
+ */
+QUALIFIERS unsigned int curand_discrete(curandStateMRG32k3a_t *state, curandDiscreteDistribution_t discrete_distribution)
+{
+    return curand__discrete(state, discrete_distribution);
+}
+
+/*
+ * \brief Return a discrete distributed unsigned int from a MTGP32 generator.
+ *
+ * Return a single discrete distributed unsigned int derived from a
+ * distribution defined by \p discrete_distribution from the MTGP32 generator in \p state,
+ * increment position of generator by one.
+ *
+ * \param state - Pointer to state to update
+ * \param discrete_distribution - ancillary structure for discrete distribution
+ *
+ * \return unsigned int distributed by distribution defined by \p discrete_distribution.
+ */
+QUALIFIERS unsigned int curand_discrete(curandStateMtgp32_t *state, curandDiscreteDistribution_t discrete_distribution)
+{
+    return curand__discrete(state, discrete_distribution);
+}
+
+/*
+ * \brief Return a discrete distributed unsigned int from a Sobol32 generator.
+ *
+ * Return a single discrete distributed unsigned int derived from a
+ * distribution defined by \p discrete_distribution from the Sobol32 generator in \p state,
+ * increment position of generator by one.
+ *
+ * \param state - Pointer to state to update
+ * \param discrete_distribution - ancillary structure for discrete distribution
+ *
+ * \return unsigned int distributed by distribution defined by \p discrete_distribution.
+ */
+QUALIFIERS unsigned int curand_discrete(curandStateSobol32_t *state, curandDiscreteDistribution_t discrete_distribution)
+{
+    return curand__discrete(state, discrete_distribution);
+}
+
+/*
+ * \brief Return a discrete distributed unsigned int from a scrambled Sobol32 generator.
+ *
+ * Return a single discrete distributed unsigned int derived from a
+ * distribution defined by \p discrete_distribution from the scrambled Sobol32 generator in \p state,
+ * increment position of generator by one.
+ *
+ * \param state - Pointer to state to update
+ * \param discrete_distribution - ancillary structure for discrete distribution
+ *
+ * \return unsigned int distributed by distribution defined by \p discrete_distribution.
+ */
+QUALIFIERS unsigned int curand_discrete(curandStateScrambledSobol32_t *state, curandDiscreteDistribution_t discrete_distribution)
+{
+    return curand__discrete(state, discrete_distribution);
+}
+
+/*
+ * \brief Return a discrete distributed unsigned int from a Sobol64 generator.
+ *
+ * Return a single discrete distributed unsigned int derived from a
+ * distribution defined by \p discrete_distribution from the Sobol64 generator in \p state,
+ * increment position of generator by one.
+ *
+ * \param state - Pointer to state to update
+ * \param discrete_distribution - ancillary structure for discrete distribution
+ *
+ * \return unsigned int distributed by distribution defined by \p discrete_distribution.
+ */
+QUALIFIERS unsigned int curand_discrete(curandStateSobol64_t *state, curandDiscreteDistribution_t discrete_distribution)
+{
+    return curand__discrete(state, discrete_distribution);
+}
+
+/*
+ * \brief Return a discrete distributed unsigned int from a scrambled Sobol64 generator.
+ *
+ * Return a single discrete distributed unsigned int derived from a
+ * distribution defined by \p discrete_distribution from the scrambled Sobol64 generator in \p state,
+ * increment position of generator by one.
+ *
+ * \param state - Pointer to state to update
+ * \param discrete_distribution - ancillary structure for discrete distribution
+ *
+ * \return unsigned int distributed by distribution defined by \p discrete_distribution.
+ */
+QUALIFIERS unsigned int curand_discrete(curandStateScrambledSobol64_t *state, curandDiscreteDistribution_t discrete_distribution)
+{
+    return curand__discrete(state, discrete_distribution);
+}
+
+#endif // !defined(CURAND_DISCRETE_H_)

infer_4_37_2/lib/python3.10/site-packages/nvidia/curand/include/curand_kernel.h

@@ -0,0 +1,1677 @@
+
+ /* Copyright 2010-2014 NVIDIA Corporation.  All rights reserved.
+  *
+  * NOTICE TO LICENSEE:
+  *
+  * The source code and/or documentation ("Licensed Deliverables") are
+  * subject to NVIDIA intellectual property rights under U.S. and
+  * international Copyright laws.
+  *
+  * The Licensed Deliverables contained herein are PROPRIETARY and
+  * CONFIDENTIAL to NVIDIA and are being provided under the terms and
+  * conditions of a form of NVIDIA software license agreement by and
+  * between NVIDIA and Licensee ("License Agreement") or electronically
+  * accepted by Licensee.  Notwithstanding any terms or conditions to
+  * the contrary in the License Agreement, reproduction or disclosure
+  * of the Licensed Deliverables to any third party without the express
+  * written consent of NVIDIA is prohibited.
+  *
+  * NOTWITHSTANDING ANY TERMS OR CONDITIONS TO THE CONTRARY IN THE
+  * LICENSE AGREEMENT, NVIDIA MAKES NO REPRESENTATION ABOUT THE
+  * SUITABILITY OF THESE LICENSED DELIVERABLES FOR ANY PURPOSE.  THEY ARE
+  * PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY OF ANY KIND.
+  * NVIDIA DISCLAIMS ALL WARRANTIES WITH REGARD TO THESE LICENSED
+  * DELIVERABLES, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY,
+  * NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE.
+  * NOTWITHSTANDING ANY TERMS OR CONDITIONS TO THE CONTRARY IN THE
+  * LICENSE AGREEMENT, IN NO EVENT SHALL NVIDIA BE LIABLE FOR ANY
+  * SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, OR ANY
+  * DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+  * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
+  * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
+  * OF THESE LICENSED DELIVERABLES.
+  *
+  * U.S. Government End Users.  These Licensed Deliverables are a
+  * "commercial item" as that term is defined at 48 C.F.R. 2.101 (OCT
+  * 1995), consisting of "commercial computer software" and "commercial
+  * computer software documentation" as such terms are used in 48
+  * C.F.R. 12.212 (SEPT 1995) and are provided to the U.S. Government
+  * only as a commercial end item.  Consistent with 48 C.F.R.12.212 and
+  * 48 C.F.R. 227.7202-1 through 227.7202-4 (JUNE 1995), all
+  * U.S. Government End Users acquire the Licensed Deliverables with
+  * only those rights set forth herein.
+  *
+  * Any use of the Licensed Deliverables in individual and commercial
+  * software must include, in the user documentation and internal
+  * comments to the code, the above Disclaimer and U.S. Government End
+  * Users Notice.
+  */
+
+
+#if !defined(CURAND_KERNEL_H_)
+#define CURAND_KERNEL_H_
+
+/**
+ * \defgroup DEVICE Device API
+ *
+ * @{
+ */
+
+#if !defined(QUALIFIERS)
+#define QUALIFIERS static __forceinline__ __device__
+#endif
+
+/* To prevent unused parameter warnings */
+#if !defined(GCC_UNUSED_PARAMETER)
+#if defined(__GNUC__)
+#define GCC_UNUSED_PARAMETER __attribute__((unused))
+#else
+#define GCC_UNUSED_PARAMETER
+#endif /* defined(__GNUC__) */
+#endif /* !defined(GCC_UNUSED_PARAMETER) */
+
+#include <nv/target>
+
+#ifdef __CUDACC_RTC__
+#define CURAND_DETAIL_USE_CUDA_STL
+#endif
+
+#if __cplusplus >= 201103L
+#   ifdef CURAND_DETAIL_USE_CUDA_STL
+#       define CURAND_STD cuda::std
+#       include <cuda/std/type_traits>
+#   else
+#       define CURAND_STD std
+#       include <type_traits>
+#   endif // CURAND_DETAIL_USE_CUDA_STL
+#else
+// To support C++03 compilation
+#   define CURAND_STD curand_detail
+namespace curand_detail {
+    template<bool B, class T = void>
+    struct enable_if {};
+
+    template<class T>
+    struct enable_if<true, T> { typedef T type; };
+
+    template<class T, class U>
+    struct is_same { static const bool value = false; };
+
+    template<class T>
+    struct is_same<T, T> { static const bool value = true; };
+} // namespace curand_detail
+#endif // __cplusplus >= 201103L
+
+#ifndef __CUDACC_RTC__
+#include <math.h>
+#endif // __CUDACC_RTC__
+
+#include "curand.h"
+#include "curand_discrete.h"
+#include "curand_precalc.h"
+#include "curand_mrg32k3a.h"
+#include "curand_mtgp32_kernel.h"
+#include "curand_philox4x32_x.h"
+#include "curand_globals.h"
+
+/* Test RNG */
+/* This generator uses the formula:
+   x_n = x_(n-1) + 1 mod 2^32
+   x_0 = (unsigned int)seed * 3
+   Subsequences are spaced 31337 steps apart.
+*/
+struct curandStateTest {
+    unsigned int v;
+};
+
+/** \cond UNHIDE_TYPEDEFS */
+typedef struct curandStateTest curandStateTest_t;
+/** \endcond */
+
+/* XORSHIFT FAMILY RNGs */
+/* These generators are a family proposed by Marsaglia.  They keep state
+   in 32 bit chunks, then use repeated shift and xor operations to scramble
+   the bits.  The following generators are a combination of a simple Weyl
+   generator with an N variable XORSHIFT generator.
+*/
+
+/* XORSHIFT RNG */
+/* This generator uses the xorwow formula of
+www.jstatsoft.org/v08/i14/paper page 5
+Has period 2^192 - 2^32.
+*/
+/**
+ * CURAND XORWOW state
+ */
+struct curandStateXORWOW;
+
+/*
+ * Implementation details not in reference documentation */
+struct curandStateXORWOW {
+    unsigned int d, v[5];
+    int boxmuller_flag;
+    int boxmuller_flag_double;
+    float boxmuller_extra;
+    double boxmuller_extra_double;
+};
+
+/*
+ * CURAND XORWOW state
+ */
+/** \cond UNHIDE_TYPEDEFS */
+typedef struct curandStateXORWOW curandStateXORWOW_t;
+
+#define EXTRA_FLAG_NORMAL         0x00000001
+#define EXTRA_FLAG_LOG_NORMAL     0x00000002
+/** \endcond */
+
+/* Combined Multiple Recursive Generators */
+/* These generators are a family proposed by L'Ecuyer.  They keep state
+   in sets of doubles, then use repeated modular arithmetic multiply operations
+   to scramble the bits in each set, and combine the result.
+*/
+
+/* MRG32k3a RNG */
+/* This generator uses the MRG32k3A formula of
+http://www.iro.umontreal.ca/~lecuyer/myftp/streams00/c++/streams4.pdf
+Has period 2^191.
+*/
+
+/* moduli for the recursions */
+/** \cond UNHIDE_DEFINES */
+#define MRG32K3A_MOD1 4294967087.
+#define MRG32K3A_MOD2 4294944443.
+
+/* Constants used in generation */
+
+#define MRG32K3A_A12  1403580.
+#define MRG32K3A_A13N 810728.
+#define MRG32K3A_A21  527612.
+#define MRG32K3A_A23N 1370589.
+#define MRG32K3A_NORM (2.3283065498378288e-10)
+//
+// #define MRG32K3A_BITS_NORM ((double)((POW32_DOUBLE-1.0)/MOD1))
+//  above constant, used verbatim, rounds differently on some host systems.
+#define MRG32K3A_BITS_NORM 1.000000048662
+
+/** \endcond */
+
+
+
+
+/**
+ * CURAND MRG32K3A state
+ */
+struct curandStateMRG32k3a;
+
+/* Implementation details not in reference documentation */
+struct curandStateMRG32k3a {
+    unsigned int s1[3];
+    unsigned int s2[3];
+    int boxmuller_flag;
+    int boxmuller_flag_double;
+    float boxmuller_extra;
+    double boxmuller_extra_double;
+};
+
+/*
+ * CURAND MRG32K3A state
+ */
+/** \cond UNHIDE_TYPEDEFS */
+typedef struct curandStateMRG32k3a curandStateMRG32k3a_t;
+/** \endcond */
+
+/* SOBOL QRNG */
+/**
+ * CURAND Sobol32 state
+ */
+struct curandStateSobol32;
+
+/* Implementation details not in reference documentation */
+struct curandStateSobol32 {
+    unsigned int i, x, c;
+    unsigned int direction_vectors[32];
+};
+
+/*
+ * CURAND Sobol32 state
+ */
+/** \cond UNHIDE_TYPEDEFS */
+typedef struct curandStateSobol32 curandStateSobol32_t;
+/** \endcond */
+
+/**
+ * CURAND Scrambled Sobol32 state
+ */
+struct curandStateScrambledSobol32;
+
+/* Implementation details not in reference documentation */
+struct curandStateScrambledSobol32 {
+    unsigned int i, x, c;
+    unsigned int direction_vectors[32];
+};
+
+/*
+ * CURAND Scrambled Sobol32 state
+ */
+/** \cond UNHIDE_TYPEDEFS */
+typedef struct curandStateScrambledSobol32 curandStateScrambledSobol32_t;
+/** \endcond */
+
+/**
+ * CURAND Sobol64 state
+ */
+struct curandStateSobol64;
+
+/* Implementation details not in reference documentation */
+struct curandStateSobol64 {
+    unsigned long long i, x, c;
+    unsigned long long direction_vectors[64];
+};
+
+/*
+ * CURAND Sobol64 state
+ */
+/** \cond UNHIDE_TYPEDEFS */
+typedef struct curandStateSobol64 curandStateSobol64_t;
+/** \endcond */
+
+/**
+ * CURAND Scrambled Sobol64 state
+ */
+struct curandStateScrambledSobol64;
+
+/* Implementation details not in reference documentation */
+struct curandStateScrambledSobol64 {
+    unsigned long long i, x, c;
+    unsigned long long direction_vectors[64];
+};
+
+/*
+ * CURAND Scrambled Sobol64 state
+ */
+/** \cond UNHIDE_TYPEDEFS */
+typedef struct curandStateScrambledSobol64 curandStateScrambledSobol64_t;
+/** \endcond */
+
+/*
+ * Default RNG
+ */
+/** \cond UNHIDE_TYPEDEFS */
+typedef struct curandStateXORWOW curandState_t;
+typedef struct curandStateXORWOW curandState;
+/** \endcond */
+
+/****************************************************************************/
+/* Utility functions needed by RNGs */
+/****************************************************************************/
+/** \cond UNHIDE_UTILITIES */
+/*
+   multiply vector by matrix, store in result
+   matrix is n x n, measured in 32 bit units
+   matrix is stored in row major order
+   vector and result cannot be same pointer
+*/
+template<int N>
+QUALIFIERS void __curand_matvec_inplace(unsigned int *vector, unsigned int *matrix)
+{
+    unsigned int result[N] = { 0 };
+    for(int i = 0; i < N; i++) {
+        #ifdef __CUDA_ARCH__
+        #pragma unroll 16
+        #endif
+        for(int j = 0; j < 32; j++) {
+            if(vector[i] & (1 << j)) {
+                for(int k = 0; k < N; k++) {
+                    result[k] ^= matrix[N * (i * 32 + j) + k];
+                }
+            }
+        }
+    }
+    for(int i = 0; i < N; i++) {
+        vector[i] = result[i];
+    }
+}
+
+QUALIFIERS void __curand_matvec(unsigned int *vector, unsigned int *matrix,
+                                unsigned int *result, int n)
+{
+    for(int i = 0; i < n; i++) {
+        result[i] = 0;
+    }
+    for(int i = 0; i < n; i++) {
+        for(int j = 0; j < 32; j++) {
+            if(vector[i] & (1 << j)) {
+                for(int k = 0; k < n; k++) {
+                    result[k] ^= matrix[n * (i * 32 + j) + k];
+                }
+            }
+        }
+    }
+}
+
+/* generate identity matrix */
+QUALIFIERS void __curand_matidentity(unsigned int *matrix, int n)
+{
+    int r;
+    for(int i = 0; i < n * 32; i++) {
+        for(int j = 0; j < n; j++) {
+            r = i & 31;
+            if(i / 32 == j) {
+                matrix[i * n + j] = (1 << r);
+            } else {
+                matrix[i * n + j] = 0;
+            }
+        }
+    }
+}
+
+/* multiply matrixA by matrixB, store back in matrixA
+   matrixA and matrixB must not be same matrix */
+QUALIFIERS void __curand_matmat(unsigned int *matrixA, unsigned int *matrixB, int n)
+{
+    unsigned int result[MAX_XOR_N];
+    for(int i = 0; i < n * 32; i++) {
+        __curand_matvec(matrixA + i * n, matrixB, result, n);
+        for(int j = 0; j < n; j++) {
+            matrixA[i * n + j] = result[j];
+        }
+    }
+}
+
+/* copy vectorA to vector */
+QUALIFIERS void __curand_veccopy(unsigned int *vector, unsigned int *vectorA, int n)
+{
+    for(int i = 0; i < n; i++) {
+        vector[i] = vectorA[i];
+    }
+}
+
+/* copy matrixA to matrix */
+QUALIFIERS void __curand_matcopy(unsigned int *matrix, unsigned int *matrixA, int n)
+{
+    for(int i = 0; i < n * n * 32; i++) {
+        matrix[i] = matrixA[i];
+    }
+}
+
+/* compute matrixA to power p, store result in matrix */
+QUALIFIERS void __curand_matpow(unsigned int *matrix, unsigned int *matrixA,
+                                unsigned long long p, int n)
+{
+    unsigned int matrixR[MAX_XOR_N * MAX_XOR_N * 32];
+    unsigned int matrixS[MAX_XOR_N * MAX_XOR_N * 32];
+    __curand_matidentity(matrix, n);
+    __curand_matcopy(matrixR, matrixA, n);
+    while(p) {
+        if(p & 1) {
+            __curand_matmat(matrix, matrixR, n);
+        }
+        __curand_matcopy(matrixS, matrixR, n);
+        __curand_matmat(matrixR, matrixS, n);
+        p >>= 1;
+    }
+}
+
+/****************************************************************************/
+/* Utility functions needed by MRG32k3a RNG                                 */
+/* Matrix operations modulo some integer less than 2**32, done in           */
+/* double precision floating point, with care not to overflow 53 bits       */
+/****************************************************************************/
+
+/* return i mod m.                                                          */
+/* assumes i and m are integers represented accurately in doubles           */
+
+QUALIFIERS double curand_MRGmod(double i, double m)
+{
+    double quo;
+    double rem;
+    quo = floor(i/m);
+    rem = i - (quo*m);
+    if (rem < 0.0) rem += m;
+    return rem;
+}
+
+/* Multiplication modulo m. Inputs i and j less than 2**32                  */
+/* Ensure intermediate results do not exceed 2**53                          */
+
+QUALIFIERS double curand_MRGmodMul(double i, double j, double m)
+{
+    double tempHi;
+    double tempLo;
+
+    tempHi = floor(i/131072.0);
+    tempLo = i - (tempHi*131072.0);
+    tempLo = curand_MRGmod( curand_MRGmod( (tempHi * j), m) * 131072.0 + curand_MRGmod(tempLo * j, m),m);
+
+    if (tempLo < 0.0) tempLo += m;
+    return tempLo;
+}
+
+/* multiply 3 by 3 matrices of doubles, modulo m                            */
+
+QUALIFIERS void curand_MRGmatMul3x3(unsigned int i1[][3],unsigned int i2[][3],unsigned int o[][3],double m)
+{
+    int i,j;
+    double temp[3][3];
+    for (i=0; i<3; i++){
+        for (j=0; j<3; j++){
+            temp[i][j] = ( curand_MRGmodMul(i1[i][0], i2[0][j], m) +
+                           curand_MRGmodMul(i1[i][1], i2[1][j], m) +
+                           curand_MRGmodMul(i1[i][2], i2[2][j], m));
+            temp[i][j] = curand_MRGmod( temp[i][j], m );
+        }
+    }
+    for (i=0; i<3; i++){
+        for (j=0; j<3; j++){
+            o[i][j] = (unsigned int)temp[i][j];
+        }
+    }
+}
+
+/* multiply 3 by 3 matrix times 3 by 1 vector of doubles, modulo m          */
+
+QUALIFIERS void curand_MRGmatVecMul3x3( unsigned int i[][3], unsigned int v[], double m)
+{
+    int k;
+    double t[3];
+    for (k = 0; k < 3; k++) {
+        t[k] = ( curand_MRGmodMul(i[k][0], v[0], m) +
+                 curand_MRGmodMul(i[k][1], v[1], m) +
+                 curand_MRGmodMul(i[k][2], v[2], m) );
+        t[k] = curand_MRGmod( t[k], m );
+    }
+    for (k = 0; k < 3; k++) {
+        v[k] = (unsigned int)t[k];
+    }
+
+}
+
+/* raise a 3 by 3 matrix of doubles to a 64 bit integer power pow, modulo m */
+/* input is index zero of an array of 3 by 3 matrices m,                    */
+/* each m = m[0]**(2**index)                                                */
+
+QUALIFIERS void curand_MRGmatPow3x3( unsigned int in[][3][3], unsigned int o[][3], double m, unsigned long long pow )
+{
+    int i,j;
+    for ( i = 0; i < 3; i++ ) {
+        for ( j = 0; j < 3; j++ ) {
+            o[i][j] = 0;
+            if ( i == j ) o[i][j] = 1;
+        }
+    }
+    i = 0;
+    curand_MRGmatVecMul3x3(o,o[0],m);
+    while (pow) {
+        if ( pow & 1ll ) {
+             curand_MRGmatMul3x3(in[i], o, o, m);
+        }
+        i++;
+        pow >>= 1;
+    }
+}
+
+/* raise a 3 by 3 matrix of doubles to the power                            */
+/* 2 to the power (pow modulo 191), modulo m                                */
+
+QUALIFIERS void curnand_MRGmatPow2Pow3x3( double in[][3], double o[][3], double m, unsigned long pow )
+{
+    unsigned int temp[3][3];
+    int i,j;
+    pow = pow % 191;
+    for ( i = 0; i < 3; i++ ) {
+        for ( j = 0; j < 3; j++ ) {
+            temp[i][j] = (unsigned int)in[i][j];
+        }
+    }
+    while (pow) {
+        curand_MRGmatMul3x3(temp, temp, temp, m);
+        pow--;
+    }
+    for ( i = 0; i < 3; i++ ) {
+        for ( j = 0; j < 3; j++ ) {
+            o[i][j] = temp[i][j];
+        }
+    }
+}
+
+/** \endcond */
+
+/****************************************************************************/
+/* Kernel implementations of RNGs                                           */
+/****************************************************************************/
+
+/* Test RNG */
+
+QUALIFIERS void curand_init(unsigned long long seed,
+                                            unsigned long long subsequence,
+                                            unsigned long long offset,
+                                            curandStateTest_t *state)
+{
+    state->v = (unsigned int)(seed * 3) + (unsigned int)(subsequence * 31337) + \
+                     (unsigned int)offset;
+}
+
+
+QUALIFIERS unsigned int curand(curandStateTest_t *state)
+{
+    unsigned int r = state->v++;
+    return r;
+}
+
+QUALIFIERS void skipahead(unsigned long long n, curandStateTest_t *state)
+{
+    state->v += (unsigned int)n;
+}
+
+/* XORWOW RNG */
+
+template <typename T, int n>
+QUALIFIERS void __curand_generate_skipahead_matrix_xor(unsigned int matrix[])
+{
+    T state;
+    // Generate matrix that advances one step
+    // matrix has n * n * 32 32-bit elements
+    // solve for matrix by stepping single bit states
+    for(int i = 0; i < 32 * n; i++) {
+        state.d = 0;
+        for(int j = 0; j < n; j++) {
+            state.v[j] = 0;
+        }
+        state.v[i / 32] = (1 << (i & 31));
+        curand(&state);
+        for(int j = 0; j < n; j++) {
+            matrix[i * n + j] = state.v[j];
+        }
+    }
+}
+
+template <typename T, int n>
+QUALIFIERS void _skipahead_scratch(unsigned long long x, T *state, unsigned int *scratch)
+{
+    // unsigned int matrix[n * n * 32];
+    unsigned int *matrix = scratch;
+    // unsigned int matrixA[n * n * 32];
+    unsigned int *matrixA = scratch + (n * n * 32);
+    // unsigned int vector[n];
+    unsigned int *vector = scratch + (n * n * 32) + (n * n * 32);
+    // unsigned int result[n];
+    unsigned int *result = scratch + (n * n * 32) + (n * n * 32) + n;
+    unsigned long long p = x;
+    for(int i = 0; i < n; i++) {
+        vector[i] = state->v[i];
+    }
+    int matrix_num = 0;
+    while(p && (matrix_num < PRECALC_NUM_MATRICES - 1)) {
+        for(unsigned int t = 0; t < (p & PRECALC_BLOCK_MASK); t++) {
+NV_IF_ELSE_TARGET(NV_IS_DEVICE,
+            __curand_matvec(vector, precalc_xorwow_offset_matrix[matrix_num], result, n);
+,
+            __curand_matvec(vector, precalc_xorwow_offset_matrix_host[matrix_num], result, n);
+)
+            __curand_veccopy(vector, result, n);
+        }
+        p >>= PRECALC_BLOCK_SIZE;
+        matrix_num++;
+    }
+    if(p) {
+NV_IF_ELSE_TARGET(NV_IS_DEVICE,
+        __curand_matcopy(matrix, precalc_xorwow_offset_matrix[PRECALC_NUM_MATRICES - 1], n);
+        __curand_matcopy(matrixA, precalc_xorwow_offset_matrix[PRECALC_NUM_MATRICES - 1], n);
+,
+        __curand_matcopy(matrix, precalc_xorwow_offset_matrix_host[PRECALC_NUM_MATRICES - 1], n);
+        __curand_matcopy(matrixA, precalc_xorwow_offset_matrix_host[PRECALC_NUM_MATRICES - 1], n);
+)
+    }
+    while(p) {
+        for(unsigned int t = 0; t < (p & SKIPAHEAD_MASK); t++) {
+            __curand_matvec(vector, matrixA, result, n);
+            __curand_veccopy(vector, result, n);
+        }
+        p >>= SKIPAHEAD_BLOCKSIZE;
+        if(p) {
+            for(int i = 0; i < SKIPAHEAD_BLOCKSIZE; i++) {
+                __curand_matmat(matrix, matrixA, n);
+                __curand_matcopy(matrixA, matrix, n);
+            }
+        }
+    }
+    for(int i = 0; i < n; i++) {
+        state->v[i] = vector[i];
+    }
+    state->d += 362437 * (unsigned int)x;
+}
+
+template <typename T, int n>
+QUALIFIERS void _skipahead_sequence_scratch(unsigned long long x, T *state, unsigned int *scratch)
+{
+    // unsigned int matrix[n * n * 32];
+    unsigned int *matrix = scratch;
+    // unsigned int matrixA[n * n * 32];
+    unsigned int *matrixA = scratch + (n * n * 32);
+    // unsigned int vector[n];
+    unsigned int *vector = scratch + (n * n * 32) + (n * n * 32);
+    // unsigned int result[n];
+    unsigned int *result = scratch + (n * n * 32) + (n * n * 32) + n;
+    unsigned long long p = x;
+    for(int i = 0; i < n; i++) {
+        vector[i] = state->v[i];
+    }
+    int matrix_num = 0;
+    while(p && matrix_num < PRECALC_NUM_MATRICES - 1) {
+        for(unsigned int t = 0; t < (p & PRECALC_BLOCK_MASK); t++) {
+NV_IF_ELSE_TARGET(NV_IS_DEVICE,
+            __curand_matvec(vector, precalc_xorwow_matrix[matrix_num], result, n);
+,
+            __curand_matvec(vector, precalc_xorwow_matrix_host[matrix_num], result, n);
+)
+            __curand_veccopy(vector, result, n);
+        }
+        p >>= PRECALC_BLOCK_SIZE;
+        matrix_num++;
+    }
+    if(p) {
+NV_IF_ELSE_TARGET(NV_IS_DEVICE,
+        __curand_matcopy(matrix, precalc_xorwow_matrix[PRECALC_NUM_MATRICES - 1], n);
+        __curand_matcopy(matrixA, precalc_xorwow_matrix[PRECALC_NUM_MATRICES - 1], n);
+,
+        __curand_matcopy(matrix, precalc_xorwow_matrix_host[PRECALC_NUM_MATRICES - 1], n);
+        __curand_matcopy(matrixA, precalc_xorwow_matrix_host[PRECALC_NUM_MATRICES - 1], n);
+)
+    }
+    while(p) {
+        for(unsigned int t = 0; t < (p & SKIPAHEAD_MASK); t++) {
+            __curand_matvec(vector, matrixA, result, n);
+            __curand_veccopy(vector, result, n);
+        }
+        p >>= SKIPAHEAD_BLOCKSIZE;
+        if(p) {
+            for(int i = 0; i < SKIPAHEAD_BLOCKSIZE; i++) {
+                __curand_matmat(matrix, matrixA, n);
+                __curand_matcopy(matrixA, matrix, n);
+            }
+        }
+    }
+    for(int i = 0; i < n; i++) {
+        state->v[i] = vector[i];
+    }
+    /* No update of state->d needed, guaranteed to be a multiple of 2^32 */
+}
+
+template <typename T, int N>
+QUALIFIERS void _skipahead_inplace(const unsigned long long x, T *state)
+{
+    unsigned long long p = x;
+    int matrix_num = 0;
+    while(p) {
+        for(unsigned int t = 0; t < (p & PRECALC_BLOCK_MASK); t++) {
+NV_IF_ELSE_TARGET(NV_IS_DEVICE,
+            __curand_matvec_inplace<N>(state->v, precalc_xorwow_offset_matrix[matrix_num]);
+,
+            __curand_matvec_inplace<N>(state->v, precalc_xorwow_offset_matrix_host[matrix_num]);
+)
+        }
+        p >>= PRECALC_BLOCK_SIZE;
+        matrix_num++;
+    }
+    state->d += 362437 * (unsigned int)x;
+}
+
+template <typename T, int N>
+QUALIFIERS void _skipahead_sequence_inplace(unsigned long long x, T *state)
+{
+    int matrix_num = 0;
+    while(x) {
+        for(unsigned int t = 0; t < (x & PRECALC_BLOCK_MASK); t++) {
+NV_IF_ELSE_TARGET(NV_IS_DEVICE,
+            __curand_matvec_inplace<N>(state->v, precalc_xorwow_matrix[matrix_num]);
+,
+            __curand_matvec_inplace<N>(state->v, precalc_xorwow_matrix_host[matrix_num]);
+)
+        }
+        x >>= PRECALC_BLOCK_SIZE;
+        matrix_num++;
+    }
+    /* No update of state->d needed, guaranteed to be a multiple of 2^32 */
+}
+
+/**
+ * \brief Update XORWOW state to skip \p n elements.
+ *
+ * Update the XORWOW state in \p state to skip ahead \p n elements.
+ *
+ * All values of \p n are valid.  Large values require more computation and so
+ * will take more time to complete.
+ *
+ * \param n - Number of elements to skip
+ * \param state - Pointer to state to update
+ */
+QUALIFIERS void skipahead(unsigned long long n, curandStateXORWOW_t *state)
+{
+    _skipahead_inplace<curandStateXORWOW_t, 5>(n, state);
+}
+
+/**
+ * \brief Update XORWOW state to skip ahead \p n subsequences.
+ *
+ * Update the XORWOW state in \p state to skip ahead \p n subsequences.  Each
+ * subsequence is \xmlonly<ph outputclass="xmlonly">2<sup>67</sup></ph>\endxmlonly elements long, so this means the function will skip ahead
+ * \xmlonly<ph outputclass="xmlonly">2<sup>67</sup></ph>\endxmlonly  * n elements.
+ *
+ * All values of \p n are valid.  Large values require more computation and so
+ * will take more time to complete.
+ *
+ * \param n - Number of subsequences to skip
+ * \param state - Pointer to state to update
+ */
+QUALIFIERS void skipahead_sequence(unsigned long long n, curandStateXORWOW_t *state)
+{
+    _skipahead_sequence_inplace<curandStateXORWOW_t, 5>(n, state);
+}
+
+QUALIFIERS void _curand_init_scratch(unsigned long long seed,
+                                     unsigned long long subsequence,
+                                     unsigned long long offset,
+                                     curandStateXORWOW_t *state,
+                                     unsigned int *scratch)
+{
+    // Break up seed, apply salt
+    // Constants are arbitrary nonzero values
+    unsigned int s0 = ((unsigned int)seed) ^ 0xaad26b49UL;
+    unsigned int s1 = (unsigned int)(seed >> 32) ^ 0xf7dcefddUL;
+    // Simple multiplication to mix up bits
+    // Constants are arbitrary odd values
+    unsigned int t0 = 1099087573UL * s0;
+    unsigned int t1 = 2591861531UL * s1;
+    state->d = 6615241 + t1 + t0;
+    state->v[0] = 123456789UL + t0;
+    state->v[1] = 362436069UL ^ t0;
+    state->v[2] = 521288629UL + t1;
+    state->v[3] = 88675123UL ^ t1;
+    state->v[4] = 5783321UL + t0;
+    _skipahead_sequence_scratch<curandStateXORWOW_t, 5>(subsequence, state, scratch);
+    _skipahead_scratch<curandStateXORWOW_t, 5>(offset, state, scratch);
+    state->boxmuller_flag = 0;
+    state->boxmuller_flag_double = 0;
+    state->boxmuller_extra = 0.f;
+    state->boxmuller_extra_double = 0.;
+}
+
+QUALIFIERS void _curand_init_inplace(unsigned long long seed,
+                                     unsigned long long subsequence,
+                                     unsigned long long offset,
+                                     curandStateXORWOW_t *state)
+{
+    // Break up seed, apply salt
+    // Constants are arbitrary nonzero values
+    unsigned int s0 = ((unsigned int)seed) ^ 0xaad26b49UL;
+    unsigned int s1 = (unsigned int)(seed >> 32) ^ 0xf7dcefddUL;
+    // Simple multiplication to mix up bits
+    // Constants are arbitrary odd values
+    unsigned int t0 = 1099087573UL * s0;
+    unsigned int t1 = 2591861531UL * s1;
+    state->d = 6615241 + t1 + t0;
+    state->v[0] = 123456789UL + t0;
+    state->v[1] = 362436069UL ^ t0;
+    state->v[2] = 521288629UL + t1;
+    state->v[3] = 88675123UL ^ t1;
+    state->v[4] = 5783321UL + t0;
+    _skipahead_sequence_inplace<curandStateXORWOW_t, 5>(subsequence, state);
+    _skipahead_inplace<curandStateXORWOW_t, 5>(offset, state);
+    state->boxmuller_flag = 0;
+    state->boxmuller_flag_double = 0;
+    state->boxmuller_extra = 0.f;
+    state->boxmuller_extra_double = 0.;
+}
+
+/**
+ * \brief Initialize XORWOW state.
+ *
+ * Initialize XORWOW state in \p state with the given \p seed, \p subsequence,
+ * and \p offset.
+ *
+ * All input values of \p seed, \p subsequence, and \p offset are legal.  Large
+ * values for \p subsequence and \p offset require more computation and so will
+ * take more time to complete.
+ *
+ * A value of 0 for \p seed sets the state to the values of the original
+ * published version of the \p xorwow algorithm.
+ *
+ * \param seed - Arbitrary bits to use as a seed
+ * \param subsequence - Subsequence to start at
+ * \param offset - Absolute offset into sequence
+ * \param state - Pointer to state to initialize
+ */
+QUALIFIERS void curand_init(unsigned long long seed,
+                            unsigned long long subsequence,
+                            unsigned long long offset,
+                            curandStateXORWOW_t *state)
+{
+    _curand_init_inplace(seed, subsequence, offset, state);
+}
+
+/**
+ * \brief Return 32-bits of pseudorandomness from an XORWOW generator.
+ *
+ * Return 32-bits of pseudorandomness from the XORWOW generator in \p state,
+ * increment position of generator by one.
+ *
+ * \param state - Pointer to state to update
+ *
+ * \return 32-bits of pseudorandomness as an unsigned int, all bits valid to use.
+ */
+QUALIFIERS unsigned int curand(curandStateXORWOW_t *state)
+{
+    unsigned int t;
+    t = (state->v[0] ^ (state->v[0] >> 2));
+    state->v[0] = state->v[1];
+    state->v[1] = state->v[2];
+    state->v[2] = state->v[3];
+    state->v[3] = state->v[4];
+    state->v[4] = (state->v[4] ^ (state->v[4] <<4)) ^ (t ^ (t << 1));
+    state->d += 362437;
+    return state->v[4] + state->d;
+}
+
+
+/**
+ * \brief Return 32-bits of pseudorandomness from an Philox4_32_10 generator.
+ *
+ * Return 32-bits of pseudorandomness from the Philox4_32_10 generator in \p state,
+ * increment position of generator by one.
+ *
+ * \param state - Pointer to state to update
+ *
+ * \return 32-bits of pseudorandomness as an unsigned int, all bits valid to use.
+ */
+
+QUALIFIERS unsigned int curand(curandStatePhilox4_32_10_t *state)
+{
+    // Maintain the invariant: output[STATE] is always "good" and
+    //  is the next value to be returned by curand.
+    unsigned int ret;
+    switch(state->STATE++){
+    default:
+        ret = state->output.x;
+        break;
+    case 1:
+        ret = state->output.y;
+        break;
+    case 2:
+        ret = state->output.z;
+        break;
+    case 3:
+        ret = state->output.w;
+        break;
+    }
+    if(state->STATE == 4){
+        Philox_State_Incr(state);
+        state->output = curand_Philox4x32_10(state->ctr,state->key);
+        state->STATE = 0;
+    }
+    return ret;
+}
+
+/**
+ * \brief Return tuple of 4 32-bit pseudorandoms from a Philox4_32_10 generator.
+ *
+ * Return 128 bits of pseudorandomness from the Philox4_32_10 generator in \p state,
+ * increment position of generator by four.
+ *
+ * \param state - Pointer to state to update
+ *
+ * \return 128-bits of pseudorandomness as a uint4, all bits valid to use.
+ */
+
+QUALIFIERS uint4 curand4(curandStatePhilox4_32_10_t *state)
+{
+    uint4 r;
+
+    uint4 tmp = state->output;
+    Philox_State_Incr(state);
+    state->output= curand_Philox4x32_10(state->ctr,state->key);
+    switch(state->STATE){
+    case 0:
+        return tmp;
+    case 1:
+        r.x = tmp.y;
+        r.y = tmp.z;
+        r.z = tmp.w;
+        r.w = state->output.x;
+        break;
+    case 2:
+        r.x = tmp.z;
+        r.y = tmp.w;
+        r.z = state->output.x;
+        r.w = state->output.y;
+        break;
+    case 3:
+        r.x = tmp.w;
+        r.y = state->output.x;
+        r.z = state->output.y;
+        r.w = state->output.z;
+        break;
+    default:
+        // NOT possible but needed to avoid compiler warnings
+        return tmp;
+    }
+    return r;
+}
+
+/**
+ * \brief Update Philox4_32_10 state to skip \p n elements.
+ *
+ * Update the Philox4_32_10 state in \p state to skip ahead \p n elements.
+ *
+ * All values of \p n are valid.
+ *
+ * \param n - Number of elements to skip
+ * \param state - Pointer to state to update
+ */
+QUALIFIERS void skipahead(unsigned long long n, curandStatePhilox4_32_10_t *state)
+{
+    state->STATE += (n & 3);
+    n /= 4;
+    if( state->STATE > 3 ){
+        n += 1;
+        state->STATE -= 4;
+    }
+    Philox_State_Incr(state, n);
+    state->output = curand_Philox4x32_10(state->ctr,state->key);
+}
+
+/**
+ * \brief Update Philox4_32_10 state to skip ahead \p n subsequences.
+ *
+ * Update the Philox4_32_10 state in \p state to skip ahead \p n subsequences.  Each
+ * subsequence is \xmlonly<ph outputclass="xmlonly">2<sup>66</sup></ph>\endxmlonly elements long, so this means the function will skip ahead
+ * \xmlonly<ph outputclass="xmlonly">2<sup>66</sup></ph>\endxmlonly * n elements.
+ *
+ * All values of \p n are valid.
+ *
+ * \param n - Number of subsequences to skip
+ * \param state - Pointer to state to update
+ */
+QUALIFIERS void skipahead_sequence(unsigned long long n, curandStatePhilox4_32_10_t *state)
+{
+    Philox_State_Incr_hi(state, n);
+    state->output = curand_Philox4x32_10(state->ctr,state->key);
+}
+
+/**
+ * \brief Initialize Philox4_32_10 state.
+ *
+ * Initialize Philox4_32_10 state in \p state with the given \p seed, p\ subsequence,
+ * and \p offset.
+ *
+ * All input values for \p seed, \p subseqence and \p offset are legal.  Each of the
+ * \xmlonly<ph outputclass="xmlonly">2<sup>64</sup></ph>\endxmlonly possible
+ * values of seed selects an independent sequence of length
+ * \xmlonly<ph outputclass="xmlonly">2<sup>130</sup></ph>\endxmlonly.
+ * The first
+ * \xmlonly<ph outputclass="xmlonly">2<sup>66</sup> * subsequence + offset</ph>\endxmlonly.
+ * values of the sequence are skipped.
+ * I.e., subsequences are of length
+ * \xmlonly<ph outputclass="xmlonly">2<sup>66</sup></ph>\endxmlonly.
+ *
+ * \param seed - Arbitrary bits to use as a seed
+ * \param subsequence - Subsequence to start at
+ * \param offset - Absolute offset into subsequence
+ * \param state - Pointer to state to initialize
+ */
+QUALIFIERS void curand_init(unsigned long long seed,
+                                 unsigned long long subsequence,
+                                 unsigned long long offset,
+                                 curandStatePhilox4_32_10_t *state)
+{
+    state->ctr = make_uint4(0, 0, 0, 0);
+    state->key.x = (unsigned int)seed;
+    state->key.y = (unsigned int)(seed>>32);
+    state->STATE = 0;
+    state->boxmuller_flag = 0;
+    state->boxmuller_flag_double = 0;
+    state->boxmuller_extra = 0.f;
+    state->boxmuller_extra_double = 0.;
+    skipahead_sequence(subsequence, state);
+    skipahead(offset, state);
+}
+
+
+/* MRG32k3a RNG */
+
+/* Base generator for MRG32k3a                                              */
+QUALIFIERS unsigned long long __curand_umad(GCC_UNUSED_PARAMETER unsigned int a, GCC_UNUSED_PARAMETER unsigned int b, GCC_UNUSED_PARAMETER unsigned long long c)
+{
+    unsigned long long r = 0;
+NV_IF_TARGET(NV_PROVIDES_SM_61,
+    asm("mad.wide.u32 %0, %1, %2, %3;"
+        : "=l"(r) : "r"(a), "r"(b), "l"(c));
+)
+    return r;
+}
+QUALIFIERS unsigned long long __curand_umul(GCC_UNUSED_PARAMETER unsigned int a, GCC_UNUSED_PARAMETER unsigned int b)
+{
+    unsigned long long r = 0;
+NV_IF_TARGET(NV_PROVIDES_SM_61,
+    asm("mul.wide.u32 %0, %1, %2;"
+        : "=l"(r) : "r"(a), "r"(b));
+)
+    return r;
+}
+QUALIFIERS double curand_MRG32k3a (curandStateMRG32k3a_t *state)
+{
+NV_IF_TARGET(NV_PROVIDES_SM_61,
+    const unsigned int m1  = 4294967087u;
+    const unsigned int m2  = 4294944443u;
+    const unsigned int m1c = 209u;
+    const unsigned int m2c = 22853u;
+    const unsigned int a12  = 1403580u;
+    const unsigned int a13n = 810728u;
+    const unsigned int a21  = 527612u;
+    const unsigned int a23n = 1370589u;
+
+    unsigned long long p1;
+    unsigned long long p2;
+    const unsigned long long p3 = __curand_umul(a13n, m1 - state->s1[0]);
+    p1 = __curand_umad(a12, state->s1[1], p3);
+
+    // Putting addition inside and changing umul to umad
+    // slowed this function down on GV100
+    p1 =  __curand_umul(p1 >> 32, m1c) + (p1 & 0xffffffff);
+    if (p1 >= m1) p1 -= m1;
+
+    state->s1[0] = state->s1[1]; state->s1[1] = state->s1[2]; state->s1[2] = p1;
+    const unsigned long long p4 = __curand_umul(a23n, m2 - state->s2[0]);
+    p2 = __curand_umad(a21, state->s2[2], p4);
+
+    // Putting addition inside and changing umul to umad
+    // slowed this function down on GV100
+    p2 =  __curand_umul(p2 >> 32, m2c) + (p2 & 0xffffffff);
+    p2 =  __curand_umul(p2 >> 32, m2c) + (p2 & 0xffffffff);
+    if (p2 >= m2) p2 -= m2;
+
+    state->s2[0] = state->s2[1]; state->s2[1] = state->s2[2]; state->s2[2] = p2;
+
+    const unsigned int p5 = (unsigned int)p1 - (unsigned int)p2;
+    if(p1 <= p2) return p5 + m1;
+    return p5;
+)
+NV_IF_TARGET(NV_IS_DEVICE,
+/*  nj's implementation */
+    const double m1 = 4294967087.;
+    const double m2 = 4294944443.;
+    const double a12  = 1403580.;
+    const double a13n = 810728.;
+    const double a21  = 527612.;
+    const double a23n = 1370589.;
+
+    const double rh1 =  2.3283065498378290e-010;  /* (1.0 / m1)__hi */
+    const double rl1 = -1.7354913086174288e-026;  /* (1.0 / m1)__lo */
+    const double rh2 =  2.3283188252407387e-010;  /* (1.0 / m2)__hi */
+    const double rl2 =  2.4081018096503646e-026;  /* (1.0 / m2)__lo */
+
+    double q;
+    double p1;
+    double p2;
+    p1 = a12 * state->s1[1] - a13n * state->s1[0];
+    q = trunc (fma (p1, rh1, p1 * rl1));
+    p1 -= q * m1;
+    if (p1 < 0.0) p1 += m1;
+    state->s1[0] = state->s1[1];   state->s1[1] = state->s1[2];   state->s1[2] = (unsigned int)p1;
+    p2 = a21 * state->s2[2] - a23n * state->s2[0];
+    q = trunc (fma (p2, rh2, p2 * rl2));
+    p2 -= q * m2;
+    if (p2 < 0.0) p2 += m2;
+    state->s2[0] = state->s2[1];   state->s2[1] = state->s2[2];   state->s2[2] = (unsigned int)p2;
+    if (p1 <= p2) return (p1 - p2 + m1);
+    else return (p1 - p2);
+)
+/* end nj's implementation */
+    double p1;
+    double p2;
+    double r;
+    p1 = (MRG32K3A_A12 * state->s1[1]) - (MRG32K3A_A13N * state->s1[0]);
+    p1 = curand_MRGmod(p1, MRG32K3A_MOD1);
+    if (p1 < 0.0) p1 += MRG32K3A_MOD1;
+    state->s1[0] = state->s1[1];
+    state->s1[1] = state->s1[2];
+    state->s1[2] = (unsigned int)p1;
+    p2 = (MRG32K3A_A21 * state->s2[2]) - (MRG32K3A_A23N * state->s2[0]);
+    p2 = curand_MRGmod(p2, MRG32K3A_MOD2);
+    if (p2 < 0) p2 += MRG32K3A_MOD2;
+    state->s2[0] = state->s2[1];
+    state->s2[1] = state->s2[2];
+    state->s2[2] = (unsigned int)p2;
+    r = p1 - p2;
+    if (r <= 0) r += MRG32K3A_MOD1;
+    return r;
+}
+
+
+/**
+ * \brief Return 32-bits of pseudorandomness from an MRG32k3a generator.
+ *
+ * Return 32-bits of pseudorandomness from the MRG32k3a generator in \p state,
+ * increment position of generator by one.
+ *
+ * \param state - Pointer to state to update
+ *
+ * \return 32-bits of pseudorandomness as an unsigned int, all bits valid to use.
+ */
+QUALIFIERS unsigned int curand(curandStateMRG32k3a_t *state)
+{
+    double dRet;
+    dRet = (double)curand_MRG32k3a(state)*(double)MRG32K3A_BITS_NORM;
+    return (unsigned int)dRet;
+}
+
+
+
+/**
+ * \brief Update MRG32k3a state to skip \p n elements.
+ *
+ * Update the MRG32k3a state in \p state to skip ahead \p n elements.
+ *
+ * All values of \p n are valid.  Large values require more computation and so
+ * will take more time to complete.
+ *
+ * \param n - Number of elements to skip
+ * \param state - Pointer to state to update
+ */
+QUALIFIERS void skipahead(unsigned long long n, curandStateMRG32k3a_t *state)
+{
+    unsigned int t[3][3];
+NV_IF_ELSE_TARGET(NV_IS_DEVICE,
+    curand_MRGmatPow3x3( mrg32k3aM1, t, MRG32K3A_MOD1, n);
+    curand_MRGmatVecMul3x3( t, state->s1, MRG32K3A_MOD1);
+    curand_MRGmatPow3x3(mrg32k3aM2, t, MRG32K3A_MOD2, n);
+    curand_MRGmatVecMul3x3( t, state->s2, MRG32K3A_MOD2);
+,
+    curand_MRGmatPow3x3( mrg32k3aM1Host, t, MRG32K3A_MOD1, n);
+    curand_MRGmatVecMul3x3( t, state->s1, MRG32K3A_MOD1);
+    curand_MRGmatPow3x3(mrg32k3aM2Host, t, MRG32K3A_MOD2, n);
+    curand_MRGmatVecMul3x3( t, state->s2, MRG32K3A_MOD2);
+)
+}
+
+/**
+ * \brief Update MRG32k3a state to skip ahead \p n subsequences.
+ *
+ * Update the MRG32k3a state in \p state to skip ahead \p n subsequences.  Each
+ * subsequence is \xmlonly<ph outputclass="xmlonly">2<sup>127</sup></ph>\endxmlonly
+ *
+ * \xmlonly<ph outputclass="xmlonly">2<sup>76</sup></ph>\endxmlonly elements long, so this means the function will skip ahead
+ * \xmlonly<ph outputclass="xmlonly">2<sup>67</sup></ph>\endxmlonly * n elements.
+ *
+ * Valid values of \p n are 0 to \xmlonly<ph outputclass="xmlonly">2<sup>51</sup></ph>\endxmlonly.  Note \p n will be masked to 51 bits
+ *
+ * \param n - Number of subsequences to skip
+ * \param state - Pointer to state to update
+ */
+QUALIFIERS void skipahead_subsequence(unsigned long long n, curandStateMRG32k3a_t *state)
+{
+    unsigned int t[3][3];
+NV_IF_ELSE_TARGET(NV_IS_DEVICE,
+    curand_MRGmatPow3x3( mrg32k3aM1SubSeq, t, MRG32K3A_MOD1, n);
+    curand_MRGmatVecMul3x3( t, state->s1, MRG32K3A_MOD1);
+    curand_MRGmatPow3x3( mrg32k3aM2SubSeq, t, MRG32K3A_MOD2, n);
+    curand_MRGmatVecMul3x3( t, state->s2, MRG32K3A_MOD2);
+,
+    curand_MRGmatPow3x3( mrg32k3aM1SubSeqHost, t, MRG32K3A_MOD1, n);
+    curand_MRGmatVecMul3x3( t, state->s1, MRG32K3A_MOD1);
+    curand_MRGmatPow3x3( mrg32k3aM2SubSeqHost, t, MRG32K3A_MOD2, n);
+    curand_MRGmatVecMul3x3( t, state->s2, MRG32K3A_MOD2);
+)
+}
+
+/**
+ * \brief Update MRG32k3a state to skip ahead \p n sequences.
+ *
+ * Update the MRG32k3a state in \p state to skip ahead \p n sequences.  Each
+ * sequence is \xmlonly<ph outputclass="xmlonly">2<sup>127</sup></ph>\endxmlonly elements long, so this means the function will skip ahead
+ * \xmlonly<ph outputclass="xmlonly">2<sup>127</sup></ph>\endxmlonly * n elements.
+ *
+ * All values of \p n are valid.  Large values require more computation and so
+ * will take more time to complete.
+ *
+ * \param n - Number of sequences to skip
+ * \param state - Pointer to state to update
+ */
+QUALIFIERS void skipahead_sequence(unsigned long long n, curandStateMRG32k3a_t *state)
+{
+    unsigned int t[3][3];
+NV_IF_ELSE_TARGET(NV_IS_DEVICE,
+    curand_MRGmatPow3x3( mrg32k3aM1Seq, t, MRG32K3A_MOD1, n);
+    curand_MRGmatVecMul3x3( t, state->s1, MRG32K3A_MOD1);
+    curand_MRGmatPow3x3(  mrg32k3aM2Seq, t, MRG32K3A_MOD2, n);
+    curand_MRGmatVecMul3x3( t, state->s2, MRG32K3A_MOD2);
+,
+    curand_MRGmatPow3x3( mrg32k3aM1SeqHost, t, MRG32K3A_MOD1, n);
+    curand_MRGmatVecMul3x3( t, state->s1, MRG32K3A_MOD1);
+    curand_MRGmatPow3x3(  mrg32k3aM2SeqHost, t, MRG32K3A_MOD2, n);
+    curand_MRGmatVecMul3x3( t, state->s2, MRG32K3A_MOD2);
+)
+}
+
+
+/**
+ * \brief Initialize MRG32k3a state.
+ *
+ * Initialize MRG32k3a state in \p state with the given \p seed, \p subsequence,
+ * and \p offset.
+ *
+ * All input values of \p seed, \p subsequence, and \p offset are legal.
+ * \p subsequence will be truncated to 51 bits to avoid running into the next sequence
+ *
+ * A value of 0 for \p seed sets the state to the values of the original
+ * published version of the \p MRG32k3a algorithm.
+ *
+ * \param seed - Arbitrary bits to use as a seed
+ * \param subsequence - Subsequence to start at
+ * \param offset - Absolute offset into sequence
+ * \param state - Pointer to state to initialize
+ */
+QUALIFIERS void curand_init(unsigned long long seed,
+                            unsigned long long subsequence,
+                            unsigned long long offset,
+                            curandStateMRG32k3a_t *state)
+{
+    int i;
+    for ( i=0; i<3; i++ ) {
+        state->s1[i] = 12345u;
+        state->s2[i] = 12345u;
+    }
+    if (seed != 0ull) {
+        unsigned int x1 = ((unsigned int)seed) ^ 0x55555555UL;
+        unsigned int x2 = (unsigned int)((seed >> 32) ^ 0xAAAAAAAAUL);
+        state->s1[0] = (unsigned int)curand_MRGmodMul(x1, state->s1[0], MRG32K3A_MOD1);
+        state->s1[1] = (unsigned int)curand_MRGmodMul(x2, state->s1[1], MRG32K3A_MOD1);
+        state->s1[2] = (unsigned int)curand_MRGmodMul(x1, state->s1[2], MRG32K3A_MOD1);
+        state->s2[0] = (unsigned int)curand_MRGmodMul(x2, state->s2[0], MRG32K3A_MOD2);
+        state->s2[1] = (unsigned int)curand_MRGmodMul(x1, state->s2[1], MRG32K3A_MOD2);
+        state->s2[2] = (unsigned int)curand_MRGmodMul(x2, state->s2[2], MRG32K3A_MOD2);
+    }
+    skipahead_subsequence( subsequence, state );
+    skipahead( offset, state );
+    state->boxmuller_flag = 0;
+    state->boxmuller_flag_double = 0;
+    state->boxmuller_extra = 0.f;
+    state->boxmuller_extra_double = 0.;
+}
+
+/**
+ * \brief Update Sobol32 state to skip \p n elements.
+ *
+ * Update the Sobol32 state in \p state to skip ahead \p n elements.
+ *
+ * All values of \p n are valid.
+ *
+ * \param n - Number of elements to skip
+ * \param state - Pointer to state to update
+ */
+template <typename T>
+QUALIFIERS
+typename CURAND_STD::enable_if<CURAND_STD::is_same<curandStateSobol32_t*, T>::value || CURAND_STD::is_same<curandStateScrambledSobol32_t*, T>::value>::type
+skipahead(unsigned int n, T state)
+{
+    unsigned int i_gray;
+    state->x = state->c;
+    state->i += n;
+    /* Convert state->i to gray code */
+    i_gray = state->i ^ (state->i >> 1);
+    for(unsigned int k = 0; k < 32; k++) {
+        if(i_gray & (1 << k)) {
+            state->x ^= state->direction_vectors[k];
+        }
+    }
+    return;
+}
+
+/**
+ * \brief Update Sobol64 state to skip \p n elements.
+ *
+ * Update the Sobol64 state in \p state to skip ahead \p n elements.
+ *
+ * All values of \p n are valid.
+ *
+ * \param n - Number of elements to skip
+ * \param state - Pointer to state to update
+ */
+template <typename T>
+QUALIFIERS
+typename CURAND_STD::enable_if<CURAND_STD::is_same<curandStateSobol64_t*, T>::value || CURAND_STD::is_same<curandStateScrambledSobol64_t*, T>::value>::type
+skipahead(unsigned long long n, T state)
+{
+    unsigned long long i_gray;
+    state->x = state->c;
+    state->i += n;
+    /* Convert state->i to gray code */
+    i_gray = state->i ^ (state->i >> 1);
+    for(unsigned k = 0; k < 64; k++) {
+        if(i_gray & (1ULL << k)) {
+            state->x ^= state->direction_vectors[k];
+        }
+    }
+    return;
+}
+
+/**
+ * \brief Initialize Sobol32 state.
+ *
+ * Initialize Sobol32 state in \p state with the given \p direction \p vectors and
+ * \p offset.
+ *
+ * The direction vector is a device pointer to an array of 32 unsigned ints.
+ * All input values of \p offset are legal.
+ *
+ * \param direction_vectors - Pointer to array of 32 unsigned ints representing the
+ * direction vectors for the desired dimension
+ * \param offset - Absolute offset into sequence
+ * \param state - Pointer to state to initialize
+ */
+QUALIFIERS void curand_init(curandDirectionVectors32_t direction_vectors,
+                                            unsigned int offset,
+                                            curandStateSobol32_t *state)
+{
+    state->i = 0;
+    state->c = 0;
+    for(int i = 0; i < 32; i++) {
+        state->direction_vectors[i] = direction_vectors[i];
+    }
+    state->x = 0;
+    skipahead<curandStateSobol32_t *>(offset, state);
+}
+/**
+ * \brief Initialize Scrambled Sobol32 state.
+ *
+ * Initialize Sobol32 state in \p state with the given \p direction \p vectors and
+ * \p offset.
+ *
+ * The direction vector is a device pointer to an array of 32 unsigned ints.
+ * All input values of \p offset are legal.
+ *
+ * \param direction_vectors - Pointer to array of 32 unsigned ints representing the
+ direction vectors for the desired dimension
+ * \param scramble_c Scramble constant
+ * \param offset - Absolute offset into sequence
+ * \param state - Pointer to state to initialize
+ */
+QUALIFIERS void curand_init(curandDirectionVectors32_t direction_vectors,
+                                            unsigned int scramble_c,
+                                            unsigned int offset,
+                                            curandStateScrambledSobol32_t *state)
+{
+    state->i = 0;
+    state->c = scramble_c;
+    for(int i = 0; i < 32; i++) {
+        state->direction_vectors[i] = direction_vectors[i];
+    }
+    state->x = state->c;
+    skipahead<curandStateScrambledSobol32_t *>(offset, state);
+}
+
+QUALIFIERS int __curand_find_trailing_zero(unsigned int x)
+{
+NV_IF_ELSE_TARGET(NV_IS_DEVICE,
+    int y = __ffs(~x);
+    if(y)
+        return y - 1;
+    return 31;
+,
+    int i = 1;
+    while(x & 1) {
+        i++;
+        x >>= 1;
+    }
+    i = i - 1;
+    return i == 32 ? 31 : i;
+)
+}
+
+QUALIFIERS int __curand_find_trailing_zero(unsigned long long x)
+{
+NV_IF_ELSE_TARGET(NV_IS_DEVICE,
+    int y = __ffsll(~x);
+    if(y)
+        return y - 1;
+    return 63;
+,
+    int i = 1;
+    while(x & 1) {
+        i++;
+        x >>= 1;
+    }
+    i = i - 1;
+    return i == 64 ? 63 : i;
+)
+}
+
+/**
+ * \brief Initialize Sobol64 state.
+ *
+ * Initialize Sobol64 state in \p state with the given \p direction \p vectors and
+ * \p offset.
+ *
+ * The direction vector is a device pointer to an array of 64 unsigned long longs.
+ * All input values of \p offset are legal.
+ *
+ * \param direction_vectors - Pointer to array of 64 unsigned long longs representing the
+ direction vectors for the desired dimension
+ * \param offset - Absolute offset into sequence
+ * \param state - Pointer to state to initialize
+ */
+QUALIFIERS void curand_init(curandDirectionVectors64_t direction_vectors,
+                                            unsigned long long offset,
+                                            curandStateSobol64_t *state)
+{
+    state->i = 0;
+    state->c = 0;
+    for(int i = 0; i < 64; i++) {
+        state->direction_vectors[i] = direction_vectors[i];
+    }
+    state->x = 0;
+    skipahead<curandStateSobol64_t *>(offset, state);
+}
+
+/**
+ * \brief Initialize Scrambled Sobol64 state.
+ *
+ * Initialize Sobol64 state in \p state with the given \p direction \p vectors and
+ * \p offset.
+ *
+ * The direction vector is a device pointer to an array of 64 unsigned long longs.
+ * All input values of \p offset are legal.
+ *
+ * \param direction_vectors - Pointer to array of 64 unsigned long longs representing the
+ direction vectors for the desired dimension
+ * \param scramble_c Scramble constant
+ * \param offset - Absolute offset into sequence
+ * \param state - Pointer to state to initialize
+ */
+QUALIFIERS void curand_init(curandDirectionVectors64_t direction_vectors,
+                                            unsigned long long scramble_c,
+                                            unsigned long long offset,
+                                            curandStateScrambledSobol64_t *state)
+{
+    state->i = 0;
+    state->c = scramble_c;
+    for(int i = 0; i < 64; i++) {
+        state->direction_vectors[i] = direction_vectors[i];
+    }
+    state->x = state->c;
+    skipahead<curandStateScrambledSobol64_t *>(offset, state);
+}
+
+/**
+ * \brief Return 32-bits of quasirandomness from a Sobol32 generator.
+ *
+ * Return 32-bits of quasirandomness from the Sobol32 generator in \p state,
+ * increment position of generator by one.
+ *
+ * \param state - Pointer to state to update
+ *
+ * \return 32-bits of quasirandomness as an unsigned int, all bits valid to use.
+ */
+
+QUALIFIERS unsigned int curand(curandStateSobol32_t * state)
+{
+    /* Moving from i to i+1 element in gray code is flipping one bit,
+       the trailing zero bit of i
+    */
+    unsigned int res = state->x;
+    state->x ^= state->direction_vectors[__curand_find_trailing_zero(state->i)];
+    state->i ++;
+    return res;
+}
+
+/**
+ * \brief Return 32-bits of quasirandomness from a scrambled Sobol32 generator.
+ *
+ * Return 32-bits of quasirandomness from the scrambled Sobol32 generator in \p state,
+ * increment position of generator by one.
+ *
+ * \param state - Pointer to state to update
+ *
+ * \return 32-bits of quasirandomness as an unsigned int, all bits valid to use.
+ */
+
+QUALIFIERS unsigned int curand(curandStateScrambledSobol32_t * state)
+{
+    /* Moving from i to i+1 element in gray code is flipping one bit,
+       the trailing zero bit of i
+    */
+    unsigned int res = state->x;
+    state->x ^= state->direction_vectors[__curand_find_trailing_zero(state->i)];
+    state->i ++;
+    return res;
+}
+
+/**
+ * \brief Return 64-bits of quasirandomness from a Sobol64 generator.
+ *
+ * Return 64-bits of quasirandomness from the Sobol64 generator in \p state,
+ * increment position of generator by one.
+ *
+ * \param state - Pointer to state to update
+ *
+ * \return 64-bits of quasirandomness as an unsigned long long, all bits valid to use.
+ */
+
+QUALIFIERS unsigned long long curand(curandStateSobol64_t * state)
+{
+    /* Moving from i to i+1 element in gray code is flipping one bit,
+       the trailing zero bit of i
+    */
+    unsigned long long res = state->x;
+    state->x ^= state->direction_vectors[__curand_find_trailing_zero(state->i)];
+    state->i ++;
+    return res;
+}
+
+/**
+ * \brief Return 64-bits of quasirandomness from a scrambled Sobol64 generator.
+ *
+ * Return 64-bits of quasirandomness from the scrambled Sobol32 generator in \p state,
+ * increment position of generator by one.
+ *
+ * \param state - Pointer to state to update
+ *
+ * \return 64-bits of quasirandomness as an unsigned long long, all bits valid to use.
+ */
+
+QUALIFIERS unsigned long long curand(curandStateScrambledSobol64_t * state)
+{
+    /* Moving from i to i+1 element in gray code is flipping one bit,
+       the trailing zero bit of i
+    */
+    unsigned long long res = state->x;
+    state->x ^= state->direction_vectors[__curand_find_trailing_zero(state->i)];
+    state->i ++;
+    return res;
+}
+
+#include "curand_uniform.h"
+#include "curand_normal.h"
+#include "curand_lognormal.h"
+#include "curand_poisson.h"
+#include "curand_discrete2.h"
+
+__device__ static inline unsigned int *__get_precalculated_matrix(int n)
+{
+    if(n == 0) {
+        return precalc_xorwow_matrix[n];
+    }
+    if(n == 2) {
+        return precalc_xorwow_offset_matrix[n];
+    }
+    return precalc_xorwow_matrix[n];
+}
+
+#ifndef __CUDACC_RTC__
+__host__ static inline unsigned int *__get_precalculated_matrix_host(int n)
+{
+    if(n == 1) {
+        return precalc_xorwow_matrix_host[n];
+    }
+    if(n == 3) {
+        return precalc_xorwow_offset_matrix_host[n];
+    }
+    return precalc_xorwow_matrix_host[n];
+}
+#endif // #ifndef __CUDACC_RTC__
+
+__device__ static inline unsigned int *__get_mrg32k3a_matrix(int n)
+{
+    if(n == 0) {
+        return mrg32k3aM1[n][0];
+    }
+    if(n == 2) {
+        return mrg32k3aM2[n][0];
+    }
+    if(n == 4) {
+        return mrg32k3aM1SubSeq[n][0];
+    }
+    if(n == 6) {
+        return mrg32k3aM2SubSeq[n][0];
+    }
+    if(n == 8) {
+        return mrg32k3aM1Seq[n][0];
+    }
+    if(n == 10) {
+        return mrg32k3aM2Seq[n][0];
+    }
+    return mrg32k3aM1[n][0];
+}
+
+#ifndef __CUDACC_RTC__
+__host__ static inline unsigned int *__get_mrg32k3a_matrix_host(int n)
+{
+    if(n == 1) {
+        return mrg32k3aM1Host[n][0];
+    }
+    if(n == 3) {
+        return mrg32k3aM2Host[n][0];
+    }
+    if(n == 5) {
+        return mrg32k3aM1SubSeqHost[n][0];
+    }
+    if(n == 7) {
+        return mrg32k3aM2SubSeqHost[n][0];
+    }
+    if(n == 9) {
+        return mrg32k3aM1SeqHost[n][0];
+    }
+    if(n == 11) {
+        return mrg32k3aM2SeqHost[n][0];
+    }
+    return mrg32k3aM1Host[n][0];
+}
+
+__host__ static inline double *__get__cr_lgamma_table_host(void) {
+    return __cr_lgamma_table;
+}
+#endif // #ifndef __CUDACC_RTC__
+
+/** @} */
+
+#endif // !defined(CURAND_KERNEL_H_)

infer_4_37_2/lib/python3.10/site-packages/nvidia/curand/include/curand_mtgp32_host.h

@@ -0,0 +1,516 @@
+/*
+ * Copyright 2010-2014 NVIDIA Corporation.  All rights reserved.
+ *
+ * NOTICE TO LICENSEE:
+ *
+ * This source code and/or documentation ("Licensed Deliverables") are
+ * subject to NVIDIA intellectual property rights under U.S. and
+ * international Copyright laws.
+ *
+ * These Licensed Deliverables contained herein is PROPRIETARY and
+ * CONFIDENTIAL to NVIDIA and is being provided under the terms and
+ * conditions of a form of NVIDIA software license agreement by and
+ * between NVIDIA and Licensee ("License Agreement") or electronically
+ * accepted by Licensee.  Notwithstanding any terms or conditions to
+ * the contrary in the License Agreement, reproduction or disclosure
+ * of the Licensed Deliverables to any third party without the express
+ * written consent of NVIDIA is prohibited.
+ *
+ * NOTWITHSTANDING ANY TERMS OR CONDITIONS TO THE CONTRARY IN THE
+ * LICENSE AGREEMENT, NVIDIA MAKES NO REPRESENTATION ABOUT THE
+ * SUITABILITY OF THESE LICENSED DELIVERABLES FOR ANY PURPOSE.  IT IS
+ * PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY OF ANY KIND.
+ * NVIDIA DISCLAIMS ALL WARRANTIES WITH REGARD TO THESE LICENSED
+ * DELIVERABLES, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY,
+ * NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE.
+ * NOTWITHSTANDING ANY TERMS OR CONDITIONS TO THE CONTRARY IN THE
+ * LICENSE AGREEMENT, IN NO EVENT SHALL NVIDIA BE LIABLE FOR ANY
+ * SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, OR ANY
+ * DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+ * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
+ * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
+ * OF THESE LICENSED DELIVERABLES.
+ *
+ * U.S. Government End Users.  These Licensed Deliverables are a
+ * "commercial item" as that term is defined at 48 C.F.R. 2.101 (OCT
+ * 1995), consisting of "commercial computer software" and "commercial
+ * computer software documentation" as such terms are used in 48
+ * C.F.R. 12.212 (SEPT 1995) and is provided to the U.S. Government
+ * only as a commercial end item.  Consistent with 48 C.F.R.12.212 and
+ * 48 C.F.R. 227.7202-1 through 227.7202-4 (JUNE 1995), all
+ * U.S. Government End Users acquire the Licensed Deliverables with
+ * only those rights set forth herein.
+ *
+ * Any use of the Licensed Deliverables in individual and commercial
+ * software must include, in the user documentation and internal
+ * comments to the code, the above Disclaimer and U.S. Government End
+ * Users Notice.
+ */
+
+/*
+ * curand_mtgp32_host.h
+ *
+ *
+ * MTGP32-11213
+ *
+ * Mersenne Twister RNG for the GPU
+ *
+ * The period of generated integers is 2<sup>11213</sup>-1.
+ *
+ * This code generates 32-bit unsigned integers, and
+ * single precision floating point numbers uniformly distributed
+ * in the range [1, 2). (float r; 1.0 <= r < 2.0)
+ */
+
+/*
+ * Copyright (c) 2009, 2010 Mutsuo Saito, Makoto Matsumoto and Hiroshima
+ * University.  All rights reserved.
+ * Copyright (c) 2011 Mutsuo Saito, Makoto Matsumoto, Hiroshima
+ * University and University of Tokyo.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ *       copyright notice, this list of conditions and the following
+ *       disclaimer in the documentation and/or other materials provided
+ *       with the distribution.
+ *     * Neither the name of the Hiroshima University nor the names of
+ *       its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written
+ *       permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#if !defined CURAND_MTGP32_HOST_H
+#define CURAND_MTGP32_HOST_H
+
+#if !defined(QUALIFIERS)
+#define QUALIFIERS static inline __device__
+#endif
+
+#include <cuda_runtime.h>
+#include <stdlib.h>
+#include <memory.h>
+#include <string.h>
+#include "curand.h"
+#include "curand_mtgp32.h"
+#include "curand_mtgp32dc_p_11213.h"
+
+
+/**
+ * \addtogroup DEVICE Device API
+ *
+ * @{
+ */
+
+static const unsigned int non_zero = 0x4d544750;
+
+/*
+ * This function represents a function used in the initialization
+ * by mtgp32_init_by_array() and mtgp32_init_by_str().
+ * @param[in] x 32-bit integer
+ * @return 32-bit integer
+ */
+static __forceinline__ unsigned int ini_func1(unsigned int x) {
+    return (x ^ (x >> 27)) * (1664525);
+}
+
+/*
+ * This function represents a function used in the initialization
+ * by mtgp32_init_by_array() and mtgp32_init_by_str().
+ * @param[in] x 32-bit integer
+ * @return 32-bit integer
+ */
+static __forceinline__ unsigned int ini_func2(unsigned int x) {
+    return (x ^ (x >> 27)) * (1566083941);
+}
+
+/*
+ * This function initializes the internal state array with a 32-bit
+ * integer seed. The allocated memory should be freed by calling
+ * mtgp32_free(). \b para should be one of the elements in the
+ * parameter table (mtgp32-param-ref.c).
+ *
+ * This function is call by cuda program, because cuda program uses
+ * another structure and another allocation method.
+ *
+ * @param[out] array MTGP internal status vector.
+ * @param[in] para parameter structure
+ * @param[in] seed a 32-bit integer used as the seed.
+ */
+static __forceinline__ __host__
+void mtgp32_init_state(unsigned int state[],
+                       const mtgp32_params_fast_t *para, unsigned int seed) {
+    int i;
+    int size = para->mexp / 32 + 1;
+    unsigned int hidden_seed;
+    unsigned int tmp;
+    hidden_seed = para->tbl[4] ^ (para->tbl[8] << 16);
+    tmp = hidden_seed;
+    tmp += tmp >> 16;
+    tmp += tmp >> 8;
+    memset(state, tmp & 0xff, sizeof(unsigned int) * size);
+    state[0] = seed;
+    state[1] = hidden_seed;
+    for (i = 1; i < size; i++) {
+        state[i] ^= (1812433253) * (state[i - 1] ^ (state[i - 1] >> 30)) + i;
+    }
+}
+
+/*
+ * This function initializes the internal state array
+ * with a 32-bit integer array. \b para should be one of the elements in
+ * the parameter table (mtgp32-param-ref.c).
+ *
+ * @param[out] mtgp32 MTGP structure.
+ * @param[in] para parameter structure
+ * @param[in] array a 32-bit integer array used as a seed.
+ * @param[in] length length of the array.
+ * @return CURAND_STATUS_SUCCESS
+ */
+static __forceinline__ __host__
+int mtgp32_init_by_array(unsigned int state[],
+                         const mtgp32_params_fast_t *para,
+                         unsigned int *array, int length) {
+    int i, j, count;
+    unsigned int r;
+    int lag;
+    int mid;
+    int size = para->mexp / 32 + 1;
+    unsigned int hidden_seed;
+    unsigned int tmp;
+
+    if (size >= 623) {
+    lag = 11;
+    } else if (size >= 68) {
+    lag = 7;
+    } else if (size >= 39) {
+    lag = 5;
+    } else {
+    lag = 3;
+    }
+    mid = (size - lag) / 2;
+
+    hidden_seed = para->tbl[4] ^ (para->tbl[8] << 16);
+    tmp = hidden_seed;
+    tmp += tmp >> 16;
+    tmp += tmp >> 8;
+    memset(state, tmp & 0xff, sizeof(unsigned int) * size);
+    state[0] = hidden_seed;
+
+    if (length + 1 > size) {
+    count = length + 1;
+    } else {
+    count = size;
+    }
+    r = ini_func1(state[0] ^ state[mid] ^ state[size - 1]);
+    state[mid] += r;
+    r += length;
+    state[(mid + lag) % size] += r;
+    state[0] = r;
+    i = 1;
+    count--;
+    for (i = 1, j = 0; (j < count) && (j < length); j++) {
+    r = ini_func1(state[i] ^ state[(i + mid) % size]
+              ^ state[(i + size - 1) % size]);
+    state[(i + mid) % size] += r;
+    r += array[j] + i;
+    state[(i + mid + lag) % size] += r;
+    state[i] = r;
+    i = (i + 1) % size;
+    }
+    for (; j < count; j++) {
+    r = ini_func1(state[i] ^ state[(i + mid) % size]
+              ^ state[(i + size - 1) % size]);
+    state[(i + mid) % size] += r;
+    r += i;
+    state[(i + mid + lag) % size] += r;
+    state[i] = r;
+    i = (i + 1) % size;
+    }
+    for (j = 0; j < size; j++) {
+    r = ini_func2(state[i] + state[(i + mid) % size]
+              + state[(i + size - 1) % size]);
+    state[(i + mid) % size] ^= r;
+    r -= i;
+    state[(i + mid + lag) % size] ^= r;
+    state[i] = r;
+    i = (i + 1) % size;
+    }
+    if (state[size - 1] == 0) {
+    state[size - 1] = non_zero;
+    }
+    return 0;
+}
+
+/*
+ * This function initializes the internal state array
+ * with a character array. \b para should be one of the elements in
+ * the parameter table (mtgp32-param-ref.c).
+ * This is the same algorithm with mtgp32_init_by_array(), but hope to
+ * be more useful.
+ *
+ * @param[out] mtgp32 MTGP structure.
+ * @param[in] para parameter structure
+ * @param[in] array a character array used as a seed. (terminated by zero.)
+ * @return memory allocation result. if 0 then O.K.
+ */
+static __forceinline__ __host__
+int mtgp32_init_by_str(unsigned int state[],
+                       const mtgp32_params_fast_t *para, unsigned char *array) {
+    int i, j, count;
+    unsigned int r;
+    int lag;
+    int mid;
+    int size = para->mexp / 32 + 1;
+    int length = (unsigned int)strlen((char *)array);
+    unsigned int hidden_seed;
+    unsigned int tmp;
+
+    if (size >= 623) {
+    lag = 11;
+    } else if (size >= 68) {
+    lag = 7;
+    } else if (size >= 39) {
+    lag = 5;
+    } else {
+    lag = 3;
+    }
+    mid = (size - lag) / 2;
+
+    hidden_seed = para->tbl[4] ^ (para->tbl[8] << 16);
+    tmp = hidden_seed;
+    tmp += tmp >> 16;
+    tmp += tmp >> 8;
+    memset(state, tmp & 0xff, sizeof(unsigned int) * size);
+    state[0] = hidden_seed;
+
+    if (length + 1 > size) {
+    count = length + 1;
+    } else {
+    count = size;
+    }
+    r = ini_func1(state[0] ^ state[mid] ^ state[size - 1]);
+    state[mid] += r;
+    r += length;
+    state[(mid + lag) % size] += r;
+    state[0] = r;
+    i = 1;
+    count--;
+    for (i = 1, j = 0; (j < count) && (j < length); j++) {
+    r = ini_func1(state[i] ^ state[(i + mid) % size]
+              ^ state[(i + size - 1) % size]);
+    state[(i + mid) % size] += r;
+    r += array[j] + i;
+    state[(i + mid + lag) % size] += r;
+    state[i] = r;
+    i = (i + 1) % size;
+    }
+    for (; j < count; j++) {
+    r = ini_func1(state[i] ^ state[(i + mid) % size]
+              ^ state[(i + size - 1) % size]);
+    state[(i + mid) % size] += r;
+    r += i;
+    state[(i + mid + lag) % size] += r;
+    state[i] = r;
+    i = (i + 1) % size;
+    }
+    for (j = 0; j < size; j++) {
+    r = ini_func2(state[i] + state[(i + mid) % size]
+              + state[(i + size - 1) % size]);
+    state[(i + mid) % size] ^= r;
+    r -= i;
+    state[(i + mid + lag) % size] ^= r;
+    state[i] = r;
+    i = (i + 1) % size;
+    }
+    if (state[size - 1] == 0) {
+    state[size - 1] = non_zero;
+    }
+    return 0;
+}
+
+template<typename ParamsType>
+static __forceinline__ __host__
+curandStatus_t curandMakeMTGP32ConstantsImpl(const mtgp32_params_fast_t params[], ParamsType * p, const int block_num)
+{
+    const int size1 = sizeof(unsigned int) * block_num;
+    const int size2 = sizeof(unsigned int) * block_num * TBL_SIZE;
+    unsigned int *h_pos_tbl;
+    unsigned int *h_sh1_tbl;
+    unsigned int *h_sh2_tbl;
+    unsigned int *h_param_tbl;
+    unsigned int *h_temper_tbl;
+    unsigned int *h_single_temper_tbl;
+    unsigned int *h_mask;
+    curandStatus_t status = CURAND_STATUS_SUCCESS;
+
+    h_pos_tbl = (unsigned int *)malloc(size1);
+    h_sh1_tbl = (unsigned int *)malloc(size1);
+    h_sh2_tbl = (unsigned int *)malloc(size1);
+    h_param_tbl = (unsigned int *)malloc(size2);
+    h_temper_tbl = (unsigned int *)malloc(size2);
+    h_single_temper_tbl = (unsigned int *)malloc(size2);
+    h_mask = (unsigned int *)malloc(sizeof(unsigned int));
+    if (h_pos_tbl == NULL
+	    || h_sh1_tbl == NULL
+	    || h_sh2_tbl == NULL
+	    || h_param_tbl == NULL
+	    || h_temper_tbl == NULL
+	    || h_single_temper_tbl == NULL
+	    || h_mask == NULL) {
+        if (h_pos_tbl != NULL) free(h_pos_tbl);
+        if (h_sh1_tbl != NULL) free(h_sh1_tbl);
+        if (h_sh2_tbl != NULL) free(h_sh2_tbl);
+        if (h_param_tbl != NULL) free(h_param_tbl);
+        if (h_temper_tbl != NULL) free(h_temper_tbl);
+        if (h_single_temper_tbl != NULL) free(h_single_temper_tbl);
+        if (h_mask != NULL) free(h_mask);
+        status = CURAND_STATUS_ALLOCATION_FAILED;
+    } else {
+
+        h_mask[0] = params[0].mask;
+        for (int i = 0; i < block_num; i++) {
+	        h_pos_tbl[i] = params[i].pos;
+	        h_sh1_tbl[i] = params[i].sh1;
+	        h_sh2_tbl[i] = params[i].sh2;
+	        for (int j = 0; j < TBL_SIZE; j++) {
+	            h_param_tbl[i * TBL_SIZE + j] = params[i].tbl[j];
+	            h_temper_tbl[i * TBL_SIZE + j] = params[i].tmp_tbl[j];
+	            h_single_temper_tbl[i * TBL_SIZE + j] = params[i].flt_tmp_tbl[j];
+	        }
+        }
+        if (cudaMemcpy( p->pos_tbl,
+                        h_pos_tbl, size1, cudaMemcpyHostToDevice) != cudaSuccess)
+        {
+            status = CURAND_STATUS_INITIALIZATION_FAILED;
+        } else
+        if (cudaMemcpy( p->sh1_tbl,
+                        h_sh1_tbl, size1, cudaMemcpyHostToDevice) != cudaSuccess)
+        {
+            status = CURAND_STATUS_INITIALIZATION_FAILED;
+        } else
+        if (cudaMemcpy( p->sh2_tbl,
+                        h_sh2_tbl, size1, cudaMemcpyHostToDevice) != cudaSuccess)
+        {
+            status = CURAND_STATUS_INITIALIZATION_FAILED;
+        } else
+        if (cudaMemcpy( p->param_tbl,
+                        h_param_tbl, size2, cudaMemcpyHostToDevice) != cudaSuccess)
+        {
+            status = CURAND_STATUS_INITIALIZATION_FAILED;
+        } else
+        if (cudaMemcpy( p->temper_tbl,
+                        h_temper_tbl, size2, cudaMemcpyHostToDevice) != cudaSuccess)
+        {
+            status = CURAND_STATUS_INITIALIZATION_FAILED;
+        } else
+        if (cudaMemcpy( p->single_temper_tbl,
+                        h_single_temper_tbl, size2, cudaMemcpyHostToDevice) != cudaSuccess)
+        {
+            status = CURAND_STATUS_INITIALIZATION_FAILED;
+        } else
+        if (cudaMemcpy( p->mask,
+                        h_mask, sizeof(unsigned int), cudaMemcpyHostToDevice) != cudaSuccess)
+        {
+            status = CURAND_STATUS_INITIALIZATION_FAILED;
+        }
+    }
+    if (h_pos_tbl != NULL) free(h_pos_tbl);
+    if (h_sh1_tbl != NULL) free(h_sh1_tbl);
+    if (h_sh2_tbl != NULL) free(h_sh2_tbl);
+    if (h_param_tbl != NULL) free(h_param_tbl);
+    if (h_temper_tbl != NULL) free(h_temper_tbl);
+    if (h_single_temper_tbl != NULL)free(h_single_temper_tbl);
+    if (h_mask != NULL) free(h_mask);
+    return status;
+}
+
+/**
+ * \brief Set up constant parameters for the mtgp32 generator
+ *
+ * This host-side helper function re-organizes CURAND_NUM_MTGP32_PARAMS sets of
+ * generator parameters for use by kernel functions and copies the
+ * result to the specified location in device memory.
+ *
+ * \param params - Pointer to an array of type mtgp32_params_fast_t in host memory
+ * \param p - pointer to a structure of type mtgp32_kernel_params_t in device memory.
+ *
+ * \return
+ * - CURAND_STATUS_ALLOCATION_FAILED if host memory could not be allocated
+ * - CURAND_STATUS_INITIALIZATION_FAILED if the copy to device memory failed
+ * - CURAND_STATUS_SUCCESS otherwise
+ */
+static __forceinline__ __host__
+curandStatus_t curandMakeMTGP32Constants(const mtgp32_params_fast_t params[], mtgp32_kernel_params_t * p)
+{
+    return curandMakeMTGP32ConstantsImpl(params, p, CURAND_NUM_MTGP32_PARAMS);
+}
+
+/**
+ * \brief Set up initial states for the mtgp32 generator
+ *
+ * This host-side helper function initializes a number of states (one parameter set per state) for
+ * an mtgp32 generator. To accomplish this it allocates a state array in host memory,
+ * initializes that array, and copies the result to device memory.
+ *
+ * \param s - pointer to an array of states in device memory
+ * \param params - Pointer to an array of type mtgp32_params_fast_t in host memory
+ * \param k - pointer to a structure of type mtgp32_kernel_params_t in device memory
+ * \param n - number of parameter sets/states to initialize
+ * \param seed - seed value
+ *
+ * \return
+ * - CURAND_STATUS_ALLOCATION_FAILED if host memory state could not be allocated
+ * - CURAND_STATUS_INITIALIZATION_FAILED if the copy to device memory failed
+ * - CURAND_STATUS_SUCCESS otherwise
+ */
+static __forceinline__ __host__
+curandStatus_t CURANDAPI curandMakeMTGP32KernelState(curandStateMtgp32_t *s,
+                                                     mtgp32_params_fast_t params[],
+                                                     mtgp32_kernel_params_t *k,
+                                                     int n,
+                                                     unsigned long long seed)
+{
+    int i;
+    curandStatus_t status = CURAND_STATUS_SUCCESS;
+    curandStateMtgp32_t *h_status =(curandStateMtgp32_t *) malloc(sizeof(curandStateMtgp32_t) * n);
+    if (h_status == NULL) {
+        status = CURAND_STATUS_ALLOCATION_FAILED;
+    } else {
+        seed = seed ^ (seed >> 32);
+        for (i = 0; i < n; i++) {
+            mtgp32_init_state(&(h_status[i].s[0]), &params[i],(unsigned int)seed + i + 1);
+            h_status[i].offset = 0;
+            h_status[i].pIdx = i;
+            h_status[i].k = k;
+        }
+        if (cudaMemcpy(s, h_status,
+                       sizeof(curandStateMtgp32_t) * n,
+                       cudaMemcpyHostToDevice) != cudaSuccess) {
+            status = CURAND_STATUS_INITIALIZATION_FAILED;
+        }
+     }
+    free(h_status);
+    return status;
+}
+
+/** @} */
+
+#endif
+
+

infer_4_37_2/lib/python3.10/site-packages/nvidia/curand/include/curand_mtgp32_kernel.h

@@ -0,0 +1,386 @@
+/*
+ * Copyright 2010-2014 NVIDIA Corporation.  All rights reserved.
+ *
+ * NOTICE TO LICENSEE:
+ *
+ * This source code and/or documentation ("Licensed Deliverables") are
+ * subject to NVIDIA intellectual property rights under U.S. and
+ * international Copyright laws.
+ *
+ * These Licensed Deliverables contained herein is PROPRIETARY and
+ * CONFIDENTIAL to NVIDIA and is being provided under the terms and
+ * conditions of a form of NVIDIA software license agreement by and
+ * between NVIDIA and Licensee ("License Agreement") or electronically
+ * accepted by Licensee.  Notwithstanding any terms or conditions to
+ * the contrary in the License Agreement, reproduction or disclosure
+ * of the Licensed Deliverables to any third party without the express
+ * written consent of NVIDIA is prohibited.
+ *
+ * NOTWITHSTANDING ANY TERMS OR CONDITIONS TO THE CONTRARY IN THE
+ * LICENSE AGREEMENT, NVIDIA MAKES NO REPRESENTATION ABOUT THE
+ * SUITABILITY OF THESE LICENSED DELIVERABLES FOR ANY PURPOSE.  IT IS
+ * PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY OF ANY KIND.
+ * NVIDIA DISCLAIMS ALL WARRANTIES WITH REGARD TO THESE LICENSED
+ * DELIVERABLES, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY,
+ * NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE.
+ * NOTWITHSTANDING ANY TERMS OR CONDITIONS TO THE CONTRARY IN THE
+ * LICENSE AGREEMENT, IN NO EVENT SHALL NVIDIA BE LIABLE FOR ANY
+ * SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, OR ANY
+ * DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+ * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
+ * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
+ * OF THESE LICENSED DELIVERABLES.
+ *
+ * U.S. Government End Users.  These Licensed Deliverables are a
+ * "commercial item" as that term is defined at 48 C.F.R. 2.101 (OCT
+ * 1995), consisting of "commercial computer software" and "commercial
+ * computer software documentation" as such terms are used in 48
+ * C.F.R. 12.212 (SEPT 1995) and is provided to the U.S. Government
+ * only as a commercial end item.  Consistent with 48 C.F.R.12.212 and
+ * 48 C.F.R. 227.7202-1 through 227.7202-4 (JUNE 1995), all
+ * U.S. Government End Users acquire the Licensed Deliverables with
+ * only those rights set forth herein.
+ *
+ * Any use of the Licensed Deliverables in individual and commercial
+ * software must include, in the user documentation and internal
+ * comments to the code, the above Disclaimer and U.S. Government End
+ * Users Notice.
+ */
+
+/*
+ * curand_mtgp32_kernel.h
+ *
+ *
+ * MTGP32-11213
+ *
+ * Mersenne Twister RNG for the GPU
+ *
+ * The period of generated integers is 2<sup>11213</sup>-1.
+ *
+ * This code generates 32-bit unsigned integers, and
+ * single precision floating point numbers uniformly distributed
+ * in the range [1, 2). (float r; 1.0 <= r < 2.0)
+ */
+
+/*
+ * Copyright (c) 2009, 2010 Mutsuo Saito, Makoto Matsumoto and Hiroshima
+ * University.  All rights reserved.
+ * Copyright (c) 2011 Mutsuo Saito, Makoto Matsumoto, Hiroshima
+ * University and University of Tokyo.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ *       copyright notice, this list of conditions and the following
+ *       disclaimer in the documentation and/or other materials provided
+ *       with the distribution.
+ *     * Neither the name of the Hiroshima University nor the names of
+ *       its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written
+ *       permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#if !defined CURAND_MTGP32_KERNEL_H
+#define CURAND_MTGP32_KERNEL_H
+
+#if !defined(QUALIFIERS)
+#define QUALIFIERS static __forceinline__ __device__
+#endif
+
+#ifndef __CUDACC_RTC__
+#include <cuda_runtime.h>
+#include <stdlib.h>
+#include <memory.h>
+#include <string.h>
+#endif // ifndef __CUDACC_RTC__
+#include <nv/target>
+#include "curand.h"
+#include "curand_mtgp32.h"
+
+/**
+ * \addtogroup DEVICE Device API
+ *
+ * @{
+ */
+
+#ifndef __CUDA_ARCH__
+// define blockDim and threadIdx for host compatibility call
+extern const dim3 blockDim;
+extern const uint3 threadIdx;
+#endif
+
+
+/*
+ * The function of the recursion formula calculation.
+ *
+ * @param[in] X1 the farthest part of state array.
+ * @param[in] X2 the second farthest part of state array.
+ * @param[in] Y a part of state array.
+ * @param[in] bid block id.
+ * @return output
+ */
+QUALIFIERS unsigned int para_rec(mtgp32_kernel_params_t * k,unsigned int X1, unsigned int X2, unsigned int Y, int bid) {
+    unsigned int X = (X1 & k->mask[0]) ^ X2;
+    unsigned int MAT;
+
+    X ^= X << k->sh1_tbl[bid];
+    Y = X ^ (Y >> k->sh2_tbl[bid]);
+    MAT = k->param_tbl[bid][Y & 0x0f];
+    return Y ^ MAT;
+}
+
+/*
+ * The tempering function.
+ *
+ * @param[in] V the output value should be tempered.
+ * @param[in] T the tempering helper value.
+ * @param[in] bid block id.
+ * @return the tempered value.
+ */
+QUALIFIERS unsigned int temper(mtgp32_kernel_params_t * k,unsigned int V, unsigned int T, int bid) {
+    unsigned int MAT;
+
+    T ^= T >> 16;
+    T ^= T >> 8;
+    MAT = k->temper_tbl[bid][T & 0x0f];
+    return V ^ MAT;
+}
+
+/*
+ * The tempering and converting function.
+ * By using the preset table, converting to IEEE format
+ * and tempering are done simultaneously.
+ *
+ * @param[in] V the output value should be tempered.
+ * @param[in] T the tempering helper value.
+ * @param[in] bid block id.
+ * @return the tempered and converted value.
+ */
+QUALIFIERS unsigned int temper_single(mtgp32_kernel_params_t * k,unsigned int V, unsigned int T, int bid) {
+    unsigned int MAT;
+    unsigned int r;
+
+    T ^= T >> 16;
+    T ^= T >> 8;
+    MAT = k->single_temper_tbl[bid][T & 0x0f];
+    r = (V >> 9) ^ MAT;
+    return r;
+}
+
+/**
+ * \brief Return 32-bits of pseudorandomness from a mtgp32 generator.
+ *
+ * Return 32-bits of pseudorandomness from the mtgp32 generator in \p state,
+ * increment position of generator by the number of threads in the block.
+ * Note the number of threads in the block can not exceed 256.
+ *
+ * \param state - Pointer to state to update
+ *
+ * \return 32-bits of pseudorandomness as an unsigned int, all bits valid to use.
+ */
+QUALIFIERS unsigned int curand(curandStateMtgp32_t *state)
+{
+    unsigned int t;
+    unsigned int d;
+    int pos = state->k->pos_tbl[state->pIdx];
+    unsigned int r;
+    unsigned int o;
+
+    d = blockDim.z * blockDim.y * blockDim.x;
+    //assert( d <= 256 );
+    t = (blockDim.z * blockDim.y * threadIdx.z) + (blockDim.x * threadIdx.y) + threadIdx.x;
+    r = para_rec(state->k, state->s[(t + state->offset) & MTGP32_STATE_MASK],
+             state->s[(t + state->offset + 1) & MTGP32_STATE_MASK],
+             state->s[(t + state->offset + pos) & MTGP32_STATE_MASK],
+             state->pIdx);
+
+    state->s[(t + state->offset + MTGPDC_N) & MTGP32_STATE_MASK] = r;
+    o = temper(state->k, r,
+           state->s[(t + state->offset + pos -1) & MTGP32_STATE_MASK],
+           state->pIdx);
+NV_IF_TARGET(NV_IS_DEVICE,
+    __syncthreads();
+)
+    if (t == 0)
+    {
+        state->offset = (state->offset + d) & MTGP32_STATE_MASK;
+    }
+NV_IF_TARGET(NV_IS_DEVICE,
+    __syncthreads();
+)
+    return o;
+
+}
+/**
+ * \brief Return 32-bits of pseudorandomness from a specific position in a mtgp32 generator.
+ *
+ * Return 32-bits of pseudorandomness from position \p index of the mtgp32 generator in \p state,
+ * increment position of generator by \p n positions, which must be the total number of positions
+ * upddated in the state by the thread block, for this invocation.
+ *
+ * Note :
+ * Thread indices must range from 0...\ n - 1.
+ * The number of positions updated may not exceed 256.
+ * A thread block may update more than one state, but a given state may not be updated by more than one thread block.
+ *
+ * \param state - Pointer to state to update
+ * \param index - Index (0..255) of the position within the state to draw from and update
+ * \param n - The total number of postions in this state that are being updated by this invocation
+ *
+ * \return 32-bits of pseudorandomness as an unsigned int, all bits valid to use.
+ */
+QUALIFIERS unsigned int curand_mtgp32_specific(curandStateMtgp32_t *state, unsigned char index, unsigned char n)
+{
+    unsigned int t;
+    int pos = state->k->pos_tbl[state->pIdx];
+    unsigned int r;
+    unsigned int o;
+
+    t = index;
+    r = para_rec(state->k, state->s[(t + state->offset) & MTGP32_STATE_MASK],
+             state->s[(t + state->offset + 1) & MTGP32_STATE_MASK],
+             state->s[(t + state->offset + pos) & MTGP32_STATE_MASK],
+             state->pIdx);
+
+    state->s[(t + state->offset + MTGPDC_N) & MTGP32_STATE_MASK] = r;
+    o = temper(state->k, r,
+           state->s[(t + state->offset + pos -1) & MTGP32_STATE_MASK],
+           state->pIdx);
+NV_IF_TARGET(NV_IS_DEVICE,
+    __syncthreads();
+)
+    if (index == 0)
+    {
+        state->offset = (state->offset + n) & MTGP32_STATE_MASK;
+    }
+NV_IF_TARGET(NV_IS_DEVICE,
+    __syncthreads();
+)
+    return o;
+}
+/**
+ * \brief Return a uniformly distributed float from a mtgp32 generator.
+ *
+ * Return a uniformly distributed float between \p 0.0f and \p 1.0f
+ * from the mtgp32 generator in \p state, increment position of generator.
+ * Output range excludes \p 0.0f but includes \p 1.0f.  Denormalized floating
+ * point outputs are never returned.
+ *
+ * Note: This alternate derivation of a uniform float is provided for completeness
+ * with the original source
+ *
+ * \param state - Pointer to state to update
+ *
+ * \return uniformly distributed float between \p 0.0f and \p 1.0f
+ */
+QUALIFIERS float curand_mtgp32_single(curandStateMtgp32_t *state)
+{
+    unsigned int t;
+    unsigned int d;
+    int pos = state->k->pos_tbl[state->pIdx];
+    unsigned int r;
+    unsigned int o_u;
+    float o_f;
+
+
+    t = blockDim.z * blockDim.y;
+    d = t * blockDim.x;
+    //assert( d <= 256 );
+    t += threadIdx.x;
+    r = para_rec(state->k, state->s[(t + state->offset) & MTGP32_STATE_MASK],
+             state->s[(t + state->offset + 1) & MTGP32_STATE_MASK],
+             state->s[(t + state->offset + pos) & MTGP32_STATE_MASK],
+             state->pIdx);
+
+    state->s[t] = r;
+    o_u = temper_single(state->k, r,
+                        state->s[(t + state->offset + pos -1) & MTGP32_STATE_MASK],
+                        state->pIdx);
+NV_IF_TARGET(NV_IS_DEVICE,
+    __syncthreads();
+)
+    if (threadIdx.x == 0)
+    {
+        state->offset = (state->offset + d) & MTGP32_STATE_MASK;
+    }
+NV_IF_TARGET(NV_IS_DEVICE,
+    __syncthreads();
+)
+    memcpy(&o_f, &o_u, sizeof(o_u));
+    return o_f;
+}
+
+/**
+ * \brief Return a uniformly distributed float from a specific position in a mtgp32 generator.
+ *
+ * Return a uniformly distributed float between \p 0.0f and \p 1.0f
+ * from position \p index of the mtgp32 generator in \p state, and
+ * increment position of generator by \p n positions, which must be the total number of positions
+ * upddated in the state by the thread block, for this invocation.
+ * Output range excludes \p 0.0f but includes \p 1.0f.  Denormalized floating
+ * point outputs are never returned.
+ *
+ * Note 1:
+ * Thread indices must range from 0...\p n - 1.
+ * The number of positions updated may not exceed 256.
+ * A thread block may update more than one state, but a given state may not be updated by more than one thread block.
+ *
+ * Note 2: This alternate derivation of a uniform float is provided for completeness
+ * with the original source
+ *
+ * \param state - Pointer to state to update
+ * \param index - Index (0..255) of the position within the state to draw from and update
+ * \param n - The total number of postions in this state that are being updated by this invocation
+ *
+ * \return uniformly distributed float between \p 0.0f and \p 1.0f
+ */
+QUALIFIERS float curand_mtgp32_single_specific(curandStateMtgp32_t *state, unsigned char index, unsigned char n)
+{
+    unsigned int t;
+    int pos = state->k->pos_tbl[state->pIdx];
+    unsigned int r;
+    unsigned int o_u;
+    float o_f;
+
+    t = index;
+    r = para_rec(state->k, state->s[(t + state->offset) & MTGP32_STATE_MASK],
+             state->s[(t + state->offset + 1) & MTGP32_STATE_MASK],
+             state->s[(t + state->offset + pos) & MTGP32_STATE_MASK],
+             state->pIdx);
+
+    state->s[t] = r;
+    o_u = temper_single(state->k, r,
+                        state->s[(t + state->offset + pos -1) & MTGP32_STATE_MASK],
+                        state->pIdx);
+NV_IF_TARGET(NV_IS_DEVICE,
+    __syncthreads();
+)
+    if (threadIdx.x == 0)
+    {
+        state->offset = (state->offset + n) & MTGP32_STATE_MASK;
+    }
+NV_IF_TARGET(NV_IS_DEVICE,
+    __syncthreads();
+)
+    memcpy(&o_f, &o_u, sizeof(o_u));
+    return o_f;
+}
+
+/** @} */
+
+#endif

infer_4_37_2/lib/python3.10/site-packages/nvidia/curand/include/curand_normal.h

@@ -0,0 +1,840 @@
+
+ /* Copyright 2010-2014 NVIDIA Corporation.  All rights reserved.
+  *
+  * NOTICE TO LICENSEE:
+  *
+  * The source code and/or documentation ("Licensed Deliverables") are
+  * subject to NVIDIA intellectual property rights under U.S. and
+  * international Copyright laws.
+  *
+  * The Licensed Deliverables contained herein are PROPRIETARY and
+  * CONFIDENTIAL to NVIDIA and are being provided under the terms and
+  * conditions of a form of NVIDIA software license agreement by and
+  * between NVIDIA and Licensee ("License Agreement") or electronically
+  * accepted by Licensee.  Notwithstanding any terms or conditions to
+  * the contrary in the License Agreement, reproduction or disclosure
+  * of the Licensed Deliverables to any third party without the express
+  * written consent of NVIDIA is prohibited.
+  *
+  * NOTWITHSTANDING ANY TERMS OR CONDITIONS TO THE CONTRARY IN THE
+  * LICENSE AGREEMENT, NVIDIA MAKES NO REPRESENTATION ABOUT THE
+  * SUITABILITY OF THESE LICENSED DELIVERABLES FOR ANY PURPOSE.  THEY ARE
+  * PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY OF ANY KIND.
+  * NVIDIA DISCLAIMS ALL WARRANTIES WITH REGARD TO THESE LICENSED
+  * DELIVERABLES, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY,
+  * NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE.
+  * NOTWITHSTANDING ANY TERMS OR CONDITIONS TO THE CONTRARY IN THE
+  * LICENSE AGREEMENT, IN NO EVENT SHALL NVIDIA BE LIABLE FOR ANY
+  * SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, OR ANY
+  * DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+  * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
+  * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
+  * OF THESE LICENSED DELIVERABLES.
+  *
+  * U.S. Government End Users.  These Licensed Deliverables are a
+  * "commercial item" as that term is defined at 48 C.F.R. 2.101 (OCT
+  * 1995), consisting of "commercial computer software" and "commercial
+  * computer software documentation" as such terms are used in 48
+  * C.F.R. 12.212 (SEPT 1995) and are provided to the U.S. Government
+  * only as a commercial end item.  Consistent with 48 C.F.R.12.212 and
+  * 48 C.F.R. 227.7202-1 through 227.7202-4 (JUNE 1995), all
+  * U.S. Government End Users acquire the Licensed Deliverables with
+  * only those rights set forth herein.
+  *
+  * Any use of the Licensed Deliverables in individual and commercial
+  * software must include, in the user documentation and internal
+  * comments to the code, the above Disclaimer and U.S. Government End
+  * Users Notice.
+  */
+
+
+#if !defined(CURAND_NORMAL_H_)
+#define CURAND_NORMAL_H_
+
+/**
+ * \defgroup DEVICE Device API
+ *
+ * @{
+ */
+
+#ifndef __CUDACC_RTC__
+#include <math.h>
+#endif // __CUDACC_RTC__
+#include <nv/target>
+
+#include "curand_mrg32k3a.h"
+#include "curand_mtgp32_kernel.h"
+#include "curand_philox4x32_x.h"
+#include "curand_normal_static.h"
+
+QUALIFIERS float2 _curand_box_muller(unsigned int x, unsigned int y)
+{
+    float2 result;
+    float u = x * CURAND_2POW32_INV + (CURAND_2POW32_INV/2);
+    float v = y * CURAND_2POW32_INV_2PI + (CURAND_2POW32_INV_2PI/2);
+    float s;
+NV_IF_ELSE_TARGET(NV_IS_DEVICE,
+    s = sqrtf(-2.0f * logf(u));
+    __sincosf(v, &result.x, &result.y);
+,
+    s = sqrtf(-2.0f * logf(u));
+    result.x = sinf(v);
+    result.y = cosf(v);
+)
+    result.x *= s;
+    result.y *= s;
+    return result;
+}
+
+QUALIFIERS float2 curand_box_muller_mrg(curandStateMRG32k3a_t * state)
+{
+    float x, y;
+    x = curand_uniform(state);
+    y = curand_uniform(state) * CURAND_2PI;
+    float2 result;
+    float s;
+NV_IF_ELSE_TARGET(NV_IS_DEVICE,
+    s = sqrtf(-2.0f * logf(x));
+    __sincosf(y, &result.x, &result.y);
+,
+    s = sqrtf(-2.0f * logf(x));
+    result.x = sinf(y);
+    result.y = cosf(y);
+)
+    result.x *= s;
+    result.y *= s;
+    return result;
+}
+
+QUALIFIERS double2
+_curand_box_muller_double(unsigned int x0, unsigned int x1,
+                          unsigned int y0, unsigned int y1)
+{
+    double2 result;
+    unsigned long long zx = (unsigned long long)x0 ^
+        ((unsigned long long)x1 << (53 - 32));
+    double u = zx * CURAND_2POW53_INV_DOUBLE + (CURAND_2POW53_INV_DOUBLE/2.0);
+    unsigned long long zy = (unsigned long long)y0 ^
+        ((unsigned long long)y1 << (53 - 32));
+    double v = zy * (CURAND_2POW53_INV_DOUBLE*2.0) + CURAND_2POW53_INV_DOUBLE;
+    double s = sqrt(-2.0 * log(u));
+
+NV_IF_ELSE_TARGET(NV_IS_DEVICE,
+    sincospi(v, &result.x, &result.y);
+,
+    result.x = sin(v*CURAND_PI_DOUBLE);
+    result.y = cos(v*CURAND_PI_DOUBLE);
+)
+    result.x *= s;
+    result.y *= s;
+
+    return result;
+}
+
+QUALIFIERS double2
+curand_box_muller_mrg_double(curandStateMRG32k3a_t * state)
+{
+    double x, y;
+    double2 result;
+    x = curand_uniform_double(state);
+    y = curand_uniform_double(state) * 2.0;
+
+    double s = sqrt(-2.0 * log(x));
+NV_IF_ELSE_TARGET(NV_IS_DEVICE,
+    sincospi(y, &result.x, &result.y);
+,
+    result.x = sin(y*CURAND_PI_DOUBLE);
+    result.y = cos(y*CURAND_PI_DOUBLE);
+)
+    result.x *= s;
+    result.y *= s;
+    return result;
+}
+
+template <typename R>
+QUALIFIERS float2 curand_box_muller(R *state)
+{
+    float2 result;
+    unsigned int x = curand(state);
+    unsigned int y = curand(state);
+    result = _curand_box_muller(x, y);
+    return result;
+}
+
+template <typename R>
+QUALIFIERS float4 curand_box_muller4(R *state)
+{
+    float4 result;
+    float2 _result;
+    uint4 x = curand4(state);
+    //unsigned int y = curand(state);
+    _result = _curand_box_muller(x.x, x.y);
+    result.x = _result.x;
+    result.y = _result.y;
+    _result = _curand_box_muller(x.z, x.w);
+    result.z = _result.x;
+    result.w = _result.y;
+    return result;
+}
+
+template <typename R>
+QUALIFIERS double2 curand_box_muller_double(R *state)
+{
+    double2 result;
+    unsigned int x0 = curand(state);
+    unsigned int x1 = curand(state);
+    unsigned int y0 = curand(state);
+    unsigned int y1 = curand(state);
+    result = _curand_box_muller_double(x0, x1, y0, y1);
+    return result;
+}
+
+template <typename R>
+QUALIFIERS double2 curand_box_muller2_double(R *state)
+{
+    double2 result;
+    uint4 _x;
+    _x = curand4(state);
+    result = _curand_box_muller_double(_x.x, _x.y, _x.z, _x.w);
+    return result;
+}
+
+
+template <typename R>
+QUALIFIERS double4 curand_box_muller4_double(R *state)
+{
+    double4 result;
+    double2 _res1;
+    double2 _res2;
+    uint4 _x;
+    uint4 _y;
+    _x = curand4(state);
+    _y = curand4(state);
+    _res1 = _curand_box_muller_double(_x.x, _x.y, _x.z, _x.w);
+    _res2 = _curand_box_muller_double(_y.x, _y.y, _y.z, _y.w);
+    result.x = _res1.x;
+    result.y = _res1.y;
+    result.z = _res2.x;
+    result.w = _res2.y;
+    return result;
+}
+
+//QUALIFIERS float _curand_normal_icdf(unsigned int x)
+//{
+//#if __CUDA_ARCH__ > 0 || defined(HOST_HAVE_ERFCINVF)
+//    float s = CURAND_SQRT2;
+//    // Mirror to avoid loss of precision
+//    if(x > 0x80000000UL) {
+//        x = 0xffffffffUL - x;
+//        s = -s;
+//    }
+//    float p = x * CURAND_2POW32_INV + (CURAND_2POW32_INV/2.0f);
+//    // p is in (0, 0.5], 2p is in (0, 1]
+//    return s * erfcinvf(2.0f * p);
+//#else
+//    x++;    //suppress warnings
+//    return 0.0f;
+//#endif
+//}
+//
+//QUALIFIERS float _curand_normal_icdf(unsigned long long x)
+//{
+//#if __CUDA_ARCH__ > 0 || defined(HOST_HAVE_ERFCINVF)
+//    unsigned int t = (unsigned int)(x >> 32);
+//    float s = CURAND_SQRT2;
+//    // Mirror to avoid loss of precision
+//    if(t > 0x80000000UL) {
+//        t = 0xffffffffUL - t;
+//        s = -s;
+//    }
+//    float p = t * CURAND_2POW32_INV + (CURAND_2POW32_INV/2.0f);
+//    // p is in (0, 0.5], 2p is in (0, 1]
+//    return s * erfcinvf(2.0f * p);
+//#else
+//    x++;
+//    return 0.0f;
+//#endif
+//}
+//
+//QUALIFIERS double _curand_normal_icdf_double(unsigned int x)
+//{
+//#if __CUDA_ARCH__ > 0 || defined(HOST_HAVE_ERFCINVF)
+//    double s = CURAND_SQRT2_DOUBLE;
+//    // Mirror to avoid loss of precision
+//    if(x > 0x80000000UL) {
+//        x = 0xffffffffUL - x;
+//        s = -s;
+//    }
+//    double p = x * CURAND_2POW32_INV_DOUBLE + (CURAND_2POW32_INV_DOUBLE/2.0);
+//    // p is in (0, 0.5], 2p is in (0, 1]
+//    return s * erfcinv(2.0 * p);
+//#else
+//    x++;
+//    return 0.0;
+//#endif
+//}
+//
+//QUALIFIERS double _curand_normal_icdf_double(unsigned long long x)
+//{
+//#if __CUDA_ARCH__ > 0 || defined(HOST_HAVE_ERFCINVF)
+//    double s = CURAND_SQRT2_DOUBLE;
+//    x >>= 11;
+//    // Mirror to avoid loss of precision
+//    if(x > 0x10000000000000UL) {
+//        x = 0x1fffffffffffffUL - x;
+//        s = -s;
+//    }
+//    double p = x * CURAND_2POW53_INV_DOUBLE + (CURAND_2POW53_INV_DOUBLE/2.0);
+//    // p is in (0, 0.5], 2p is in (0, 1]
+//    return s * erfcinv(2.0 * p);
+//#else
+//    x++;
+//    return 0.0;
+//#endif
+//}
+//
+
+/**
+ * \brief Return a normally distributed float from an XORWOW generator.
+ *
+ * Return a single normally distributed float with mean \p 0.0f and
+ * standard deviation \p 1.0f from the XORWOW generator in \p state,
+ * increment position of generator by one.
+ *
+ * The implementation uses a Box-Muller transform to generate two
+ * normally distributed results, then returns them one at a time.
+ * See ::curand_normal2() for a more efficient version that returns
+ * both results at once.
+ *
+ * \param state - Pointer to state to update
+ *
+ * \return Normally distributed float with mean \p 0.0f and standard deviation \p 1.0f
+ */
+QUALIFIERS float curand_normal(curandStateXORWOW_t *state)
+{
+    if(state->boxmuller_flag != EXTRA_FLAG_NORMAL) {
+        unsigned int x, y;
+        x = curand(state);
+        y = curand(state);
+        float2 v = _curand_box_muller(x, y);
+        state->boxmuller_extra = v.y;
+        state->boxmuller_flag = EXTRA_FLAG_NORMAL;
+        return v.x;
+    }
+    state->boxmuller_flag = 0;
+    return state->boxmuller_extra;
+}
+
+/**
+ * \brief Return a normally distributed float from an Philox4_32_10 generator.
+ *
+ * Return a single normally distributed float with mean \p 0.0f and
+ * standard deviation \p 1.0f from the Philox4_32_10 generator in \p state,
+ * increment position of generator by one.
+ *
+ * The implementation uses a Box-Muller transform to generate two
+ * normally distributed results, then returns them one at a time.
+ * See ::curand_normal2() for a more efficient version that returns
+ * both results at once.
+ *
+ * \param state - Pointer to state to update
+ *
+ * \return Normally distributed float with mean \p 0.0f and standard deviation \p 1.0f
+ */
+
+QUALIFIERS float curand_normal(curandStatePhilox4_32_10_t *state)
+{
+    if(state->boxmuller_flag != EXTRA_FLAG_NORMAL) {
+        unsigned int x, y;
+        x = curand(state);
+        y = curand(state);
+        float2 v = _curand_box_muller(x, y);
+        state->boxmuller_extra = v.y;
+        state->boxmuller_flag = EXTRA_FLAG_NORMAL;
+        return v.x;
+    }
+    state->boxmuller_flag = 0;
+    return state->boxmuller_extra;
+}
+
+
+
+/**
+ * \brief Return a normally distributed float from an MRG32k3a generator.
+ *
+ * Return a single normally distributed float with mean \p 0.0f and
+ * standard deviation \p 1.0f from the MRG32k3a generator in \p state,
+ * increment position of generator by one.
+ *
+ * The implementation uses a Box-Muller transform to generate two
+ * normally distributed results, then returns them one at a time.
+ * See ::curand_normal2() for a more efficient version that returns
+ * both results at once.
+ *
+ * \param state - Pointer to state to update
+ *
+ * \return Normally distributed float with mean \p 0.0f and standard deviation \p 1.0f
+ */
+QUALIFIERS float curand_normal(curandStateMRG32k3a_t *state)
+{
+    if(state->boxmuller_flag != EXTRA_FLAG_NORMAL) {
+        float2 v = curand_box_muller_mrg(state);
+        state->boxmuller_extra = v.y;
+        state->boxmuller_flag = EXTRA_FLAG_NORMAL;
+        return v.x;
+    }
+    state->boxmuller_flag = 0;
+    return state->boxmuller_extra;
+}
+
+/**
+ * \brief Return two normally distributed floats from an XORWOW generator.
+ *
+ * Return two normally distributed floats with mean \p 0.0f and
+ * standard deviation \p 1.0f from the XORWOW generator in \p state,
+ * increment position of generator by two.
+ *
+ * The implementation uses a Box-Muller transform to generate two
+ * normally distributed results.
+ *
+ * \param state - Pointer to state to update
+ *
+ * \return Normally distributed float2 where each element is from a
+ * distribution with mean \p 0.0f and standard deviation \p 1.0f
+ */
+QUALIFIERS float2 curand_normal2(curandStateXORWOW_t *state)
+{
+    return curand_box_muller(state);
+}
+/**
+ * \brief Return two normally distributed floats from an Philox4_32_10 generator.
+ *
+ * Return two normally distributed floats with mean \p 0.0f and
+ * standard deviation \p 1.0f from the Philox4_32_10 generator in \p state,
+ * increment position of generator by two.
+ *
+ * The implementation uses a Box-Muller transform to generate two
+ * normally distributed results.
+ *
+ * \param state - Pointer to state to update
+ *
+ * \return Normally distributed float2 where each element is from a
+ * distribution with mean \p 0.0f and standard deviation \p 1.0f
+ */
+QUALIFIERS float2 curand_normal2(curandStatePhilox4_32_10_t *state)
+{
+    return curand_box_muller(state);
+}
+
+/**
+ * \brief Return four normally distributed floats from an Philox4_32_10 generator.
+ *
+ * Return four normally distributed floats with mean \p 0.0f and
+ * standard deviation \p 1.0f from the Philox4_32_10 generator in \p state,
+ * increment position of generator by four.
+ *
+ * The implementation uses a Box-Muller transform to generate two
+ * normally distributed results.
+ *
+ * \param state - Pointer to state to update
+ *
+ * \return Normally distributed float2 where each element is from a
+ * distribution with mean \p 0.0f and standard deviation \p 1.0f
+ */
+QUALIFIERS float4 curand_normal4(curandStatePhilox4_32_10_t *state)
+{
+    return curand_box_muller4(state);
+}
+
+
+
+/**
+ * \brief Return two normally distributed floats from an MRG32k3a generator.
+ *
+ * Return two normally distributed floats with mean \p 0.0f and
+ * standard deviation \p 1.0f from the MRG32k3a generator in \p state,
+ * increment position of generator by two.
+ *
+ * The implementation uses a Box-Muller transform to generate two
+ * normally distributed results.
+ *
+ * \param state - Pointer to state to update
+ *
+ * \return Normally distributed float2 where each element is from a
+ * distribution with mean \p 0.0f and standard deviation \p 1.0f
+ */
+QUALIFIERS float2 curand_normal2(curandStateMRG32k3a_t *state)
+{
+    return curand_box_muller_mrg(state);
+}
+
+/**
+ * \brief Return a normally distributed float from a MTGP32 generator.
+ *
+ * Return a single normally distributed float with mean \p 0.0f and
+ * standard deviation \p 1.0f from the MTGP32 generator in \p state,
+ * increment position of generator.
+ *
+ * The implementation uses the inverse cumulative distribution function
+ * to generate normally distributed results.
+ *
+ * \param state - Pointer to state to update
+ *
+ * \return Normally distributed float with mean \p 0.0f and standard deviation \p 1.0f
+ */
+QUALIFIERS float curand_normal(curandStateMtgp32_t *state)
+{
+    return _curand_normal_icdf(curand(state));
+}
+/**
+ * \brief Return a normally distributed float from a Sobol32 generator.
+ *
+ * Return a single normally distributed float with mean \p 0.0f and
+ * standard deviation \p 1.0f from the Sobol32 generator in \p state,
+ * increment position of generator by one.
+ *
+ * The implementation uses the inverse cumulative distribution function
+ * to generate normally distributed results.
+ *
+ * \param state - Pointer to state to update
+ *
+ * \return Normally distributed float with mean \p 0.0f and standard deviation \p 1.0f
+ */
+QUALIFIERS float curand_normal(curandStateSobol32_t *state)
+{
+    return _curand_normal_icdf(curand(state));
+}
+
+/**
+ * \brief Return a normally distributed float from a scrambled Sobol32 generator.
+ *
+ * Return a single normally distributed float with mean \p 0.0f and
+ * standard deviation \p 1.0f from the scrambled Sobol32 generator in \p state,
+ * increment position of generator by one.
+ *
+ * The implementation uses the inverse cumulative distribution function
+ * to generate normally distributed results.
+ *
+ * \param state - Pointer to state to update
+ *
+ * \return Normally distributed float with mean \p 0.0f and standard deviation \p 1.0f
+ */
+QUALIFIERS float curand_normal(curandStateScrambledSobol32_t *state)
+{
+    return _curand_normal_icdf(curand(state));
+}
+
+/**
+ * \brief Return a normally distributed float from a Sobol64 generator.
+ *
+ * Return a single normally distributed float with mean \p 0.0f and
+ * standard deviation \p 1.0f from the Sobol64 generator in \p state,
+ * increment position of generator by one.
+ *
+ * The implementation uses the inverse cumulative distribution function
+ * to generate normally distributed results.
+ *
+ * \param state - Pointer to state to update
+ *
+ * \return Normally distributed float with mean \p 0.0f and standard deviation \p 1.0f
+ */
+QUALIFIERS float curand_normal(curandStateSobol64_t *state)
+{
+    return _curand_normal_icdf(curand(state));
+}
+
+/**
+ * \brief Return a normally distributed float from a scrambled Sobol64 generator.
+ *
+ * Return a single normally distributed float with mean \p 0.0f and
+ * standard deviation \p 1.0f from the scrambled Sobol64 generator in \p state,
+ * increment position of generator by one.
+ *
+ * The implementation uses the inverse cumulative distribution function
+ * to generate normally distributed results.
+ *
+ * \param state - Pointer to state to update
+ *
+ * \return Normally distributed float with mean \p 0.0f and standard deviation \p 1.0f
+ */
+QUALIFIERS float curand_normal(curandStateScrambledSobol64_t *state)
+{
+    return _curand_normal_icdf(curand(state));
+}
+
+/**
+ * \brief Return a normally distributed double from an XORWOW generator.
+ *
+ * Return a single normally distributed double with mean \p 0.0 and
+ * standard deviation \p 1.0 from the XORWOW generator in \p state,
+ * increment position of generator.
+ *
+ * The implementation uses a Box-Muller transform to generate two
+ * normally distributed results, then returns them one at a time.
+ * See ::curand_normal2_double() for a more efficient version that returns
+ * both results at once.
+ *
+ * \param state - Pointer to state to update
+ *
+ * \return Normally distributed double with mean \p 0.0 and standard deviation \p 1.0
+ */
+QUALIFIERS double curand_normal_double(curandStateXORWOW_t *state)
+{
+    if(state->boxmuller_flag_double != EXTRA_FLAG_NORMAL) {
+        unsigned int x0, x1, y0, y1;
+        x0 = curand(state);
+        x1 = curand(state);
+        y0 = curand(state);
+        y1 = curand(state);
+        double2 v = _curand_box_muller_double(x0, x1, y0, y1);
+        state->boxmuller_extra_double = v.y;
+        state->boxmuller_flag_double = EXTRA_FLAG_NORMAL;
+        return v.x;
+    }
+    state->boxmuller_flag_double = 0;
+    return state->boxmuller_extra_double;
+}
+
+/**
+ * \brief Return a normally distributed double from an Philox4_32_10 generator.
+ *
+ * Return a single normally distributed double with mean \p 0.0 and
+ * standard deviation \p 1.0 from the Philox4_32_10 generator in \p state,
+ * increment position of generator.
+ *
+ * The implementation uses a Box-Muller transform to generate two
+ * normally distributed results, then returns them one at a time.
+ * See ::curand_normal2_double() for a more efficient version that returns
+ * both results at once.
+ *
+ * \param state - Pointer to state to update
+ *
+ * \return Normally distributed double with mean \p 0.0 and standard deviation \p 1.0
+ */
+
+QUALIFIERS double curand_normal_double(curandStatePhilox4_32_10_t *state)
+{
+    if(state->boxmuller_flag_double != EXTRA_FLAG_NORMAL) {
+        uint4 _x;
+        _x = curand4(state);
+        double2 v = _curand_box_muller_double(_x.x, _x.y, _x.z, _x.w);
+        state->boxmuller_extra_double = v.y;
+        state->boxmuller_flag_double = EXTRA_FLAG_NORMAL;
+        return v.x;
+    }
+    state->boxmuller_flag_double = 0;
+    return state->boxmuller_extra_double;
+}
+
+
+/**
+ * \brief Return a normally distributed double from an MRG32k3a generator.
+ *
+ * Return a single normally distributed double with mean \p 0.0 and
+ * standard deviation \p 1.0 from the XORWOW generator in \p state,
+ * increment position of generator.
+ *
+ * The implementation uses a Box-Muller transform to generate two
+ * normally distributed results, then returns them one at a time.
+ * See ::curand_normal2_double() for a more efficient version that returns
+ * both results at once.
+ *
+ * \param state - Pointer to state to update
+ *
+ * \return Normally distributed double with mean \p 0.0 and standard deviation \p 1.0
+ */
+QUALIFIERS double curand_normal_double(curandStateMRG32k3a_t *state)
+{
+    if(state->boxmuller_flag_double != EXTRA_FLAG_NORMAL) {
+        double2 v = curand_box_muller_mrg_double(state);
+        state->boxmuller_extra_double = v.y;
+        state->boxmuller_flag_double = EXTRA_FLAG_NORMAL;
+        return v.x;
+    }
+    state->boxmuller_flag_double = 0;
+    return state->boxmuller_extra_double;
+}
+
+/**
+ * \brief Return two normally distributed doubles from an XORWOW generator.
+ *
+ * Return two normally distributed doubles with mean \p 0.0 and
+ * standard deviation \p 1.0 from the XORWOW generator in \p state,
+ * increment position of generator by 2.
+ *
+ * The implementation uses a Box-Muller transform to generate two
+ * normally distributed results.
+ *
+ * \param state - Pointer to state to update
+ *
+ * \return Normally distributed double2 where each element is from a
+ * distribution with mean \p 0.0 and standard deviation \p 1.0
+ */
+QUALIFIERS double2 curand_normal2_double(curandStateXORWOW_t *state)
+{
+    return curand_box_muller_double(state);
+}
+
+/**
+ * \brief Return two normally distributed doubles from an Philox4_32_10 generator.
+ *
+ * Return two normally distributed doubles with mean \p 0.0 and
+ * standard deviation \p 1.0 from the Philox4_32_10 generator in \p state,
+ * increment position of generator by 2.
+ *
+ * The implementation uses a Box-Muller transform to generate two
+ * normally distributed results.
+ *
+ * \param state - Pointer to state to update
+ *
+ * \return Normally distributed double2 where each element is from a
+ * distribution with mean \p 0.0 and standard deviation \p 1.0
+ */
+QUALIFIERS double2 curand_normal2_double(curandStatePhilox4_32_10_t *state)
+{
+    uint4 _x;
+    double2 result;
+
+    _x = curand4(state);
+    double2 v1 = _curand_box_muller_double(_x.x, _x.y, _x.z, _x.w);
+    result.x = v1.x;
+    result.y = v1.y;
+
+    return result;
+}
+
+ // not a part of API
+QUALIFIERS double4 curand_normal4_double(curandStatePhilox4_32_10_t *state)
+{
+    uint4 _x;
+    uint4 _y;
+    double4 result;
+
+    _x = curand4(state);
+    _y = curand4(state);
+    double2 v1 = _curand_box_muller_double(_x.x, _x.y, _x.z, _x.w);
+    double2 v2 = _curand_box_muller_double(_y.x, _y.y, _y.z, _y.w);
+    result.x = v1.x;
+    result.y = v1.y;
+    result.z = v2.x;
+    result.w = v2.y;
+
+    return result;
+}
+
+
+/**
+ * \brief Return two normally distributed doubles from an MRG32k3a generator.
+ *
+ * Return two normally distributed doubles with mean \p 0.0 and
+ * standard deviation \p 1.0 from the MRG32k3a generator in \p state,
+ * increment position of generator.
+ *
+ * The implementation uses a Box-Muller transform to generate two
+ * normally distributed results.
+ *
+ * \param state - Pointer to state to update
+ *
+ * \return Normally distributed double2 where each element is from a
+ * distribution with mean \p 0.0 and standard deviation \p 1.0
+ */
+QUALIFIERS double2 curand_normal2_double(curandStateMRG32k3a_t *state)
+{
+    return curand_box_muller_mrg_double(state);
+}
+
+/**
+ * \brief Return a normally distributed double from an MTGP32 generator.
+ *
+ * Return a single normally distributed double with mean \p 0.0 and
+ * standard deviation \p 1.0 from the MTGP32 generator in \p state,
+ * increment position of generator.
+ *
+ * The implementation uses the inverse cumulative distribution function
+ * to generate normally distributed results.
+ *
+ * \param state - Pointer to state to update
+ *
+ * \return Normally distributed double with mean \p 0.0 and standard deviation \p 1.0
+ */
+QUALIFIERS double curand_normal_double(curandStateMtgp32_t *state)
+{
+    return _curand_normal_icdf_double(curand(state));
+}
+
+/**
+ * \brief Return a normally distributed double from an Sobol32 generator.
+ *
+ * Return a single normally distributed double with mean \p 0.0 and
+ * standard deviation \p 1.0 from the Sobol32 generator in \p state,
+ * increment position of generator by one.
+ *
+ * The implementation uses the inverse cumulative distribution function
+ * to generate normally distributed results.
+ *
+ * \param state - Pointer to state to update
+ *
+ * \return Normally distributed double with mean \p 0.0 and standard deviation \p 1.0
+ */
+QUALIFIERS double curand_normal_double(curandStateSobol32_t *state)
+{
+    return _curand_normal_icdf_double(curand(state));
+}
+
+/**
+ * \brief Return a normally distributed double from a scrambled Sobol32 generator.
+ *
+ * Return a single normally distributed double with mean \p 0.0 and
+ * standard deviation \p 1.0 from the scrambled Sobol32 generator in \p state,
+ * increment position of generator by one.
+ *
+ * The implementation uses the inverse cumulative distribution function
+ * to generate normally distributed results.
+ *
+ * \param state - Pointer to state to update
+ *
+ * \return Normally distributed double with mean \p 0.0 and standard deviation \p 1.0
+ */
+QUALIFIERS double curand_normal_double(curandStateScrambledSobol32_t *state)
+{
+    return _curand_normal_icdf_double(curand(state));
+}
+
+/**
+ * \brief Return a normally distributed double from a Sobol64 generator.
+ *
+ * Return a single normally distributed double with mean \p 0.0 and
+ * standard deviation \p 1.0 from the Sobol64 generator in \p state,
+ * increment position of generator by one.
+ *
+ * The implementation uses the inverse cumulative distribution function
+ * to generate normally distributed results.
+ *
+ * \param state - Pointer to state to update
+ *
+ * \return Normally distributed double with mean \p 0.0 and standard deviation \p 1.0
+ */
+QUALIFIERS double curand_normal_double(curandStateSobol64_t *state)
+{
+    return _curand_normal_icdf_double(curand(state));
+}
+
+/**
+ * \brief Return a normally distributed double from a scrambled Sobol64 generator.
+ *
+ * Return a single normally distributed double with mean \p 0.0 and
+ * standard deviation \p 1.0 from the scrambled Sobol64 generator in \p state,
+ * increment position of generator by one.
+ *
+ * The implementation uses the inverse cumulative distribution function
+ * to generate normally distributed results.
+ *
+ * \param state - Pointer to state to update
+ *
+ * \return Normally distributed double with mean \p 0.0 and standard deviation \p 1.0
+ */
+QUALIFIERS double curand_normal_double(curandStateScrambledSobol64_t *state)
+{
+    return _curand_normal_icdf_double(curand(state));
+}
+#endif // !defined(CURAND_NORMAL_H_)

infer_4_37_2/lib/python3.10/site-packages/nvidia/curand/include/curand_poisson.h

@@ -0,0 +1,763 @@
+
+ /* Copyright 2010-2014 NVIDIA Corporation.  All rights reserved.
+  *
+  * NOTICE TO LICENSEE:
+  *
+  * The source code and/or documentation ("Licensed Deliverables") are
+  * subject to NVIDIA intellectual property rights under U.S. and
+  * international Copyright laws.
+  *
+  * The Licensed Deliverables contained herein are PROPRIETARY and
+  * CONFIDENTIAL to NVIDIA and are being provided under the terms and
+  * conditions of a form of NVIDIA software license agreement by and
+  * between NVIDIA and Licensee ("License Agreement") or electronically
+  * accepted by Licensee.  Notwithstanding any terms or conditions to
+  * the contrary in the License Agreement, reproduction or disclosure
+  * of the Licensed Deliverables to any third party without the express
+  * written consent of NVIDIA is prohibited.
+  *
+  * NOTWITHSTANDING ANY TERMS OR CONDITIONS TO THE CONTRARY IN THE
+  * LICENSE AGREEMENT, NVIDIA MAKES NO REPRESENTATION ABOUT THE
+  * SUITABILITY OF THESE LICENSED DELIVERABLES FOR ANY PURPOSE.  THEY ARE
+  * PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY OF ANY KIND.
+  * NVIDIA DISCLAIMS ALL WARRANTIES WITH REGARD TO THESE LICENSED
+  * DELIVERABLES, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY,
+  * NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE.
+  * NOTWITHSTANDING ANY TERMS OR CONDITIONS TO THE CONTRARY IN THE
+  * LICENSE AGREEMENT, IN NO EVENT SHALL NVIDIA BE LIABLE FOR ANY
+  * SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, OR ANY
+  * DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+  * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
+  * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
+  * OF THESE LICENSED DELIVERABLES.
+  *
+  * U.S. Government End Users.  These Licensed Deliverables are a
+  * "commercial item" as that term is defined at 48 C.F.R. 2.101 (OCT
+  * 1995), consisting of "commercial computer software" and "commercial
+  * computer software documentation" as such terms are used in 48
+  * C.F.R. 12.212 (SEPT 1995) and are provided to the U.S. Government
+  * only as a commercial end item.  Consistent with 48 C.F.R.12.212 and
+  * 48 C.F.R. 227.7202-1 through 227.7202-4 (JUNE 1995), all
+  * U.S. Government End Users acquire the Licensed Deliverables with
+  * only those rights set forth herein.
+  *
+  * Any use of the Licensed Deliverables in individual and commercial
+  * software must include, in the user documentation and internal
+  * comments to the code, the above Disclaimer and U.S. Government End
+  * Users Notice.
+  */
+
+
+#if !defined(CURAND_POISSON_H_)
+#define CURAND_POISSON_H_
+
+/**
+ * \defgroup DEVICE Device API
+ *
+ * @{
+ */
+
+#ifndef __CUDACC_RTC__
+#include <math.h>
+#endif // __CUDACC_RTC__
+
+#include <nv/target>
+
+#include "curand_mrg32k3a.h"
+#include "curand_mtgp32_kernel.h"
+#include "curand_philox4x32_x.h"
+
+#define CR_CUDART_PI               3.1415926535897931e+0
+#define CR_CUDART_TWO_TO_52        4503599627370496.0
+
+
+QUALIFIERS float __cr_rsqrt(float a)
+{
+NV_IF_ELSE_TARGET(NV_IS_DEVICE,
+    asm ("rsqrt.approx.f32.ftz %0, %1;" : "=f"(a) : "f"(a));
+,
+    a = 1.0f / sqrtf (a);
+)
+    return a;
+}
+
+QUALIFIERS float __cr_exp (float a)
+{
+NV_IF_ELSE_TARGET(NV_IS_DEVICE,
+    a = a * 1.4426950408889634074;
+    asm ("ex2.approx.f32.ftz %0, %1;" : "=f"(a) : "f"(a));
+,
+    a = expf (a);
+)
+    return a;
+}
+
+QUALIFIERS float __cr_log (float a)
+{
+NV_IF_ELSE_TARGET(NV_IS_DEVICE,
+    asm ("lg2.approx.f32.ftz %0, %1;" : "=f"(a) : "f"(a));
+    a = a * 0.69314718055994530942;
+,
+    a = logf (a);
+)
+    return a;
+}
+
+QUALIFIERS float __cr_rcp (float a)
+{
+NV_IF_ELSE_TARGET(NV_IS_DEVICE,
+    asm ("rcp.approx.f32.ftz %0, %1;" : "=f"(a) : "f"(a));
+,
+    a = 1.0f / a;
+)
+    return a;
+}
+
+/* Computes regularized gamma function:  gammainc(a,x)/gamma(a) */
+QUALIFIERS float __cr_pgammainc (float a, float x)
+{
+    float t, alpha, beta;
+
+    /* First level parametrization constants */
+    float ma1 = 1.43248035075540910f,
+          ma2 = 0.12400979329415655f,
+          ma3 = 0.00025361074907033f,
+          mb1 = 0.21096734870196546f,
+          mb2 = 1.97381164089999420f,
+          mb3 = 0.94201734077887530f;
+
+    /* Second level parametrization constants (depends only on a) */
+
+    alpha = __cr_rsqrt (a - ma2);
+    alpha = ma1 * alpha + ma3;
+    beta = __cr_rsqrt (a - mb2);
+    beta = mb1 * beta + mb3;
+
+    /* Final approximation (depends on a and x) */
+
+    t = a - x;
+    t = alpha * t - beta;
+    t = 1.0f + __cr_exp (t);
+    t = t * t;
+    t = __cr_rcp (t);
+
+    /* Negative a,x or a,x=NAN requires special handling */
+    //t = !(x > 0 && a >= 0) ? 0.0 : t;
+
+    return t;
+}
+
+/* Computes inverse of pgammainc */
+QUALIFIERS float __cr_pgammaincinv (float a, float y)
+{
+    float t, alpha, beta;
+
+    /* First level parametrization constants */
+
+    float ma1 = 1.43248035075540910f,
+          ma2 = 0.12400979329415655f,
+          ma3 = 0.00025361074907033f,
+          mb1 = 0.21096734870196546f,
+          mb2 = 1.97381164089999420f,
+          mb3 = 0.94201734077887530f;
+
+    /* Second level parametrization constants (depends only on a) */
+
+    alpha = __cr_rsqrt (a - ma2);
+    alpha = ma1 * alpha + ma3;
+    beta = __cr_rsqrt (a - mb2);
+    beta = mb1 * beta + mb3;
+
+    /* Final approximation (depends on a and y) */
+
+    t = __cr_rsqrt (y) - 1.0f;
+    t = __cr_log (t);
+    t = beta + t;
+    t = - t * __cr_rcp (alpha) + a;
+    /* Negative a,x or a,x=NAN requires special handling */
+    //t = !(y > 0 && a >= 0) ? 0.0 : t;
+    return t;
+}
+
+#if defined(__CUDACC_RDC__) && (__cplusplus >= 201703L) && defined(__cpp_inline_variables)
+inline __constant__ double __cr_lgamma_table [] = {
+#else
+static __constant__ double __cr_lgamma_table [] = {
+#endif
+    0.000000000000000000e-1,
+    0.000000000000000000e-1,
+    6.931471805599453094e-1,
+    1.791759469228055001e0,
+    3.178053830347945620e0,
+    4.787491742782045994e0,
+    6.579251212010100995e0,
+    8.525161361065414300e0,
+    1.060460290274525023e1
+};
+
+
+QUALIFIERS double __cr_lgamma_integer(int a)
+{
+    double s;
+    double t;
+    double fa = fabs((float)a);
+    double sum;
+
+    if (a > 8) {
+        /* Stirling approximation; coefficients from Hart et al, "Computer
+         * Approximations", Wiley 1968. Approximation 5404.
+         */
+        s = 1.0 / fa;
+        t = s * s;
+        sum =          -0.1633436431e-2;
+        sum = sum * t + 0.83645878922e-3;
+        sum = sum * t - 0.5951896861197e-3;
+        sum = sum * t + 0.793650576493454e-3;
+        sum = sum * t - 0.277777777735865004e-2;
+        sum = sum * t + 0.833333333333331018375e-1;
+        sum = sum * s + 0.918938533204672;
+        s = 0.5 * log (fa);
+        t = fa - 0.5;
+        s = s * t;
+        t = s - fa;
+        s = s + sum;
+        t = t + s;
+        return t;
+    } else {
+NV_IF_ELSE_TARGET(NV_IS_DEVICE,
+        return __cr_lgamma_table [(int) fa-1];
+,
+        switch(a) {
+            case 1: return 0.000000000000000000e-1;
+            case 2: return 0.000000000000000000e-1;
+            case 3: return 6.931471805599453094e-1;
+            case 4: return 1.791759469228055001e0;
+            case 5: return 3.178053830347945620e0;
+            case 6: return 4.787491742782045994e0;
+            case 7: return 6.579251212010100995e0;
+            case 8: return 8.525161361065414300e0;
+            default: return 1.060460290274525023e1;
+        }
+)
+    }
+}
+
+#define KNUTH_FLOAT_CONST 60.0
+template <typename T>
+// Donald E. Knuth Seminumerical Algorithms. The Art of Computer Programming, Volume 2
+QUALIFIERS unsigned int curand_poisson_knuth(T *state, float lambda)
+{
+  unsigned int k = 0;
+  float p = expf(lambda);
+  do{
+      k++;
+      p *= curand_uniform(state);
+  }while (p > 1.0);
+  return k-1;
+}
+
+template <typename T>
+// Donald E. Knuth Seminumerical Algorithms. The Art of Computer Programming, Volume 2
+QUALIFIERS uint4 curand_poisson_knuth4(T *state, float lambda)
+{
+  uint4 k = {0,0,0,0};
+  float exp_lambda = expf(lambda);
+  float4 p={ exp_lambda,exp_lambda,exp_lambda,exp_lambda };
+  do{
+      k.x++;
+      p.x *= curand_uniform(state);
+  }while (p.x > 1.0);
+  do{
+      k.y++;
+      p.y *= curand_uniform(state);
+  }while (p.y > 1.0);
+  do{
+      k.z++;
+      p.z *= curand_uniform(state);
+  }while (p.z > 1.0);
+  do{
+      k.w++;
+      p.w *= curand_uniform(state);
+  }while (p.w > 1.0);
+
+  k.x--;
+  k.y--;
+  k.z--;
+  k.w--;
+  return k;
+}
+
+template <typename T>
+// Marsaglia, Tsang, Wang Journal of Statistical Software, square histogram.
+QUALIFIERS unsigned int _curand_M2_double(T x, curandDistributionM2Shift_t distributionM2)
+{
+    double u = _curand_uniform_double(x);
+    int j = (int) floor(distributionM2->length*u);
+
+    double histogramVj;
+    unsigned int histogramKj;
+NV_IF_ELSE_TARGET(NV_PROVIDES_SM_35,
+    histogramVj = __ldg( &(distributionM2->histogram->V[j]));
+    histogramKj = __ldg( &(distributionM2->histogram->K[j]));
+,
+    histogramVj = distributionM2->histogram->V[j];
+    histogramKj = distributionM2->histogram->K[j];
+)
+    //if (u < distributionM2->histogram->V[j]) return distributionM2->shift + j;
+    //return distributionM2->shift + distributionM2->histogram->K[j];
+    if (u < histogramVj) return distributionM2->shift + j;
+    return distributionM2->shift + histogramKj;
+}
+
+template <typename T>
+// Marsaglia, Tsang, Wang Journal of Statistical Software, square histogram.
+QUALIFIERS uint4 _curand_M2_double4(T x, curandDistributionM2Shift_t distributionM2)
+{
+    double4 u;
+    uint4 result = {0,0,0,0};
+    int4 flag = {1,1,1,1};
+
+    u.x = _curand_uniform_double(x.x);
+    u.y = _curand_uniform_double(x.y);
+    u.z = _curand_uniform_double(x.z);
+    u.w = _curand_uniform_double(x.w);
+
+    int4 j;
+    j.x = (int) floor(distributionM2->length*u.x);
+    j.y = (int) floor(distributionM2->length*u.y);
+    j.z = (int) floor(distributionM2->length*u.z);
+    j.w = (int) floor(distributionM2->length*u.w);
+//    int result;
+
+    double histogramVjx;
+    double histogramVjy;
+    double histogramVjz;
+    double histogramVjw;
+    unsigned int histogramKjx;
+    unsigned int histogramKjy;
+    unsigned int histogramKjz;
+    unsigned int histogramKjw;
+NV_IF_ELSE_TARGET(NV_PROVIDES_SM_35,
+    histogramVjx =  __ldg( &(distributionM2->histogram->V[j.x]));
+    histogramVjy =  __ldg( &(distributionM2->histogram->V[j.y]));
+    histogramVjz =  __ldg( &(distributionM2->histogram->V[j.z]));
+    histogramVjw =  __ldg( &(distributionM2->histogram->V[j.w]));
+
+    histogramKjx = __ldg( &(distributionM2->histogram->K[j.x]));
+    histogramKjy = __ldg( &(distributionM2->histogram->K[j.y]));
+    histogramKjz = __ldg( &(distributionM2->histogram->K[j.z]));
+    histogramKjw = __ldg( &(distributionM2->histogram->K[j.w]));
+,
+    histogramVjx =  distributionM2->histogram->V[j.x];
+    histogramVjy =  distributionM2->histogram->V[j.y];
+    histogramVjz =  distributionM2->histogram->V[j.z];
+    histogramVjw =  distributionM2->histogram->V[j.w];
+
+    histogramKjx = distributionM2->histogram->K[j.x];
+    histogramKjy = distributionM2->histogram->K[j.y];
+    histogramKjz = distributionM2->histogram->K[j.z];
+    histogramKjw = distributionM2->histogram->K[j.w];
+)
+
+    if (u.x < histogramVjx){ result.x = distributionM2->shift + j.x; flag.x = 0; }
+    if (u.y < histogramVjy){ result.y = distributionM2->shift + j.y; flag.y = 0; }
+    if (u.z < histogramVjz){ result.z = distributionM2->shift + j.z; flag.z = 0; }
+    if (u.w < histogramVjw){ result.w = distributionM2->shift + j.w; flag.w = 0; }
+    //return distributionM2->shift + distributionM2->histogram->K[j];
+
+    if(flag.x) result.x = distributionM2->shift + histogramKjx;
+    if(flag.y) result.y = distributionM2->shift + histogramKjy;
+    if(flag.z) result.z = distributionM2->shift + histogramKjz;
+    if(flag.w) result.w = distributionM2->shift + histogramKjw;
+
+    return result;
+}
+
+template <typename STATE>
+QUALIFIERS unsigned int curand_M2_double(STATE *state, curandDistributionM2Shift_t distributionM2)
+{
+    return _curand_M2_double(curand(state), distributionM2);
+}
+
+template <typename STATE>
+QUALIFIERS uint4 curand_M2_double4(STATE *state, curandDistributionM2Shift_t distributionM2)
+{
+    return _curand_M2_double4(curand4(state), distributionM2);
+}
+
+
+template <typename T>
+QUALIFIERS unsigned int _curand_binary_search_double(T x, curandDistributionShift_t distribution)
+{
+    double u = _curand_uniform_double(x);
+    int min = 0;
+    int max = distribution->length-1;
+    do{
+        int mid = (max + min)/2;
+        double probability_mid;
+NV_IF_ELSE_TARGET(NV_PROVIDES_SM_35,
+        probability_mid = __ldg( &(distribution->probability[mid]));
+,
+        probability_mid = distribution->probability[mid];
+)
+        if (u <= probability_mid){
+            max = mid;
+        }else{
+            min = mid+1;
+        }
+    }while (min < max);
+    return distribution->shift + min;
+}
+
+template <typename STATE>
+QUALIFIERS unsigned int curand_binary_search_double(STATE *state, curandDistributionShift_t distribution)
+{
+    return _curand_binary_search_double(curand(state), distribution);
+}
+
+// Generates uniformly distributed double values in range (0.0; 1.0) from uniformly distributed
+// unsigned int. We can't use standard _curand_uniform_double since it can generate 1.0.
+// This is required only for _curand_poisson_ITR_double.
+QUALIFIERS double _curand_uniform_double_excluding_one(unsigned int x)
+{
+    return x * CURAND_2POW32_INV_DOUBLE + (CURAND_2POW32_INV_DOUBLE/2.0);
+}
+
+// Overload for unsigned long long.
+// This is required only for _curand_poisson_ITR_double.
+QUALIFIERS double _curand_uniform_double_excluding_one(unsigned long long x)
+{
+    return (x >> 11) * CURAND_2POW53_INV_DOUBLE + (CURAND_2POW53_INV_DOUBLE/4.0);
+}
+
+#define MAGIC_DOUBLE_CONST 500.0
+template <typename T>
+//George S. Fishman Discrete-event simulation: modeling, programming, and analysis
+QUALIFIERS unsigned int _curand_poisson_ITR_double(T x, double lambda)
+{
+  double L,p = 1.0;
+  double q = 1.0;
+  unsigned int k = 0;
+  int pow=0;
+  // This algorithm requires u to be in (0;1) range, however, _curand_uniform_double
+  // returns a number in range (0;1]. If u is 1.0 the inner loop never ends. The
+  // following operation transforms the range from (0;1] to (0;1).
+  double u = _curand_uniform_double_excluding_one(x);
+  do{
+      if (lambda > (double)(pow+MAGIC_DOUBLE_CONST)){
+          L = exp(-MAGIC_DOUBLE_CONST);
+      }else{
+          L = exp((double)(pow - lambda));
+      }
+      p *= L;
+      q *= L;
+      pow += (int) MAGIC_DOUBLE_CONST;
+      while (u > q){
+        k++;
+        p *= ((double)lambda / (double) k);
+        q += p;
+      }
+  }while((double)pow < lambda);
+  return k;
+}
+
+template <typename T>
+/* Rejection Method for Poisson distribution based on gammainc approximation */
+QUALIFIERS unsigned int curand_poisson_gammainc(T state, float lambda){
+    float y, x, t, z,v;
+    float logl = __cr_log (lambda);
+    while (true) {
+        y = curand_uniform (state);
+        x = __cr_pgammaincinv (lambda, y);
+        x = floorf (x);
+        z = curand_uniform (state);
+        v = (__cr_pgammainc (lambda, x + 1.0f) - __cr_pgammainc (lambda, x)) * 1.3f;
+        z = z*v;
+        t = (float)__cr_exp (-lambda + x * logl - (float)__cr_lgamma_integer ((int)(1.0f + x)));
+        if ((z < t) && (v>=1e-20))
+            break;
+    }
+    return (unsigned int)x;
+}
+
+template <typename T>
+/* Rejection Method for Poisson distribution based on gammainc approximation */
+QUALIFIERS uint4 curand_poisson_gammainc4(T state, float lambda){
+    uint4 result;
+    float y, x, t, z,v;
+    float logl = __cr_log (lambda);
+    while (true) {
+        y = curand_uniform(state);
+        x = __cr_pgammaincinv (lambda, y);
+        x = floorf (x);
+        z = curand_uniform (state);
+        v = (__cr_pgammainc (lambda, x + 1.0f) - __cr_pgammainc (lambda, x)) * 1.3f;
+        z = z*v;
+        t = (float)__cr_exp (-lambda + x * logl - (float)__cr_lgamma_integer ((int)(1.0f + x)));
+        if ((z < t) && (v>=1e-20))
+            break;
+    }
+    result.x = (unsigned int)x;
+
+    while (true) {
+        y = curand_uniform(state);
+        x = __cr_pgammaincinv (lambda, y);
+        x = floorf (x);
+        z = curand_uniform (state);
+        v = (__cr_pgammainc (lambda, x + 1.0f) - __cr_pgammainc (lambda, x)) * 1.3f;
+        z = z*v;
+        t = (float)__cr_exp (-lambda + x * logl - (float)__cr_lgamma_integer ((int)(1.0f + x)));
+        if ((z < t) && (v>=1e-20))
+            break;
+    }
+    result.y = (unsigned int)x;
+
+    while (true) {
+        y = curand_uniform(state);
+        x = __cr_pgammaincinv (lambda, y);
+        x = floorf (x);
+        z = curand_uniform (state);
+        v = (__cr_pgammainc (lambda, x + 1.0f) - __cr_pgammainc (lambda, x)) * 1.3f;
+        z = z*v;
+        t = (float)__cr_exp (-lambda + x * logl - (float)__cr_lgamma_integer ((int)(1.0f + x)));
+        if ((z < t) && (v>=1e-20))
+            break;
+    }
+    result.z = (unsigned int)x;
+
+    while (true) {
+        y = curand_uniform(state);
+        x = __cr_pgammaincinv (lambda, y);
+        x = floorf (x);
+        z = curand_uniform (state);
+        v = (__cr_pgammainc (lambda, x + 1.0f) - __cr_pgammainc (lambda, x)) * 1.3f;
+        z = z*v;
+        t = (float)__cr_exp (-lambda + x * logl - (float)__cr_lgamma_integer ((int)(1.0f + x)));
+        if ((z < t) && (v>=1e-20))
+            break;
+    }
+    result.w = (unsigned int)x;
+
+    return result;
+}
+// Note below that the round to nearest integer, where needed,is done in line with code that
+// assumes the range of values is < 2**32
+
+template <typename T>
+QUALIFIERS unsigned int _curand_poisson(T x, double lambda)
+{
+    if (lambda < 1000)
+        return _curand_poisson_ITR_double(x, lambda);
+    return (unsigned int)((sqrt(lambda) * _curand_normal_icdf_double(x)) + lambda + 0.5); //Round to nearest
+}
+
+template <typename T>
+QUALIFIERS unsigned int _curand_poisson_from_normal(T x, double lambda)
+{
+    return (unsigned int)((sqrt(lambda) * _curand_normal_icdf(x)) + lambda + 0.5); //Round to nearest
+}
+
+template <typename STATE>
+QUALIFIERS unsigned int curand_poisson_from_normal(STATE state, double lambda)
+{
+    return (unsigned int)((sqrt(lambda) * curand_normal(state)) + lambda + 0.5); //Round to nearest
+}
+
+template <typename STATE>
+QUALIFIERS uint4 curand_poisson_from_normal4(STATE state, double lambda)
+{
+   uint4 result;
+   float4 _res;
+
+   _res = curand_normal4(state);
+
+   result.x = (unsigned int)((sqrt(lambda) * _res.x) + lambda + 0.5); //Round to nearest
+   result.y = (unsigned int)((sqrt(lambda) * _res.y) + lambda + 0.5); //Round to nearest
+   result.z = (unsigned int)((sqrt(lambda) * _res.z) + lambda + 0.5); //Round to nearest
+   result.w = (unsigned int)((sqrt(lambda) * _res.w) + lambda + 0.5); //Round to nearest
+   return result; //Round to nearest
+}
+
+/**
+ * \brief Return a Poisson-distributed unsigned int from a XORWOW generator.
+ *
+ * Return a single unsigned int from a Poisson
+ * distribution with lambda \p lambda from the XORWOW generator in \p state,
+ * increment the  position of the generator by a variable amount, depending
+ * on the algorithm used.
+ *
+ * \param state - Pointer to state to update
+ * \param lambda - Lambda of the Poisson distribution
+ *
+ * \return Poisson-distributed unsigned int with lambda \p lambda
+ */
+QUALIFIERS unsigned int curand_poisson(curandStateXORWOW_t *state, double lambda)
+{
+    if (lambda < 64)
+        return curand_poisson_knuth(state, (float)lambda);
+    if (lambda > 4000)
+        return (unsigned int)((sqrt(lambda) * curand_normal_double(state)) + lambda + 0.5); //Round to nearest
+    return curand_poisson_gammainc(state, (float)lambda);
+}
+
+/**
+ * \brief Return a Poisson-distributed unsigned int from a Philox4_32_10 generator.
+ *
+ * Return a single unsigned int from a Poisson
+ * distribution with lambda \p lambda from the Philox4_32_10 generator in \p state,
+ * increment the  position of the generator by a variable amount, depending
+ * on the algorithm used.
+ *
+ * \param state - Pointer to state to update
+ * \param lambda - Lambda of the Poisson distribution
+ *
+ * \return Poisson-distributed unsigned int with lambda \p lambda
+ */
+QUALIFIERS unsigned int curand_poisson(curandStatePhilox4_32_10_t *state, double lambda)
+{
+    if (lambda < 64)
+        return curand_poisson_knuth(state, (float)lambda);
+    if (lambda > 4000)
+        return (unsigned int)((sqrt(lambda) * curand_normal_double(state)) + lambda + 0.5); //Round to nearest
+    return curand_poisson_gammainc(state, (float)lambda);
+}
+/**
+ * \brief Return four Poisson-distributed unsigned ints from a Philox4_32_10 generator.
+ *
+ * Return a four unsigned ints from a Poisson
+ * distribution with lambda \p lambda from the Philox4_32_10 generator in \p state,
+ * increment the  position of the generator by a variable amount, depending
+ * on the algorithm used.
+ *
+ * \param state - Pointer to state to update
+ * \param lambda - Lambda of the Poisson distribution
+ *
+ * \return Poisson-distributed unsigned int with lambda \p lambda
+ */
+QUALIFIERS uint4 curand_poisson4(curandStatePhilox4_32_10_t *state, double lambda)
+{
+    uint4 result;
+    double4 _res;
+    if (lambda < 64)
+        return curand_poisson_knuth4(state, (float)lambda);
+    if (lambda > 4000) {
+        _res = curand_normal4_double(state);
+        result.x = (unsigned int)((sqrt(lambda) * _res.x) + lambda + 0.5); //Round to nearest
+        result.y = (unsigned int)((sqrt(lambda) * _res.y) + lambda + 0.5); //Round to nearest
+        result.z = (unsigned int)((sqrt(lambda) * _res.z) + lambda + 0.5); //Round to nearest
+        result.w = (unsigned int)((sqrt(lambda) * _res.w) + lambda + 0.5); //Round to nearest
+    	return result;
+    }
+    return curand_poisson_gammainc4(state, (float)lambda);
+}
+
+
+
+/**
+ * \brief Return a Poisson-distributed unsigned int from a MRG32k3A generator.
+ *
+ * Return a single unsigned int from a Poisson
+ * distribution with lambda \p lambda from the MRG32k3a generator in \p state,
+ * increment the position of the generator by a variable amount, depending
+ * on the algorithm used.
+ *
+ * \param state - Pointer to state to update
+ * \param lambda - Lambda of the Poisson distribution
+ *
+ * \return Poisson-distributed unsigned int with lambda \p lambda
+ */
+QUALIFIERS unsigned int curand_poisson(curandStateMRG32k3a_t *state, double lambda)
+{
+    if (lambda < 64)
+        return curand_poisson_knuth(state, (float)lambda);
+    if (lambda > 4000)
+        return (unsigned int)((sqrt(lambda) * curand_normal_double(state)) + lambda + 0.5); //Round to nearest
+    return curand_poisson_gammainc(state, (float)lambda);
+}
+
+/**
+ * \brief Return a Poisson-distributed unsigned int from a MTGP32 generator.
+ *
+ * Return a single int from a Poisson
+ * distribution with lambda \p lambda from the MTGP32 generator in \p state,
+ * increment the position of the generator by one.
+ *
+ * \param state - Pointer to state to update
+ * \param lambda - Lambda of the Poisson distribution
+ *
+ * \return Poisson-distributed unsigned int with lambda \p lambda
+ */
+QUALIFIERS unsigned int curand_poisson(curandStateMtgp32_t *state, double lambda)
+{
+    return _curand_poisson(curand(state), lambda);
+}
+
+/**
+ * \brief Return a Poisson-distributed unsigned int from a Sobol32 generator.
+ *
+ * Return a single unsigned int from a Poisson
+ * distribution with lambda \p lambda from the Sobol32 generator in \p state,
+ * increment the position of the generator by one.
+ *
+ * \param state - Pointer to state to update
+ * \param lambda - Lambda of the Poisson distribution
+ *
+ * \return Poisson-distributed unsigned int with lambda \p lambda
+ */
+
+QUALIFIERS unsigned int curand_poisson(curandStateSobol32_t *state, double lambda)
+{
+    return _curand_poisson(curand(state), lambda);
+}
+
+/**
+ * \brief Return a Poisson-distributed unsigned int from a scrambled Sobol32 generator.
+ *
+ * Return a single unsigned int from a Poisson
+ * distribution with lambda \p lambda from the scrambled Sobol32 generator in \p state,
+ * increment the position of the generator by one.
+ *
+ * \param state - Pointer to state to update
+ * \param lambda - Lambda of the Poisson distribution
+ *
+ * \return Poisson-distributed unsigned int with lambda \p lambda
+ */
+QUALIFIERS unsigned int curand_poisson(curandStateScrambledSobol32_t *state, double lambda)
+{
+    return _curand_poisson(curand(state), lambda);
+}
+
+/**
+ * \brief Return a Poisson-distributed unsigned int from a Sobol64 generator.
+ *
+ * Return a single unsigned int from a Poisson
+ * distribution with lambda \p lambda from the Sobol64 generator in \p state,
+ * increment position of generator by one.
+ *
+ * \param state - Pointer to state to update
+ * \param lambda - Lambda of the Poisson distribution
+ *
+ * \return Poisson-distributed unsigned int with lambda \p lambda
+ */
+QUALIFIERS unsigned int curand_poisson(curandStateSobol64_t *state, double lambda)
+{
+    return _curand_poisson(curand(state), lambda);
+}
+
+/**
+ * \brief Return a Poisson-distributed unsigned int from a scrambled Sobol64 generator.
+ *
+ * Return a single unsigned int from a Poisson
+ * distribution with lambda \p lambda from the scrambled Sobol64 generator in \p state,
+ * increment position of generator by one.
+ *
+ * \param state - Pointer to state to update
+ * \param lambda - Lambda of the Poisson distribution
+ *
+ * \return Poisson-distributed unsigned int with lambda \p lambda
+ */
+QUALIFIERS unsigned int curand_poisson(curandStateScrambledSobol64_t *state, double lambda)
+{
+    return _curand_poisson(curand(state), lambda);
+}
+#endif // !defined(CURAND_POISSON_H_)

infer_4_37_2/lib/python3.10/site-packages/nvidia/curand/include/curand_uniform.h

@@ -0,0 +1,498 @@
+
+ /* Copyright 2010-2018 NVIDIA Corporation.  All rights reserved.
+  *
+  * NOTICE TO LICENSEE:
+  *
+  * The source code and/or documentation ("Licensed Deliverables") are
+  * subject to NVIDIA intellectual property rights under U.S. and
+  * international Copyright laws.
+  *
+  * The Licensed Deliverables contained herein are PROPRIETARY and
+  * CONFIDENTIAL to NVIDIA and are being provided under the terms and
+  * conditions of a form of NVIDIA software license agreement by and
+  * between NVIDIA and Licensee ("License Agreement") or electronically
+  * accepted by Licensee.  Notwithstanding any terms or conditions to
+  * the contrary in the License Agreement, reproduction or disclosure
+  * of the Licensed Deliverables to any third party without the express
+  * written consent of NVIDIA is prohibited.
+  *
+  * NOTWITHSTANDING ANY TERMS OR CONDITIONS TO THE CONTRARY IN THE
+  * LICENSE AGREEMENT, NVIDIA MAKES NO REPRESENTATION ABOUT THE
+  * SUITABILITY OF THESE LICENSED DELIVERABLES FOR ANY PURPOSE.  THEY ARE
+  * PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY OF ANY KIND.
+  * NVIDIA DISCLAIMS ALL WARRANTIES WITH REGARD TO THESE LICENSED
+  * DELIVERABLES, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY,
+  * NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE.
+  * NOTWITHSTANDING ANY TERMS OR CONDITIONS TO THE CONTRARY IN THE
+  * LICENSE AGREEMENT, IN NO EVENT SHALL NVIDIA BE LIABLE FOR ANY
+  * SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, OR ANY
+  * DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+  * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
+  * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
+  * OF THESE LICENSED DELIVERABLES.
+  *
+  * U.S. Government End Users.  These Licensed Deliverables are a
+  * "commercial item" as that term is defined at 48 C.F.R. 2.101 (OCT
+  * 1995), consisting of "commercial computer software" and "commercial
+  * computer software documentation" as such terms are used in 48
+  * C.F.R. 12.212 (SEPT 1995) and are provided to the U.S. Government
+  * only as a commercial end item.  Consistent with 48 C.F.R.12.212 and
+  * 48 C.F.R. 227.7202-1 through 227.7202-4 (JUNE 1995), all
+  * U.S. Government End Users acquire the Licensed Deliverables with
+  * only those rights set forth herein.
+  *
+  * Any use of the Licensed Deliverables in individual and commercial
+  * software must include, in the user documentation and internal
+  * comments to the code, the above Disclaimer and U.S. Government End
+  * Users Notice.
+  */
+
+
+#if !defined(CURAND_UNIFORM_H_)
+#define CURAND_UNIFORM_H_
+
+/**
+ * \defgroup DEVICE Device API
+ *
+ * @{
+ */
+
+#ifndef __CUDACC_RTC__
+#include <math.h>
+#endif // __CUDACC_RTC__
+
+#include "curand_mrg32k3a.h"
+#include "curand_mtgp32_kernel.h"
+#include "curand_philox4x32_x.h"
+
+
+QUALIFIERS float _curand_uniform(unsigned int x)
+{
+    return x * CURAND_2POW32_INV + (CURAND_2POW32_INV/2.0f);
+}
+
+QUALIFIERS float4 _curand_uniform4(uint4 x)
+{
+    float4 y;
+    y.x = x.x * CURAND_2POW32_INV + (CURAND_2POW32_INV/2.0f);
+    y.y = x.y * CURAND_2POW32_INV + (CURAND_2POW32_INV/2.0f);
+    y.z = x.z * CURAND_2POW32_INV + (CURAND_2POW32_INV/2.0f);
+    y.w = x.w * CURAND_2POW32_INV + (CURAND_2POW32_INV/2.0f);
+    return y;
+}
+
+QUALIFIERS float _curand_uniform(unsigned long long x)
+{
+    unsigned int t;
+    t = (unsigned int)(x >> 32);
+    return t * CURAND_2POW32_INV + (CURAND_2POW32_INV/2.0f);
+}
+
+QUALIFIERS double _curand_uniform_double(unsigned int x)
+{
+    return x * CURAND_2POW32_INV_DOUBLE + CURAND_2POW32_INV_DOUBLE;
+}
+
+QUALIFIERS double _curand_uniform_double(unsigned long long x)
+{
+    return (x >> 11) * CURAND_2POW53_INV_DOUBLE + (CURAND_2POW53_INV_DOUBLE/2.0);
+}
+
+QUALIFIERS double _curand_uniform_double_hq(unsigned int x, unsigned int y)
+{
+    unsigned long long z = (unsigned long long)x ^
+        ((unsigned long long)y << (53 - 32));
+    return z * CURAND_2POW53_INV_DOUBLE + (CURAND_2POW53_INV_DOUBLE/2.0);
+}
+
+QUALIFIERS float curand_uniform(curandStateTest_t *state)
+{
+    return _curand_uniform(curand(state));
+}
+
+QUALIFIERS double curand_uniform_double(curandStateTest_t *state)
+{
+    return _curand_uniform_double(curand(state));
+}
+
+/**
+ * \brief Return a uniformly distributed float from an XORWOW generator.
+ *
+ * Return a uniformly distributed float between \p 0.0f and \p 1.0f
+ * from the XORWOW generator in \p state, increment position of generator.
+ * Output range excludes \p 0.0f but includes \p 1.0f.  Denormalized floating
+ * point outputs are never returned.
+ *
+ * The implementation may use any number of calls to \p curand() to
+ * get enough random bits to create the return value.  The current
+ * implementation uses one call.
+ *
+ * \param state - Pointer to state to update
+ *
+ * \return uniformly distributed float between \p 0.0f and \p 1.0f
+ */
+QUALIFIERS float curand_uniform(curandStateXORWOW_t *state)
+{
+    return _curand_uniform(curand(state));
+}
+
+/**
+ * \brief Return a uniformly distributed double from an XORWOW generator.
+ *
+ * Return a uniformly distributed double between \p 0.0 and \p 1.0
+ * from the XORWOW generator in \p state, increment position of generator.
+ * Output range excludes \p 0.0 but includes \p 1.0.  Denormalized floating
+ * point outputs are never returned.
+ *
+ * The implementation may use any number of calls to \p curand() to
+ * get enough random bits to create the return value.  The current
+ * implementation uses exactly two calls.
+ *
+ * \param state - Pointer to state to update
+ *
+ * \return uniformly distributed double between \p 0.0 and \p 1.0
+ */
+QUALIFIERS double curand_uniform_double(curandStateXORWOW_t *state)
+{
+    unsigned int x, y;
+    x = curand(state);
+    y = curand(state);
+    return _curand_uniform_double_hq(x, y);
+}
+/**
+ * \brief Return a uniformly distributed float from an MRG32k3a generator.
+ *
+ * Return a uniformly distributed float between \p 0.0f and \p 1.0f
+ * from the MRG32k3a generator in \p state, increment position of generator.
+ * Output range excludes \p 0.0f but includes \p 1.0f.  Denormalized floating
+ * point outputs are never returned.
+ *
+ * The implementation returns up to 23 bits of mantissa, with the minimum
+ * return value \f$ 2^{-32} \f$
+ *
+ * \param state - Pointer to state to update
+ *
+ * \return uniformly distributed float between \p 0.0f and \p 1.0f
+ */
+QUALIFIERS float curand_uniform(curandStateMRG32k3a_t *state)
+{
+    return ((float)(curand_MRG32k3a(state)*MRG32K3A_NORM));
+}
+
+/**
+ * \brief Return a uniformly distributed double from an MRG32k3a generator.
+ *
+ * Return a uniformly distributed double between \p 0.0 and \p 1.0
+ * from the MRG32k3a generator in \p state, increment position of generator.
+ * Output range excludes \p 0.0 but includes \p 1.0.  Denormalized floating
+ * point outputs are never returned.
+ *
+ * Note the implementation returns at most 32 random bits of mantissa as
+ * outlined in the seminal paper by L'Ecuyer.
+ *
+ * \param state - Pointer to state to update
+ *
+ * \return uniformly distributed double between \p 0.0 and \p 1.0
+ */
+QUALIFIERS double curand_uniform_double(curandStateMRG32k3a_t *state)
+{
+    return curand_MRG32k3a(state)*MRG32K3A_NORM;
+}
+
+
+
+/**
+ * \brief Return a uniformly distributed tuple of 2 doubles from an Philox4_32_10 generator.
+ *
+ * Return a uniformly distributed 2 doubles (double4) between \p 0.0 and \p 1.0
+ * from the Philox4_32_10 generator in \p state, increment position of generator by 4.
+ * Output range excludes \p 0.0 but includes \p 1.0.  Denormalized floating
+ * point outputs are never returned.
+ *
+ * \param state - Pointer to state to update
+ *
+ * \return 2 uniformly distributed doubles between \p 0.0 and \p 1.0
+ */
+
+QUALIFIERS double2 curand_uniform2_double(curandStatePhilox4_32_10_t *state)
+{
+    uint4 _x;
+    double2 result;
+    _x = curand4(state);
+    result.x = _curand_uniform_double_hq(_x.x,_x.y);
+    result.y = _curand_uniform_double_hq(_x.z,_x.w);
+    return result;
+}
+
+
+// not a part of API
+QUALIFIERS double4 curand_uniform4_double(curandStatePhilox4_32_10_t *state)
+{
+    uint4 _x, _y;
+    double4 result;
+    _x = curand4(state);
+    _y = curand4(state);
+    result.x = _curand_uniform_double_hq(_x.x,_x.y);
+    result.y = _curand_uniform_double_hq(_x.z,_x.w);
+    result.z = _curand_uniform_double_hq(_y.x,_y.y);
+    result.w = _curand_uniform_double_hq(_y.z,_y.w);
+    return result;
+}
+
+/**
+ * \brief Return a uniformly distributed float from a Philox4_32_10 generator.
+ *
+ * Return a uniformly distributed float between \p 0.0f and \p 1.0f
+ * from the Philox4_32_10 generator in \p state, increment position of generator.
+ * Output range excludes \p 0.0f but includes \p 1.0f.  Denormalized floating
+ * point outputs are never returned.
+ *
+ * \param state - Pointer to state to update
+ *
+ * \return uniformly distributed float between \p 0.0 and \p 1.0
+ *
+ */
+QUALIFIERS float curand_uniform(curandStatePhilox4_32_10_t *state)
+{
+   return _curand_uniform(curand(state));
+}
+
+/**
+ * \brief Return a uniformly distributed tuple of 4 floats from a Philox4_32_10 generator.
+ *
+ * Return a uniformly distributed 4 floats between \p 0.0f and \p 1.0f
+ * from the Philox4_32_10 generator in \p state, increment position of generator by 4.
+ * Output range excludes \p 0.0f but includes \p 1.0f.  Denormalized floating
+ * point outputs are never returned.
+ *
+ * \param state - Pointer to state to update
+ *
+ * \return uniformly distributed float between \p 0.0 and \p 1.0
+ *
+ */
+QUALIFIERS float4 curand_uniform4(curandStatePhilox4_32_10_t *state)
+{
+   return _curand_uniform4(curand4(state));
+}
+
+/**
+ * \brief Return a uniformly distributed float from a MTGP32 generator.
+ *
+ * Return a uniformly distributed float between \p 0.0f and \p 1.0f
+ * from the MTGP32 generator in \p state, increment position of generator.
+ * Output range excludes \p 0.0f but includes \p 1.0f.  Denormalized floating
+ * point outputs are never returned.
+ *
+ * \param state - Pointer to state to update
+ *
+ * \return uniformly distributed float between \p 0.0f and \p 1.0f
+ */
+QUALIFIERS float curand_uniform(curandStateMtgp32_t *state)
+{
+    return _curand_uniform(curand(state));
+}
+/**
+ * \brief Return a uniformly distributed double from a MTGP32 generator.
+ *
+ * Return a uniformly distributed double between \p 0.0f and \p 1.0f
+ * from the MTGP32 generator in \p state, increment position of generator.
+ * Output range excludes \p 0.0f but includes \p 1.0f.  Denormalized floating
+ * point outputs are never returned.
+ *
+ * Note that the implementation uses only 32 random bits to generate a single double
+ * precision value.
+ *
+ * \param state - Pointer to state to update
+ *
+ * \return uniformly distributed double between \p 0.0f and \p 1.0f
+ */
+QUALIFIERS double curand_uniform_double(curandStateMtgp32_t *state)
+{
+    return _curand_uniform_double(curand(state));
+}
+
+/**
+ * \brief Return a uniformly distributed double from a Philox4_32_10 generator.
+ *
+ * Return a uniformly distributed double between \p 0.0f and \p 1.0f
+ * from the Philox4_32_10 generator in \p state, increment position of generator.
+ * Output range excludes \p 0.0f but includes \p 1.0f.  Denormalized floating
+ * point outputs are never returned.
+ *
+ * Note that the implementation uses only 32 random bits to generate a single double
+ * precision value.
+ *
+ * \p curand_uniform2_double() is recommended for higher quality uniformly distributed
+ * double precision values.
+ *
+ * \param state - Pointer to state to update
+ *
+ * \return uniformly distributed double between \p 0.0f and \p 1.0f
+ */
+
+QUALIFIERS double curand_uniform_double(curandStatePhilox4_32_10_t *state)
+{
+    return _curand_uniform_double(curand(state));
+}
+
+
+/**
+ * \brief Return a uniformly distributed float from a Sobol32 generator.
+ *
+ * Return a uniformly distributed float between \p 0.0f and \p 1.0f
+ * from the Sobol32 generator in \p state, increment position of generator.
+ * Output range excludes \p 0.0f but includes \p 1.0f.  Denormalized floating
+ * point outputs are never returned.
+ *
+ * The implementation is guaranteed to use a single call to \p curand().
+ *
+ * \param state - Pointer to state to update
+ *
+ * \return uniformly distributed float between \p 0.0f and \p 1.0f
+ */
+QUALIFIERS float curand_uniform(curandStateSobol32_t *state)
+{
+    return _curand_uniform(curand(state));
+}
+
+/**
+ * \brief Return a uniformly distributed double from a Sobol32 generator.
+ *
+ * Return a uniformly distributed double between \p 0.0 and \p 1.0
+ * from the Sobol32 generator in \p state, increment position of generator.
+ * Output range excludes \p 0.0 but includes \p 1.0.  Denormalized floating
+ * point outputs are never returned.
+ *
+ * The implementation is guaranteed to use a single call to \p curand()
+ * to preserve the quasirandom properties of the sequence.
+ *
+ * Note that the implementation uses only 32 random bits to generate a single double
+ * precision value.
+ *
+ * \param state - Pointer to state to update
+ *
+ * \return uniformly distributed double between \p 0.0 and \p 1.0
+ */
+QUALIFIERS double curand_uniform_double(curandStateSobol32_t *state)
+{
+    return _curand_uniform_double(curand(state));
+}
+/**
+ * \brief Return a uniformly distributed float from a scrambled Sobol32 generator.
+ *
+ * Return a uniformly distributed float between \p 0.0f and \p 1.0f
+ * from the scrambled Sobol32 generator in \p state, increment position of generator.
+ * Output range excludes \p 0.0f but includes \p 1.0f.  Denormalized floating
+ * point outputs are never returned.
+ *
+ * The implementation is guaranteed to use a single call to \p curand().
+ *
+ * \param state - Pointer to state to update
+ *
+ * \return uniformly distributed float between \p 0.0f and \p 1.0f
+ */
+QUALIFIERS float curand_uniform(curandStateScrambledSobol32_t *state)
+{
+    return _curand_uniform(curand(state));
+}
+
+/**
+ * \brief Return a uniformly distributed double from a scrambled Sobol32 generator.
+ *
+ * Return a uniformly distributed double between \p 0.0 and \p 1.0
+ * from the scrambled Sobol32 generator in \p state, increment position of generator.
+ * Output range excludes \p 0.0 but includes \p 1.0.  Denormalized floating
+ * point outputs are never returned.
+ *
+ * The implementation is guaranteed to use a single call to \p curand()
+ * to preserve the quasirandom properties of the sequence.
+ *
+ * Note that the implementation uses only 32 random bits to generate a single double
+ * precision value.
+ *
+ * \param state - Pointer to state to update
+ *
+ * \return uniformly distributed double between \p 0.0 and \p 1.0
+ */
+QUALIFIERS double curand_uniform_double(curandStateScrambledSobol32_t *state)
+{
+    return _curand_uniform_double(curand(state));
+}
+/**
+ * \brief Return a uniformly distributed float from a Sobol64 generator.
+ *
+ * Return a uniformly distributed float between \p 0.0f and \p 1.0f
+ * from the Sobol64 generator in \p state, increment position of generator.
+ * Output range excludes \p 0.0f but includes \p 1.0f.  Denormalized floating
+ * point outputs are never returned.
+ *
+ * The implementation is guaranteed to use a single call to \p curand().
+ *
+ * \param state - Pointer to state to update
+ *
+ * \return uniformly distributed float between \p 0.0f and \p 1.0f
+ */
+QUALIFIERS float curand_uniform(curandStateSobol64_t *state)
+{
+    return _curand_uniform(curand(state));
+}
+
+/**
+ * \brief Return a uniformly distributed double from a Sobol64 generator.
+ *
+ * Return a uniformly distributed double between \p 0.0 and \p 1.0
+ * from the Sobol64 generator in \p state, increment position of generator.
+ * Output range excludes \p 0.0 but includes \p 1.0.  Denormalized floating
+ * point outputs are never returned.
+ *
+ * The implementation is guaranteed to use a single call to \p curand()
+ * to preserve the quasirandom properties of the sequence.
+ *
+ * \param state - Pointer to state to update
+ *
+ * \return uniformly distributed double between \p 0.0 and \p 1.0
+ */
+QUALIFIERS double curand_uniform_double(curandStateSobol64_t *state)
+{
+    return _curand_uniform_double(curand(state));
+}
+/**
+ * \brief Return a uniformly distributed float from a scrambled Sobol64 generator.
+ *
+ * Return a uniformly distributed float between \p 0.0f and \p 1.0f
+ * from the scrambled Sobol64 generator in \p state, increment position of generator.
+ * Output range excludes \p 0.0f but includes \p 1.0f.  Denormalized floating
+ * point outputs are never returned.
+ *
+ * The implementation is guaranteed to use a single call to \p curand().
+ *
+ * \param state - Pointer to state to update
+ *
+ * \return uniformly distributed float between \p 0.0f and \p 1.0f
+ */
+QUALIFIERS float curand_uniform(curandStateScrambledSobol64_t *state)
+{
+    return _curand_uniform(curand(state));
+}
+
+/**
+ * \brief Return a uniformly distributed double from a scrambled Sobol64 generator.
+ *
+ * Return a uniformly distributed double between \p 0.0 and \p 1.0
+ * from the scrambled Sobol64 generator in \p state, increment position of generator.
+ * Output range excludes \p 0.0 but includes \p 1.0.  Denormalized floating
+ * point outputs are never returned.
+ *
+ * The implementation is guaranteed to use a single call to \p curand()
+ * to preserve the quasirandom properties of the sequence.
+ *
+ * \param state - Pointer to state to update
+ *
+ * \return uniformly distributed double between \p 0.0 and \p 1.0
+ */
+QUALIFIERS double curand_uniform_double(curandStateScrambledSobol64_t *state)
+{
+    return _curand_uniform_double(curand(state));
+}
+
+#endif // !defined(CURAND_UNIFORM_H_)

infer_4_37_2/lib/python3.10/site-packages/nvidia/curand/lib/libcurand.so.10

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dab8074b610b82a863a42eceda788e9b08364b545bab948509306b48c46018cf
+size 96525744

infer_4_37_2/lib/python3.10/site-packages/pandas/_libs/algos.cpython-310-x86_64-linux-gnu.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e428449e985790af8faa2227d6c2c989c54cc093110f476200d68f36b4a524df
+size 2194056

infer_4_37_2/lib/python3.10/site-packages/pandas/_libs/arrays.cpython-310-x86_64-linux-gnu.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d7d4536852551fda02d7d1b2d2f4aaf559877db06a6a40e8d5fa73bc0e1d048c
+size 133184

infer_4_37_2/lib/python3.10/site-packages/pandas/_libs/arrays.pyi

@@ -0,0 +1,40 @@
+from typing import Sequence
+
+import numpy as np
+
+from pandas._typing import (
+    AxisInt,
+    DtypeObj,
+    Self,
+    Shape,
+)
+
+class NDArrayBacked:
+    _dtype: DtypeObj
+    _ndarray: np.ndarray
+    def __init__(self, values: np.ndarray, dtype: DtypeObj) -> None: ...
+    @classmethod
+    def _simple_new(cls, values: np.ndarray, dtype: DtypeObj): ...
+    def _from_backing_data(self, values: np.ndarray): ...
+    def __setstate__(self, state): ...
+    def __len__(self) -> int: ...
+    @property
+    def shape(self) -> Shape: ...
+    @property
+    def ndim(self) -> int: ...
+    @property
+    def size(self) -> int: ...
+    @property
+    def nbytes(self) -> int: ...
+    def copy(self, order=...): ...
+    def delete(self, loc, axis=...): ...
+    def swapaxes(self, axis1, axis2): ...
+    def repeat(self, repeats: int | Sequence[int], axis: int | None = ...): ...
+    def reshape(self, *args, **kwargs): ...
+    def ravel(self, order=...): ...
+    @property
+    def T(self): ...
+    @classmethod
+    def _concat_same_type(
+        cls, to_concat: Sequence[Self], axis: AxisInt = ...
+    ) -> Self: ...

infer_4_37_2/lib/python3.10/site-packages/pandas/_libs/hashing.pyi

@@ -0,0 +1,9 @@
+import numpy as np
+
+from pandas._typing import npt
+
+def hash_object_array(
+    arr: npt.NDArray[np.object_],
+    key: str,
+    encoding: str = ...,
+) -> npt.NDArray[np.uint64]: ...

infer_4_37_2/lib/python3.10/site-packages/pandas/_libs/lib.pyi

@@ -0,0 +1,213 @@
+# TODO(npdtypes): Many types specified here can be made more specific/accurate;
+#  the more specific versions are specified in comments
+from decimal import Decimal
+from typing import (
+    Any,
+    Callable,
+    Final,
+    Generator,
+    Hashable,
+    Literal,
+    TypeAlias,
+    overload,
+)
+
+import numpy as np
+
+from pandas._libs.interval import Interval
+from pandas._libs.tslibs import Period
+from pandas._typing import (
+    ArrayLike,
+    DtypeObj,
+    TypeGuard,
+    npt,
+)
+
+# placeholder until we can specify np.ndarray[object, ndim=2]
+ndarray_obj_2d = np.ndarray
+
+from enum import Enum
+
+class _NoDefault(Enum):
+    no_default = ...
+
+no_default: Final = _NoDefault.no_default
+NoDefault: TypeAlias = Literal[_NoDefault.no_default]
+
+i8max: int
+u8max: int
+
+def is_np_dtype(dtype: object, kinds: str | None = ...) -> TypeGuard[np.dtype]: ...
+def item_from_zerodim(val: object) -> object: ...
+def infer_dtype(value: object, skipna: bool = ...) -> str: ...
+def is_iterator(obj: object) -> bool: ...
+def is_scalar(val: object) -> bool: ...
+def is_list_like(obj: object, allow_sets: bool = ...) -> bool: ...
+def is_pyarrow_array(obj: object) -> bool: ...
+def is_period(val: object) -> TypeGuard[Period]: ...
+def is_interval(obj: object) -> TypeGuard[Interval]: ...
+def is_decimal(obj: object) -> TypeGuard[Decimal]: ...
+def is_complex(obj: object) -> TypeGuard[complex]: ...
+def is_bool(obj: object) -> TypeGuard[bool | np.bool_]: ...
+def is_integer(obj: object) -> TypeGuard[int | np.integer]: ...
+def is_int_or_none(obj) -> bool: ...
+def is_float(obj: object) -> TypeGuard[float]: ...
+def is_interval_array(values: np.ndarray) -> bool: ...
+def is_datetime64_array(values: np.ndarray, skipna: bool = True) -> bool: ...
+def is_timedelta_or_timedelta64_array(
+    values: np.ndarray, skipna: bool = True
+) -> bool: ...
+def is_datetime_with_singletz_array(values: np.ndarray) -> bool: ...
+def is_time_array(values: np.ndarray, skipna: bool = ...): ...
+def is_date_array(values: np.ndarray, skipna: bool = ...): ...
+def is_datetime_array(values: np.ndarray, skipna: bool = ...): ...
+def is_string_array(values: np.ndarray, skipna: bool = ...): ...
+def is_float_array(values: np.ndarray): ...
+def is_integer_array(values: np.ndarray, skipna: bool = ...): ...
+def is_bool_array(values: np.ndarray, skipna: bool = ...): ...
+def fast_multiget(
+    mapping: dict,
+    keys: np.ndarray,  # object[:]
+    default=...,
+) -> np.ndarray: ...
+def fast_unique_multiple_list_gen(gen: Generator, sort: bool = ...) -> list: ...
+def fast_unique_multiple_list(lists: list, sort: bool | None = ...) -> list: ...
+def map_infer(
+    arr: np.ndarray,
+    f: Callable[[Any], Any],
+    convert: bool = ...,
+    ignore_na: bool = ...,
+) -> np.ndarray: ...
+@overload
+def maybe_convert_objects(
+    objects: npt.NDArray[np.object_],
+    *,
+    try_float: bool = ...,
+    safe: bool = ...,
+    convert_numeric: bool = ...,
+    convert_non_numeric: Literal[False] = ...,
+    convert_to_nullable_dtype: Literal[False] = ...,
+    dtype_if_all_nat: DtypeObj | None = ...,
+) -> npt.NDArray[np.object_ | np.number]: ...
+@overload
+def maybe_convert_objects(
+    objects: npt.NDArray[np.object_],
+    *,
+    try_float: bool = ...,
+    safe: bool = ...,
+    convert_numeric: bool = ...,
+    convert_non_numeric: bool = ...,
+    convert_to_nullable_dtype: Literal[True] = ...,
+    dtype_if_all_nat: DtypeObj | None = ...,
+) -> ArrayLike: ...
+@overload
+def maybe_convert_objects(
+    objects: npt.NDArray[np.object_],
+    *,
+    try_float: bool = ...,
+    safe: bool = ...,
+    convert_numeric: bool = ...,
+    convert_non_numeric: bool = ...,
+    convert_to_nullable_dtype: bool = ...,
+    dtype_if_all_nat: DtypeObj | None = ...,
+) -> ArrayLike: ...
+@overload
+def maybe_convert_numeric(
+    values: npt.NDArray[np.object_],
+    na_values: set,
+    convert_empty: bool = ...,
+    coerce_numeric: bool = ...,
+    convert_to_masked_nullable: Literal[False] = ...,
+) -> tuple[np.ndarray, None]: ...
+@overload
+def maybe_convert_numeric(
+    values: npt.NDArray[np.object_],
+    na_values: set,
+    convert_empty: bool = ...,
+    coerce_numeric: bool = ...,
+    *,
+    convert_to_masked_nullable: Literal[True],
+) -> tuple[np.ndarray, np.ndarray]: ...
+
+# TODO: restrict `arr`?
+def ensure_string_array(
+    arr,
+    na_value: object = ...,
+    convert_na_value: bool = ...,
+    copy: bool = ...,
+    skipna: bool = ...,
+) -> npt.NDArray[np.object_]: ...
+def convert_nans_to_NA(
+    arr: npt.NDArray[np.object_],
+) -> npt.NDArray[np.object_]: ...
+def fast_zip(ndarrays: list) -> npt.NDArray[np.object_]: ...
+
+# TODO: can we be more specific about rows?
+def to_object_array_tuples(rows: object) -> ndarray_obj_2d: ...
+def tuples_to_object_array(
+    tuples: npt.NDArray[np.object_],
+) -> ndarray_obj_2d: ...
+
+# TODO: can we be more specific about rows?
+def to_object_array(rows: object, min_width: int = ...) -> ndarray_obj_2d: ...
+def dicts_to_array(dicts: list, columns: list) -> ndarray_obj_2d: ...
+def maybe_booleans_to_slice(
+    mask: npt.NDArray[np.uint8],
+) -> slice | npt.NDArray[np.uint8]: ...
+def maybe_indices_to_slice(
+    indices: npt.NDArray[np.intp],
+    max_len: int,
+) -> slice | npt.NDArray[np.intp]: ...
+def is_all_arraylike(obj: list) -> bool: ...
+
+# -----------------------------------------------------------------
+# Functions which in reality take memoryviews
+
+def memory_usage_of_objects(arr: np.ndarray) -> int: ...  # object[:]  # np.int64
+def map_infer_mask(
+    arr: np.ndarray,
+    f: Callable[[Any], Any],
+    mask: np.ndarray,  # const uint8_t[:]
+    convert: bool = ...,
+    na_value: Any = ...,
+    dtype: np.dtype = ...,
+) -> np.ndarray: ...
+def indices_fast(
+    index: npt.NDArray[np.intp],
+    labels: np.ndarray,  # const int64_t[:]
+    keys: list,
+    sorted_labels: list[npt.NDArray[np.int64]],
+) -> dict[Hashable, npt.NDArray[np.intp]]: ...
+def generate_slices(
+    labels: np.ndarray, ngroups: int  # const intp_t[:]
+) -> tuple[npt.NDArray[np.int64], npt.NDArray[np.int64]]: ...
+def count_level_2d(
+    mask: np.ndarray,  # ndarray[uint8_t, ndim=2, cast=True],
+    labels: np.ndarray,  # const intp_t[:]
+    max_bin: int,
+) -> np.ndarray: ...  # np.ndarray[np.int64, ndim=2]
+def get_level_sorter(
+    codes: np.ndarray,  # const int64_t[:]
+    starts: np.ndarray,  # const intp_t[:]
+) -> np.ndarray: ...  # np.ndarray[np.intp, ndim=1]
+def generate_bins_dt64(
+    values: npt.NDArray[np.int64],
+    binner: np.ndarray,  # const int64_t[:]
+    closed: object = ...,
+    hasnans: bool = ...,
+) -> np.ndarray: ...  # np.ndarray[np.int64, ndim=1]
+def array_equivalent_object(
+    left: npt.NDArray[np.object_],
+    right: npt.NDArray[np.object_],
+) -> bool: ...
+def has_infs(arr: np.ndarray) -> bool: ...  # const floating[:]
+def has_only_ints_or_nan(arr: np.ndarray) -> bool: ...  # const floating[:]
+def get_reverse_indexer(
+    indexer: np.ndarray,  # const intp_t[:]
+    length: int,
+) -> npt.NDArray[np.intp]: ...
+def is_bool_list(obj: list) -> bool: ...
+def dtypes_all_equal(types: list[DtypeObj]) -> bool: ...
+def is_range_indexer(
+    left: np.ndarray, n: int  # np.ndarray[np.int64, ndim=1]
+) -> bool: ...

infer_4_37_2/lib/python3.10/site-packages/pandas/_libs/parsers.cpython-310-x86_64-linux-gnu.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c9e1a4899b63e3a9a6431882897273d1797a9c2d2baff27406c8b8211eceaf34
+size 594760

infer_4_37_2/lib/python3.10/site-packages/pandas/_libs/properties.pyi

@@ -0,0 +1,27 @@
+from typing import (
+    Sequence,
+    overload,
+)
+
+from pandas._typing import (
+    AnyArrayLike,
+    DataFrame,
+    Index,
+    Series,
+)
+
+# note: this is a lie to make type checkers happy (they special
+# case property). cache_readonly uses attribute names similar to
+# property (fget) but it does not provide fset and fdel.
+cache_readonly = property
+
+class AxisProperty:
+    axis: int
+    def __init__(self, axis: int = ..., doc: str = ...) -> None: ...
+    @overload
+    def __get__(self, obj: DataFrame | Series, type) -> Index: ...
+    @overload
+    def __get__(self, obj: None, type) -> AxisProperty: ...
+    def __set__(
+        self, obj: DataFrame | Series, value: AnyArrayLike | Sequence
+    ) -> None: ...

infer_4_37_2/lib/python3.10/site-packages/pandas/_libs/tslib.pyi

@@ -0,0 +1,37 @@
+from datetime import tzinfo
+
+import numpy as np
+
+from pandas._typing import npt
+
+def format_array_from_datetime(
+    values: npt.NDArray[np.int64],
+    tz: tzinfo | None = ...,
+    format: str | None = ...,
+    na_rep: str | float = ...,
+    reso: int = ...,  # NPY_DATETIMEUNIT
+) -> npt.NDArray[np.object_]: ...
+def array_with_unit_to_datetime(
+    values: npt.NDArray[np.object_],
+    unit: str,
+    errors: str = ...,
+) -> tuple[np.ndarray, tzinfo | None]: ...
+def first_non_null(values: np.ndarray) -> int: ...
+def array_to_datetime(
+    values: npt.NDArray[np.object_],
+    errors: str = ...,
+    dayfirst: bool = ...,
+    yearfirst: bool = ...,
+    utc: bool = ...,
+    creso: int = ...,
+) -> tuple[np.ndarray, tzinfo | None]: ...
+
+# returned ndarray may be object dtype or datetime64[ns]
+
+def array_to_datetime_with_tz(
+    values: npt.NDArray[np.object_],
+    tz: tzinfo,
+    dayfirst: bool,
+    yearfirst: bool,
+    creso: int,
+) -> npt.NDArray[np.int64]: ...

janus/lib/python3.10/site-packages/sympy/codegen/__init__.py

@@ -0,0 +1,24 @@
+""" The ``sympy.codegen`` module contains classes and functions for building
+abstract syntax trees of algorithms. These trees may then be printed by the
+code-printers in ``sympy.printing``.
+
+There are several submodules available:
+- ``sympy.codegen.ast``: AST nodes useful across multiple languages.
+- ``sympy.codegen.cnodes``: AST nodes useful for the C family of languages.
+- ``sympy.codegen.fnodes``: AST nodes useful for Fortran.
+- ``sympy.codegen.cfunctions``: functions specific to C (C99 math functions)
+- ``sympy.codegen.ffunctions``: functions specific to Fortran (e.g. ``kind``).
+
+
+
+"""
+from .ast import (
+    Assignment, aug_assign, CodeBlock, For, Attribute, Variable, Declaration,
+    While, Scope, Print, FunctionPrototype, FunctionDefinition, FunctionCall
+)
+
+__all__ = [
+    'Assignment', 'aug_assign', 'CodeBlock', 'For', 'Attribute', 'Variable',
+    'Declaration', 'While', 'Scope', 'Print', 'FunctionPrototype',
+    'FunctionDefinition', 'FunctionCall',
+]

janus/lib/python3.10/site-packages/sympy/codegen/abstract_nodes.py

@@ -0,0 +1,18 @@
+"""This module provides containers for python objects that are valid
+printing targets but are not a subclass of SymPy's Printable.
+"""
+
+
+from sympy.core.containers import Tuple
+
+
+class List(Tuple):
+    """Represents a (frozen) (Python) list (for code printing purposes)."""
+    def __eq__(self, other):
+        if isinstance(other, list):
+            return self == List(*other)
+        else:
+            return self.args == other
+
+    def __hash__(self):
+        return super().__hash__()

janus/lib/python3.10/site-packages/sympy/codegen/approximations.py

@@ -0,0 +1,187 @@
+import math
+from sympy.sets.sets import Interval
+from sympy.calculus.singularities import is_increasing, is_decreasing
+from sympy.codegen.rewriting import Optimization
+from sympy.core.function import UndefinedFunction
+
+"""
+This module collects classes useful for approimate rewriting of expressions.
+This can be beneficial when generating numeric code for which performance is
+of greater importance than precision (e.g. for preconditioners used in iterative
+methods).
+"""
+
+class SumApprox(Optimization):
+    """
+    Approximates sum by neglecting small terms.
+
+    Explanation
+    ===========
+
+    If terms are expressions which can be determined to be monotonic, then
+    bounds for those expressions are added.
+
+    Parameters
+    ==========
+
+    bounds : dict
+        Mapping expressions to length 2 tuple of bounds (low, high).
+    reltol : number
+        Threshold for when to ignore a term. Taken relative to the largest
+        lower bound among bounds.
+
+    Examples
+    ========
+
+    >>> from sympy import exp
+    >>> from sympy.abc import x, y, z
+    >>> from sympy.codegen.rewriting import optimize
+    >>> from sympy.codegen.approximations import SumApprox
+    >>> bounds = {x: (-1, 1), y: (1000, 2000), z: (-10, 3)}
+    >>> sum_approx3 = SumApprox(bounds, reltol=1e-3)
+    >>> sum_approx2 = SumApprox(bounds, reltol=1e-2)
+    >>> sum_approx1 = SumApprox(bounds, reltol=1e-1)
+    >>> expr = 3*(x + y + exp(z))
+    >>> optimize(expr, [sum_approx3])
+    3*(x + y + exp(z))
+    >>> optimize(expr, [sum_approx2])
+    3*y + 3*exp(z)
+    >>> optimize(expr, [sum_approx1])
+    3*y
+
+    """
+
+    def __init__(self, bounds, reltol, **kwargs):
+        super().__init__(**kwargs)
+        self.bounds = bounds
+        self.reltol = reltol
+
+    def __call__(self, expr):
+        return expr.factor().replace(self.query, lambda arg: self.value(arg))
+
+    def query(self, expr):
+        return expr.is_Add
+
+    def value(self, add):
+        for term in add.args:
+            if term.is_number or term in self.bounds or len(term.free_symbols) != 1:
+                continue
+            fs, = term.free_symbols
+            if fs not in self.bounds:
+                continue
+            intrvl = Interval(*self.bounds[fs])
+            if is_increasing(term, intrvl, fs):
+                self.bounds[term] = (
+                    term.subs({fs: self.bounds[fs][0]}),
+                    term.subs({fs: self.bounds[fs][1]})
+                )
+            elif is_decreasing(term, intrvl, fs):
+                self.bounds[term] = (
+                    term.subs({fs: self.bounds[fs][1]}),
+                    term.subs({fs: self.bounds[fs][0]})
+                )
+            else:
+                return add
+
+        if all(term.is_number or term in self.bounds for term in add.args):
+            bounds = [(term, term) if term.is_number else self.bounds[term] for term in add.args]
+            largest_abs_guarantee = 0
+            for lo, hi in bounds:
+                if lo <= 0 <= hi:
+                    continue
+                largest_abs_guarantee = max(largest_abs_guarantee,
+                                            min(abs(lo), abs(hi)))
+            new_terms = []
+            for term, (lo, hi) in zip(add.args, bounds):
+                if max(abs(lo), abs(hi)) >= largest_abs_guarantee*self.reltol:
+                    new_terms.append(term)
+            return add.func(*new_terms)
+        else:
+            return add
+
+
+class SeriesApprox(Optimization):
+    """ Approximates functions by expanding them as a series.
+
+    Parameters
+    ==========
+
+    bounds : dict
+        Mapping expressions to length 2 tuple of bounds (low, high).
+    reltol : number
+        Threshold for when to ignore a term. Taken relative to the largest
+        lower bound among bounds.
+    max_order : int
+        Largest order to include in series expansion
+    n_point_checks : int (even)
+        The validity of an expansion (with respect to reltol) is checked at
+        discrete points (linearly spaced over the bounds of the variable). The
+        number of points used in this numerical check is given by this number.
+
+    Examples
+    ========
+
+    >>> from sympy import sin, pi
+    >>> from sympy.abc import x, y
+    >>> from sympy.codegen.rewriting import optimize
+    >>> from sympy.codegen.approximations import SeriesApprox
+    >>> bounds = {x: (-.1, .1), y: (pi-1, pi+1)}
+    >>> series_approx2 = SeriesApprox(bounds, reltol=1e-2)
+    >>> series_approx3 = SeriesApprox(bounds, reltol=1e-3)
+    >>> series_approx8 = SeriesApprox(bounds, reltol=1e-8)
+    >>> expr = sin(x)*sin(y)
+    >>> optimize(expr, [series_approx2])
+    x*(-y + (y - pi)**3/6 + pi)
+    >>> optimize(expr, [series_approx3])
+    (-x**3/6 + x)*sin(y)
+    >>> optimize(expr, [series_approx8])
+    sin(x)*sin(y)
+
+    """
+    def __init__(self, bounds, reltol, max_order=4, n_point_checks=4, **kwargs):
+        super().__init__(**kwargs)
+        self.bounds = bounds
+        self.reltol = reltol
+        self.max_order = max_order
+        if n_point_checks % 2 == 1:
+            raise ValueError("Checking the solution at expansion point is not helpful")
+        self.n_point_checks = n_point_checks
+        self._prec = math.ceil(-math.log10(self.reltol))
+
+    def __call__(self, expr):
+        return expr.factor().replace(self.query, lambda arg: self.value(arg))
+
+    def query(self, expr):
+        return (expr.is_Function and not isinstance(expr, UndefinedFunction)
+                and len(expr.args) == 1)
+
+    def value(self, fexpr):
+        free_symbols = fexpr.free_symbols
+        if len(free_symbols) != 1:
+            return fexpr
+        symb, = free_symbols
+        if symb not in self.bounds:
+            return fexpr
+        lo, hi = self.bounds[symb]
+        x0 = (lo + hi)/2
+        cheapest = None
+        for n in range(self.max_order+1, 0, -1):
+            fseri = fexpr.series(symb, x0=x0, n=n).removeO()
+            n_ok = True
+            for idx in range(self.n_point_checks):
+                x = lo + idx*(hi - lo)/(self.n_point_checks - 1)
+                val = fseri.xreplace({symb: x})
+                ref = fexpr.xreplace({symb: x})
+                if abs((1 - val/ref).evalf(self._prec)) > self.reltol:
+                    n_ok = False
+                    break
+
+            if n_ok:
+                cheapest = fseri
+            else:
+                break
+
+        if cheapest is None:
+            return fexpr
+        else:
+            return cheapest

janus/lib/python3.10/site-packages/sympy/codegen/cfunctions.py

@@ -0,0 +1,536 @@
+"""
+This module contains SymPy functions mathcin corresponding to special math functions in the
+C standard library (since C99, also available in C++11).
+
+The functions defined in this module allows the user to express functions such as ``expm1``
+as a SymPy function for symbolic manipulation.
+
+"""
+from sympy.core.function import ArgumentIndexError, Function
+from sympy.core.numbers import Rational
+from sympy.core.power import Pow
+from sympy.core.singleton import S
+from sympy.functions.elementary.exponential import exp, log
+from sympy.functions.elementary.miscellaneous import sqrt
+
+
+def _expm1(x):
+    return exp(x) - S.One
+
+
+class expm1(Function):
+    """
+    Represents the exponential function minus one.
+
+    Explanation
+    ===========
+
+    The benefit of using ``expm1(x)`` over ``exp(x) - 1``
+    is that the latter is prone to cancellation under finite precision
+    arithmetic when x is close to zero.
+
+    Examples
+    ========
+
+    >>> from sympy.abc import x
+    >>> from sympy.codegen.cfunctions import expm1
+    >>> '%.0e' % expm1(1e-99).evalf()
+    '1e-99'
+    >>> from math import exp
+    >>> exp(1e-99) - 1
+    0.0
+    >>> expm1(x).diff(x)
+    exp(x)
+
+    See Also
+    ========
+
+    log1p
+    """
+    nargs = 1
+
+    def fdiff(self, argindex=1):
+        """
+        Returns the first derivative of this function.
+        """
+        if argindex == 1:
+            return exp(*self.args)
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def _eval_expand_func(self, **hints):
+        return _expm1(*self.args)
+
+    def _eval_rewrite_as_exp(self, arg, **kwargs):
+        return exp(arg) - S.One
+
+    _eval_rewrite_as_tractable = _eval_rewrite_as_exp
+
+    @classmethod
+    def eval(cls, arg):
+        exp_arg = exp.eval(arg)
+        if exp_arg is not None:
+            return exp_arg - S.One
+
+    def _eval_is_real(self):
+        return self.args[0].is_real
+
+    def _eval_is_finite(self):
+        return self.args[0].is_finite
+
+
+def _log1p(x):
+    return log(x + S.One)
+
+
+class log1p(Function):
+    """
+    Represents the natural logarithm of a number plus one.
+
+    Explanation
+    ===========
+
+    The benefit of using ``log1p(x)`` over ``log(x + 1)``
+    is that the latter is prone to cancellation under finite precision
+    arithmetic when x is close to zero.
+
+    Examples
+    ========
+
+    >>> from sympy.abc import x
+    >>> from sympy.codegen.cfunctions import log1p
+    >>> from sympy import expand_log
+    >>> '%.0e' % expand_log(log1p(1e-99)).evalf()
+    '1e-99'
+    >>> from math import log
+    >>> log(1 + 1e-99)
+    0.0
+    >>> log1p(x).diff(x)
+    1/(x + 1)
+
+    See Also
+    ========
+
+    expm1
+    """
+    nargs = 1
+
+
+    def fdiff(self, argindex=1):
+        """
+        Returns the first derivative of this function.
+        """
+        if argindex == 1:
+            return S.One/(self.args[0] + S.One)
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+
+    def _eval_expand_func(self, **hints):
+        return _log1p(*self.args)
+
+    def _eval_rewrite_as_log(self, arg, **kwargs):
+        return _log1p(arg)
+
+    _eval_rewrite_as_tractable = _eval_rewrite_as_log
+
+    @classmethod
+    def eval(cls, arg):
+        if arg.is_Rational:
+            return log(arg + S.One)
+        elif not arg.is_Float:  # not safe to add 1 to Float
+            return log.eval(arg + S.One)
+        elif arg.is_number:
+            return log(Rational(arg) + S.One)
+
+    def _eval_is_real(self):
+        return (self.args[0] + S.One).is_nonnegative
+
+    def _eval_is_finite(self):
+        if (self.args[0] + S.One).is_zero:
+            return False
+        return self.args[0].is_finite
+
+    def _eval_is_positive(self):
+        return self.args[0].is_positive
+
+    def _eval_is_zero(self):
+        return self.args[0].is_zero
+
+    def _eval_is_nonnegative(self):
+        return self.args[0].is_nonnegative
+
+_Two = S(2)
+
+def _exp2(x):
+    return Pow(_Two, x)
+
+class exp2(Function):
+    """
+    Represents the exponential function with base two.
+
+    Explanation
+    ===========
+
+    The benefit of using ``exp2(x)`` over ``2**x``
+    is that the latter is not as efficient under finite precision
+    arithmetic.
+
+    Examples
+    ========
+
+    >>> from sympy.abc import x
+    >>> from sympy.codegen.cfunctions import exp2
+    >>> exp2(2).evalf() == 4.0
+    True
+    >>> exp2(x).diff(x)
+    log(2)*exp2(x)
+
+    See Also
+    ========
+
+    log2
+    """
+    nargs = 1
+
+
+    def fdiff(self, argindex=1):
+        """
+        Returns the first derivative of this function.
+        """
+        if argindex == 1:
+            return self*log(_Two)
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def _eval_rewrite_as_Pow(self, arg, **kwargs):
+        return _exp2(arg)
+
+    _eval_rewrite_as_tractable = _eval_rewrite_as_Pow
+
+    def _eval_expand_func(self, **hints):
+        return _exp2(*self.args)
+
+    @classmethod
+    def eval(cls, arg):
+        if arg.is_number:
+            return _exp2(arg)
+
+
+def _log2(x):
+    return log(x)/log(_Two)
+
+
+class log2(Function):
+    """
+    Represents the logarithm function with base two.
+
+    Explanation
+    ===========
+
+    The benefit of using ``log2(x)`` over ``log(x)/log(2)``
+    is that the latter is not as efficient under finite precision
+    arithmetic.
+
+    Examples
+    ========
+
+    >>> from sympy.abc import x
+    >>> from sympy.codegen.cfunctions import log2
+    >>> log2(4).evalf() == 2.0
+    True
+    >>> log2(x).diff(x)
+    1/(x*log(2))
+
+    See Also
+    ========
+
+    exp2
+    log10
+    """
+    nargs = 1
+
+    def fdiff(self, argindex=1):
+        """
+        Returns the first derivative of this function.
+        """
+        if argindex == 1:
+            return S.One/(log(_Two)*self.args[0])
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+
+    @classmethod
+    def eval(cls, arg):
+        if arg.is_number:
+            result = log.eval(arg, base=_Two)
+            if result.is_Atom:
+                return result
+        elif arg.is_Pow and arg.base == _Two:
+            return arg.exp
+
+    def _eval_evalf(self, *args, **kwargs):
+        return self.rewrite(log).evalf(*args, **kwargs)
+
+    def _eval_expand_func(self, **hints):
+        return _log2(*self.args)
+
+    def _eval_rewrite_as_log(self, arg, **kwargs):
+        return _log2(arg)
+
+    _eval_rewrite_as_tractable = _eval_rewrite_as_log
+
+
+def _fma(x, y, z):
+    return x*y + z
+
+
+class fma(Function):
+    """
+    Represents "fused multiply add".
+
+    Explanation
+    ===========
+
+    The benefit of using ``fma(x, y, z)`` over ``x*y + z``
+    is that, under finite precision arithmetic, the former is
+    supported by special instructions on some CPUs.
+
+    Examples
+    ========
+
+    >>> from sympy.abc import x, y, z
+    >>> from sympy.codegen.cfunctions import fma
+    >>> fma(x, y, z).diff(x)
+    y
+
+    """
+    nargs = 3
+
+    def fdiff(self, argindex=1):
+        """
+        Returns the first derivative of this function.
+        """
+        if argindex in (1, 2):
+            return self.args[2 - argindex]
+        elif argindex == 3:
+            return S.One
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+
+    def _eval_expand_func(self, **hints):
+        return _fma(*self.args)
+
+    def _eval_rewrite_as_tractable(self, arg, limitvar=None, **kwargs):
+        return _fma(arg)
+
+
+_Ten = S(10)
+
+
+def _log10(x):
+    return log(x)/log(_Ten)
+
+
+class log10(Function):
+    """
+    Represents the logarithm function with base ten.
+
+    Examples
+    ========
+
+    >>> from sympy.abc import x
+    >>> from sympy.codegen.cfunctions import log10
+    >>> log10(100).evalf() == 2.0
+    True
+    >>> log10(x).diff(x)
+    1/(x*log(10))
+
+    See Also
+    ========
+
+    log2
+    """
+    nargs = 1
+
+    def fdiff(self, argindex=1):
+        """
+        Returns the first derivative of this function.
+        """
+        if argindex == 1:
+            return S.One/(log(_Ten)*self.args[0])
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+
+    @classmethod
+    def eval(cls, arg):
+        if arg.is_number:
+            result = log.eval(arg, base=_Ten)
+            if result.is_Atom:
+                return result
+        elif arg.is_Pow and arg.base == _Ten:
+            return arg.exp
+
+    def _eval_expand_func(self, **hints):
+        return _log10(*self.args)
+
+    def _eval_rewrite_as_log(self, arg, **kwargs):
+        return _log10(arg)
+
+    _eval_rewrite_as_tractable = _eval_rewrite_as_log
+
+
+def _Sqrt(x):
+    return Pow(x, S.Half)
+
+
+class Sqrt(Function):  # 'sqrt' already defined in sympy.functions.elementary.miscellaneous
+    """
+    Represents the square root function.
+
+    Explanation
+    ===========
+
+    The reason why one would use ``Sqrt(x)`` over ``sqrt(x)``
+    is that the latter is internally represented as ``Pow(x, S.Half)`` which
+    may not be what one wants when doing code-generation.
+
+    Examples
+    ========
+
+    >>> from sympy.abc import x
+    >>> from sympy.codegen.cfunctions import Sqrt
+    >>> Sqrt(x)
+    Sqrt(x)
+    >>> Sqrt(x).diff(x)
+    1/(2*sqrt(x))
+
+    See Also
+    ========
+
+    Cbrt
+    """
+    nargs = 1
+
+    def fdiff(self, argindex=1):
+        """
+        Returns the first derivative of this function.
+        """
+        if argindex == 1:
+            return Pow(self.args[0], Rational(-1, 2))/_Two
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def _eval_expand_func(self, **hints):
+        return _Sqrt(*self.args)
+
+    def _eval_rewrite_as_Pow(self, arg, **kwargs):
+        return _Sqrt(arg)
+
+    _eval_rewrite_as_tractable = _eval_rewrite_as_Pow
+
+
+def _Cbrt(x):
+    return Pow(x, Rational(1, 3))
+
+
+class Cbrt(Function):  # 'cbrt' already defined in sympy.functions.elementary.miscellaneous
+    """
+    Represents the cube root function.
+
+    Explanation
+    ===========
+
+    The reason why one would use ``Cbrt(x)`` over ``cbrt(x)``
+    is that the latter is internally represented as ``Pow(x, Rational(1, 3))`` which
+    may not be what one wants when doing code-generation.
+
+    Examples
+    ========
+
+    >>> from sympy.abc import x
+    >>> from sympy.codegen.cfunctions import Cbrt
+    >>> Cbrt(x)
+    Cbrt(x)
+    >>> Cbrt(x).diff(x)
+    1/(3*x**(2/3))
+
+    See Also
+    ========
+
+    Sqrt
+    """
+    nargs = 1
+
+    def fdiff(self, argindex=1):
+        """
+        Returns the first derivative of this function.
+        """
+        if argindex == 1:
+            return Pow(self.args[0], Rational(-_Two/3))/3
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+
+    def _eval_expand_func(self, **hints):
+        return _Cbrt(*self.args)
+
+    def _eval_rewrite_as_Pow(self, arg, **kwargs):
+        return _Cbrt(arg)
+
+    _eval_rewrite_as_tractable = _eval_rewrite_as_Pow
+
+
+def _hypot(x, y):
+    return sqrt(Pow(x, 2) + Pow(y, 2))
+
+
+class hypot(Function):
+    """
+    Represents the hypotenuse function.
+
+    Explanation
+    ===========
+
+    The hypotenuse function is provided by e.g. the math library
+    in the C99 standard, hence one may want to represent the function
+    symbolically when doing code-generation.
+
+    Examples
+    ========
+
+    >>> from sympy.abc import x, y
+    >>> from sympy.codegen.cfunctions import hypot
+    >>> hypot(3, 4).evalf() == 5.0
+    True
+    >>> hypot(x, y)
+    hypot(x, y)
+    >>> hypot(x, y).diff(x)
+    x/hypot(x, y)
+
+    """
+    nargs = 2
+
+    def fdiff(self, argindex=1):
+        """
+        Returns the first derivative of this function.
+        """
+        if argindex in (1, 2):
+            return 2*self.args[argindex-1]/(_Two*self.func(*self.args))
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+
+    def _eval_expand_func(self, **hints):
+        return _hypot(*self.args)
+
+    def _eval_rewrite_as_Pow(self, arg, **kwargs):
+        return _hypot(arg)
+
+    _eval_rewrite_as_tractable = _eval_rewrite_as_Pow
+
+
+class isnan(Function):
+    nargs = 1

janus/lib/python3.10/site-packages/sympy/codegen/cnodes.py

@@ -0,0 +1,156 @@
+"""
+AST nodes specific to the C family of languages
+"""
+
+from sympy.codegen.ast import (
+    Attribute, Declaration, Node, String, Token, Type, none,
+    FunctionCall, CodeBlock
+    )
+from sympy.core.basic import Basic
+from sympy.core.containers import Tuple
+from sympy.core.sympify import sympify
+
+void = Type('void')
+
+restrict = Attribute('restrict')  # guarantees no pointer aliasing
+volatile = Attribute('volatile')
+static = Attribute('static')
+
+
+def alignof(arg):
+    """ Generate of FunctionCall instance for calling 'alignof' """
+    return FunctionCall('alignof', [String(arg) if isinstance(arg, str) else arg])
+
+
+def sizeof(arg):
+    """ Generate of FunctionCall instance for calling 'sizeof'
+
+    Examples
+    ========
+
+    >>> from sympy.codegen.ast import real
+    >>> from sympy.codegen.cnodes import sizeof
+    >>> from sympy import ccode
+    >>> ccode(sizeof(real))
+    'sizeof(double)'
+    """
+    return FunctionCall('sizeof', [String(arg) if isinstance(arg, str) else arg])
+
+
+class CommaOperator(Basic):
+    """ Represents the comma operator in C """
+    def __new__(cls, *args):
+        return Basic.__new__(cls, *[sympify(arg) for arg in args])
+
+
+class Label(Node):
+    """ Label for use with e.g. goto statement.
+
+    Examples
+    ========
+
+    >>> from sympy import ccode, Symbol
+    >>> from sympy.codegen.cnodes import Label, PreIncrement
+    >>> print(ccode(Label('foo')))
+    foo:
+    >>> print(ccode(Label('bar', [PreIncrement(Symbol('a'))])))
+    bar:
+    ++(a);
+
+    """
+    __slots__ = _fields = ('name', 'body')
+    defaults = {'body': none}
+    _construct_name = String
+
+    @classmethod
+    def _construct_body(cls, itr):
+        if isinstance(itr, CodeBlock):
+            return itr
+        else:
+            return CodeBlock(*itr)
+
+
+class goto(Token):
+    """ Represents goto in C """
+    __slots__ = _fields = ('label',)
+    _construct_label = Label
+
+
+class PreDecrement(Basic):
+    """ Represents the pre-decrement operator
+
+    Examples
+    ========
+
+    >>> from sympy.abc import x
+    >>> from sympy.codegen.cnodes import PreDecrement
+    >>> from sympy import ccode
+    >>> ccode(PreDecrement(x))
+    '--(x)'
+
+    """
+    nargs = 1
+
+
+class PostDecrement(Basic):
+    """ Represents the post-decrement operator
+
+    Examples
+    ========
+
+    >>> from sympy.abc import x
+    >>> from sympy.codegen.cnodes import PostDecrement
+    >>> from sympy import ccode
+    >>> ccode(PostDecrement(x))
+    '(x)--'
+
+    """
+    nargs = 1
+
+
+class PreIncrement(Basic):
+    """ Represents the pre-increment operator
+
+    Examples
+    ========
+
+    >>> from sympy.abc import x
+    >>> from sympy.codegen.cnodes import PreIncrement
+    >>> from sympy import ccode
+    >>> ccode(PreIncrement(x))
+    '++(x)'
+
+    """
+    nargs = 1
+
+
+class PostIncrement(Basic):
+    """ Represents the post-increment operator
+
+    Examples
+    ========
+
+    >>> from sympy.abc import x
+    >>> from sympy.codegen.cnodes import PostIncrement
+    >>> from sympy import ccode
+    >>> ccode(PostIncrement(x))
+    '(x)++'
+
+    """
+    nargs = 1
+
+
+class struct(Node):
+    """ Represents a struct in C """
+    __slots__ = _fields = ('name', 'declarations')
+    defaults = {'name': none}
+    _construct_name = String
+
+    @classmethod
+    def _construct_declarations(cls, args):
+        return Tuple(*[Declaration(arg) for arg in args])
+
+
+class union(struct):
+    """ Represents a union in C """
+    __slots__ = ()

janus/lib/python3.10/site-packages/sympy/codegen/cxxnodes.py

@@ -0,0 +1,14 @@
+"""
+AST nodes specific to C++.
+"""
+
+from sympy.codegen.ast import Attribute, String, Token, Type, none
+
+class using(Token):
+    """ Represents a 'using' statement in C++ """
+    __slots__ = _fields = ('type', 'alias')
+    defaults = {'alias': none}
+    _construct_type = Type
+    _construct_alias = String
+
+constexpr = Attribute('constexpr')

janus/lib/python3.10/site-packages/sympy/codegen/futils.py

@@ -0,0 +1,40 @@
+from itertools import chain
+from sympy.codegen.fnodes import Module
+from sympy.core.symbol import Dummy
+from sympy.printing.fortran import FCodePrinter
+
+""" This module collects utilities for rendering Fortran code. """
+
+
+def render_as_module(definitions, name, declarations=(), printer_settings=None):
+    """ Creates a ``Module`` instance and renders it as a string.
+
+    This generates Fortran source code for a module with the correct ``use`` statements.
+
+    Parameters
+    ==========
+
+    definitions : iterable
+        Passed to :class:`sympy.codegen.fnodes.Module`.
+    name : str
+        Passed to :class:`sympy.codegen.fnodes.Module`.
+    declarations : iterable
+        Passed to :class:`sympy.codegen.fnodes.Module`. It will be extended with
+        use statements, 'implicit none' and public list generated from ``definitions``.
+    printer_settings : dict
+        Passed to ``FCodePrinter`` (default: ``{'standard': 2003, 'source_format': 'free'}``).
+
+    """
+    printer_settings = printer_settings or {'standard': 2003, 'source_format': 'free'}
+    printer = FCodePrinter(printer_settings)
+    dummy = Dummy()
+    if isinstance(definitions, Module):
+        raise ValueError("This function expects to construct a module on its own.")
+    mod = Module(name, chain(declarations, [dummy]), definitions)
+    fstr = printer.doprint(mod)
+    module_use_str = '   %s\n' % '   \n'.join(['use %s, only: %s' % (k, ', '.join(v)) for
+                                                k, v in printer.module_uses.items()])
+    module_use_str += '   implicit none\n'
+    module_use_str += '   private\n'
+    module_use_str += '   public %s\n' % ', '.join([str(node.name) for node in definitions if getattr(node, 'name', None)])
+    return fstr.replace(printer.doprint(dummy), module_use_str)

janus/lib/python3.10/site-packages/sympy/codegen/pynodes.py

@@ -0,0 +1,11 @@
+from .abstract_nodes import List as AbstractList
+from .ast import Token
+
+
+class List(AbstractList):
+    pass
+
+
+class NumExprEvaluate(Token):
+    """represents a call to :class:`numexpr`s :func:`evaluate`"""
+    __slots__ = _fields = ('expr',)

janus/lib/python3.10/site-packages/sympy/codegen/tests/test_ast.py

@@ -0,0 +1,661 @@
+import math
+from sympy.core.containers import Tuple
+from sympy.core.numbers import nan, oo, Float, Integer
+from sympy.core.relational import Lt
+from sympy.core.symbol import symbols, Symbol
+from sympy.functions.elementary.trigonometric import sin
+from sympy.matrices.dense import Matrix
+from sympy.matrices.expressions.matexpr import MatrixSymbol
+from sympy.sets.fancysets import Range
+from sympy.tensor.indexed import Idx, IndexedBase
+from sympy.testing.pytest import raises
+
+
+from sympy.codegen.ast import (
+    Assignment, Attribute, aug_assign, CodeBlock, For, Type, Variable, Pointer, Declaration,
+    AddAugmentedAssignment, SubAugmentedAssignment, MulAugmentedAssignment,
+    DivAugmentedAssignment, ModAugmentedAssignment, value_const, pointer_const,
+    integer, real, complex_, int8, uint8, float16 as f16, float32 as f32,
+    float64 as f64, float80 as f80, float128 as f128, complex64 as c64, complex128 as c128,
+    While, Scope, String, Print, QuotedString, FunctionPrototype, FunctionDefinition, Return,
+    FunctionCall, untyped, IntBaseType, intc, Node, none, NoneToken, Token, Comment
+)
+
+x, y, z, t, x0, x1, x2, a, b = symbols("x, y, z, t, x0, x1, x2, a, b")
+n = symbols("n", integer=True)
+A = MatrixSymbol('A', 3, 1)
+mat = Matrix([1, 2, 3])
+B = IndexedBase('B')
+i = Idx("i", n)
+A22 = MatrixSymbol('A22',2,2)
+B22 = MatrixSymbol('B22',2,2)
+
+
+def test_Assignment():
+    # Here we just do things to show they don't error
+    Assignment(x, y)
+    Assignment(x, 0)
+    Assignment(A, mat)
+    Assignment(A[1,0], 0)
+    Assignment(A[1,0], x)
+    Assignment(B[i], x)
+    Assignment(B[i], 0)
+    a = Assignment(x, y)
+    assert a.func(*a.args) == a
+    assert a.op == ':='
+    # Here we test things to show that they error
+    # Matrix to scalar
+    raises(ValueError, lambda: Assignment(B[i], A))
+    raises(ValueError, lambda: Assignment(B[i], mat))
+    raises(ValueError, lambda: Assignment(x, mat))
+    raises(ValueError, lambda: Assignment(x, A))
+    raises(ValueError, lambda: Assignment(A[1,0], mat))
+    # Scalar to matrix
+    raises(ValueError, lambda: Assignment(A, x))
+    raises(ValueError, lambda: Assignment(A, 0))
+    # Non-atomic lhs
+    raises(TypeError, lambda: Assignment(mat, A))
+    raises(TypeError, lambda: Assignment(0, x))
+    raises(TypeError, lambda: Assignment(x*x, 1))
+    raises(TypeError, lambda: Assignment(A + A, mat))
+    raises(TypeError, lambda: Assignment(B, 0))
+
+
+def test_AugAssign():
+    # Here we just do things to show they don't error
+    aug_assign(x, '+', y)
+    aug_assign(x, '+', 0)
+    aug_assign(A, '+', mat)
+    aug_assign(A[1, 0], '+', 0)
+    aug_assign(A[1, 0], '+', x)
+    aug_assign(B[i], '+', x)
+    aug_assign(B[i], '+', 0)
+
+    # Check creation via aug_assign vs constructor
+    for binop, cls in [
+            ('+', AddAugmentedAssignment),
+            ('-', SubAugmentedAssignment),
+            ('*', MulAugmentedAssignment),
+            ('/', DivAugmentedAssignment),
+            ('%', ModAugmentedAssignment),
+        ]:
+        a = aug_assign(x, binop, y)
+        b = cls(x, y)
+        assert a.func(*a.args) == a == b
+        assert a.binop == binop
+        assert a.op == binop + '='
+
+    # Here we test things to show that they error
+    # Matrix to scalar
+    raises(ValueError, lambda: aug_assign(B[i], '+', A))
+    raises(ValueError, lambda: aug_assign(B[i], '+', mat))
+    raises(ValueError, lambda: aug_assign(x, '+', mat))
+    raises(ValueError, lambda: aug_assign(x, '+', A))
+    raises(ValueError, lambda: aug_assign(A[1, 0], '+', mat))
+    # Scalar to matrix
+    raises(ValueError, lambda: aug_assign(A, '+', x))
+    raises(ValueError, lambda: aug_assign(A, '+', 0))
+    # Non-atomic lhs
+    raises(TypeError, lambda: aug_assign(mat, '+', A))
+    raises(TypeError, lambda: aug_assign(0, '+', x))
+    raises(TypeError, lambda: aug_assign(x * x, '+', 1))
+    raises(TypeError, lambda: aug_assign(A + A, '+', mat))
+    raises(TypeError, lambda: aug_assign(B, '+', 0))
+
+
+def test_Assignment_printing():
+    assignment_classes = [
+        Assignment,
+        AddAugmentedAssignment,
+        SubAugmentedAssignment,
+        MulAugmentedAssignment,
+        DivAugmentedAssignment,
+        ModAugmentedAssignment,
+    ]
+    pairs = [
+        (x, 2 * y + 2),
+        (B[i], x),
+        (A22, B22),
+        (A[0, 0], x),
+    ]
+
+    for cls in assignment_classes:
+        for lhs, rhs in pairs:
+            a = cls(lhs, rhs)
+            assert repr(a) == '%s(%s, %s)' % (cls.__name__, repr(lhs), repr(rhs))
+
+
+def test_CodeBlock():
+    c = CodeBlock(Assignment(x, 1), Assignment(y, x + 1))
+    assert c.func(*c.args) == c
+
+    assert c.left_hand_sides == Tuple(x, y)
+    assert c.right_hand_sides == Tuple(1, x + 1)
+
+def test_CodeBlock_topological_sort():
+    assignments = [
+        Assignment(x, y + z),
+        Assignment(z, 1),
+        Assignment(t, x),
+        Assignment(y, 2),
+        ]
+
+    ordered_assignments = [
+        # Note that the unrelated z=1 and y=2 are kept in that order
+        Assignment(z, 1),
+        Assignment(y, 2),
+        Assignment(x, y + z),
+        Assignment(t, x),
+        ]
+    c1 = CodeBlock.topological_sort(assignments)
+    assert c1 == CodeBlock(*ordered_assignments)
+
+    # Cycle
+    invalid_assignments = [
+        Assignment(x, y + z),
+        Assignment(z, 1),
+        Assignment(y, x),
+        Assignment(y, 2),
+        ]
+
+    raises(ValueError, lambda: CodeBlock.topological_sort(invalid_assignments))
+
+    # Free symbols
+    free_assignments = [
+        Assignment(x, y + z),
+        Assignment(z, a * b),
+        Assignment(t, x),
+        Assignment(y, b + 3),
+        ]
+
+    free_assignments_ordered = [
+        Assignment(z, a * b),
+        Assignment(y, b + 3),
+        Assignment(x, y + z),
+        Assignment(t, x),
+        ]
+
+    c2 = CodeBlock.topological_sort(free_assignments)
+    assert c2 == CodeBlock(*free_assignments_ordered)
+
+def test_CodeBlock_free_symbols():
+    c1 = CodeBlock(
+        Assignment(x, y + z),
+        Assignment(z, 1),
+        Assignment(t, x),
+        Assignment(y, 2),
+        )
+    assert c1.free_symbols == set()
+
+    c2 = CodeBlock(
+        Assignment(x, y + z),
+        Assignment(z, a * b),
+        Assignment(t, x),
+        Assignment(y, b + 3),
+    )
+    assert c2.free_symbols == {a, b}
+
+def test_CodeBlock_cse():
+    c1 = CodeBlock(
+        Assignment(y, 1),
+        Assignment(x, sin(y)),
+        Assignment(z, sin(y)),
+        Assignment(t, x*z),
+        )
+    assert c1.cse() == CodeBlock(
+        Assignment(y, 1),
+        Assignment(x0, sin(y)),
+        Assignment(x, x0),
+        Assignment(z, x0),
+        Assignment(t, x*z),
+    )
+
+    # Multiple assignments to same symbol not supported
+    raises(NotImplementedError, lambda: CodeBlock(
+        Assignment(x, 1),
+        Assignment(y, 1), Assignment(y, 2)
+    ).cse())
+
+    # Check auto-generated symbols do not collide with existing ones
+    c2 = CodeBlock(
+        Assignment(x0, sin(y) + 1),
+        Assignment(x1, 2 * sin(y)),
+        Assignment(z, x * y),
+        )
+    assert c2.cse() == CodeBlock(
+        Assignment(x2, sin(y)),
+        Assignment(x0, x2 + 1),
+        Assignment(x1, 2 * x2),
+        Assignment(z, x * y),
+        )
+
+
+def test_CodeBlock_cse__issue_14118():
+    # see https://github.com/sympy/sympy/issues/14118
+    c = CodeBlock(
+        Assignment(A22, Matrix([[x, sin(y)],[3, 4]])),
+        Assignment(B22, Matrix([[sin(y), 2*sin(y)], [sin(y)**2, 7]]))
+    )
+    assert c.cse() == CodeBlock(
+        Assignment(x0, sin(y)),
+        Assignment(A22, Matrix([[x, x0],[3, 4]])),
+        Assignment(B22, Matrix([[x0, 2*x0], [x0**2, 7]]))
+    )
+
+def test_For():
+    f = For(n, Range(0, 3), (Assignment(A[n, 0], x + n), aug_assign(x, '+', y)))
+    f = For(n, (1, 2, 3, 4, 5), (Assignment(A[n, 0], x + n),))
+    assert f.func(*f.args) == f
+    raises(TypeError, lambda: For(n, x, (x + y,)))
+
+
+def test_none():
+    assert none.is_Atom
+    assert none == none
+    class Foo(Token):
+        pass
+    foo = Foo()
+    assert foo != none
+    assert none == None
+    assert none == NoneToken()
+    assert none.func(*none.args) == none
+
+
+def test_String():
+    st = String('foobar')
+    assert st.is_Atom
+    assert st == String('foobar')
+    assert st.text == 'foobar'
+    assert st.func(**st.kwargs()) == st
+    assert st.func(*st.args) == st
+
+
+    class Signifier(String):
+        pass
+
+    si = Signifier('foobar')
+    assert si != st
+    assert si.text == st.text
+    s = String('foo')
+    assert str(s) == 'foo'
+    assert repr(s) == "String('foo')"
+
+def test_Comment():
+    c = Comment('foobar')
+    assert c.text == 'foobar'
+    assert str(c) == 'foobar'
+
+def test_Node():
+    n = Node()
+    assert n == Node()
+    assert n.func(*n.args) == n
+
+
+def test_Type():
+    t = Type('MyType')
+    assert len(t.args) == 1
+    assert t.name == String('MyType')
+    assert str(t) == 'MyType'
+    assert repr(t) == "Type(String('MyType'))"
+    assert Type(t) == t
+    assert t.func(*t.args) == t
+    t1 = Type('t1')
+    t2 = Type('t2')
+    assert t1 != t2
+    assert t1 == t1 and t2 == t2
+    t1b = Type('t1')
+    assert t1 == t1b
+    assert t2 != t1b
+
+
+def test_Type__from_expr():
+    assert Type.from_expr(i) == integer
+    u = symbols('u', real=True)
+    assert Type.from_expr(u) == real
+    assert Type.from_expr(n) == integer
+    assert Type.from_expr(3) == integer
+    assert Type.from_expr(3.0) == real
+    assert Type.from_expr(3+1j) == complex_
+    raises(ValueError, lambda: Type.from_expr(sum))
+
+
+def test_Type__cast_check__integers():
+    # Rounding
+    raises(ValueError, lambda: integer.cast_check(3.5))
+    assert integer.cast_check('3') == 3
+    assert integer.cast_check(Float('3.0000000000000000000')) == 3
+    assert integer.cast_check(Float('3.0000000000000000001')) == 3  # unintuitive maybe?
+
+    # Range
+    assert int8.cast_check(127.0) == 127
+    raises(ValueError, lambda: int8.cast_check(128))
+    assert int8.cast_check(-128) == -128
+    raises(ValueError, lambda: int8.cast_check(-129))
+
+    assert uint8.cast_check(0) == 0
+    assert uint8.cast_check(128) == 128
+    raises(ValueError, lambda: uint8.cast_check(256.0))
+    raises(ValueError, lambda: uint8.cast_check(-1))
+
+def test_Attribute():
+    noexcept = Attribute('noexcept')
+    assert noexcept == Attribute('noexcept')
+    alignas16 = Attribute('alignas', [16])
+    alignas32 = Attribute('alignas', [32])
+    assert alignas16 != alignas32
+    assert alignas16.func(*alignas16.args) == alignas16
+
+
+def test_Variable():
+    v = Variable(x, type=real)
+    assert v == Variable(v)
+    assert v == Variable('x', type=real)
+    assert v.symbol == x
+    assert v.type == real
+    assert value_const not in v.attrs
+    assert v.func(*v.args) == v
+    assert str(v) == 'Variable(x, type=real)'
+
+    w = Variable(y, f32, attrs={value_const})
+    assert w.symbol == y
+    assert w.type == f32
+    assert value_const in w.attrs
+    assert w.func(*w.args) == w
+
+    v_n = Variable(n, type=Type.from_expr(n))
+    assert v_n.type == integer
+    assert v_n.func(*v_n.args) == v_n
+    v_i = Variable(i, type=Type.from_expr(n))
+    assert v_i.type == integer
+    assert v_i != v_n
+
+    a_i = Variable.deduced(i)
+    assert a_i.type == integer
+    assert Variable.deduced(Symbol('x', real=True)).type == real
+    assert a_i.func(*a_i.args) == a_i
+
+    v_n2 = Variable.deduced(n, value=3.5, cast_check=False)
+    assert v_n2.func(*v_n2.args) == v_n2
+    assert abs(v_n2.value - 3.5) < 1e-15
+    raises(ValueError, lambda: Variable.deduced(n, value=3.5, cast_check=True))
+
+    v_n3 = Variable.deduced(n)
+    assert v_n3.type == integer
+    assert str(v_n3) == 'Variable(n, type=integer)'
+    assert Variable.deduced(z, value=3).type == integer
+    assert Variable.deduced(z, value=3.0).type == real
+    assert Variable.deduced(z, value=3.0+1j).type == complex_
+
+
+def test_Pointer():
+    p = Pointer(x)
+    assert p.symbol == x
+    assert p.type == untyped
+    assert value_const not in p.attrs
+    assert pointer_const not in p.attrs
+    assert p.func(*p.args) == p
+
+    u = symbols('u', real=True)
+    pu = Pointer(u, type=Type.from_expr(u), attrs={value_const, pointer_const})
+    assert pu.symbol is u
+    assert pu.type == real
+    assert value_const in pu.attrs
+    assert pointer_const in pu.attrs
+    assert pu.func(*pu.args) == pu
+
+    i = symbols('i', integer=True)
+    deref = pu[i]
+    assert deref.indices == (i,)
+
+
+def test_Declaration():
+    u = symbols('u', real=True)
+    vu = Variable(u, type=Type.from_expr(u))
+    assert Declaration(vu).variable.type == real
+    vn = Variable(n, type=Type.from_expr(n))
+    assert Declaration(vn).variable.type == integer
+
+    # PR 19107, does not allow comparison between expressions and Basic
+    # lt = StrictLessThan(vu, vn)
+    # assert isinstance(lt, StrictLessThan)
+
+    vuc = Variable(u, Type.from_expr(u), value=3.0, attrs={value_const})
+    assert value_const in vuc.attrs
+    assert pointer_const not in vuc.attrs
+    decl = Declaration(vuc)
+    assert decl.variable == vuc
+    assert isinstance(decl.variable.value, Float)
+    assert decl.variable.value == 3.0
+    assert decl.func(*decl.args) == decl
+    assert vuc.as_Declaration() == decl
+    assert vuc.as_Declaration(value=None, attrs=None) == Declaration(vu)
+
+    vy = Variable(y, type=integer, value=3)
+    decl2 = Declaration(vy)
+    assert decl2.variable == vy
+    assert decl2.variable.value == Integer(3)
+
+    vi = Variable(i, type=Type.from_expr(i), value=3.0)
+    decl3 = Declaration(vi)
+    assert decl3.variable.type == integer
+    assert decl3.variable.value == 3.0
+
+    raises(ValueError, lambda: Declaration(vi, 42))
+
+
+def test_IntBaseType():
+    assert intc.name == String('intc')
+    assert intc.args == (intc.name,)
+    assert str(IntBaseType('a').name) == 'a'
+
+
+def test_FloatType():
+    assert f16.dig == 3
+    assert f32.dig == 6
+    assert f64.dig == 15
+    assert f80.dig == 18
+    assert f128.dig == 33
+
+    assert f16.decimal_dig == 5
+    assert f32.decimal_dig == 9
+    assert f64.decimal_dig == 17
+    assert f80.decimal_dig == 21
+    assert f128.decimal_dig == 36
+
+    assert f16.max_exponent == 16
+    assert f32.max_exponent == 128
+    assert f64.max_exponent == 1024
+    assert f80.max_exponent == 16384
+    assert f128.max_exponent == 16384
+
+    assert f16.min_exponent == -13
+    assert f32.min_exponent == -125
+    assert f64.min_exponent == -1021
+    assert f80.min_exponent == -16381
+    assert f128.min_exponent == -16381
+
+    assert abs(f16.eps / Float('0.00097656', precision=16) - 1) < 0.1*10**-f16.dig
+    assert abs(f32.eps / Float('1.1920929e-07', precision=32) - 1) < 0.1*10**-f32.dig
+    assert abs(f64.eps / Float('2.2204460492503131e-16', precision=64) - 1) < 0.1*10**-f64.dig
+    assert abs(f80.eps / Float('1.08420217248550443401e-19', precision=80) - 1) < 0.1*10**-f80.dig
+    assert abs(f128.eps / Float(' 1.92592994438723585305597794258492732e-34', precision=128) - 1) < 0.1*10**-f128.dig
+
+    assert abs(f16.max / Float('65504', precision=16) - 1) < .1*10**-f16.dig
+    assert abs(f32.max / Float('3.40282347e+38', precision=32) - 1) < 0.1*10**-f32.dig
+    assert abs(f64.max / Float('1.79769313486231571e+308', precision=64) - 1) < 0.1*10**-f64.dig  # cf. np.finfo(np.float64).max
+    assert abs(f80.max / Float('1.18973149535723176502e+4932', precision=80) - 1) < 0.1*10**-f80.dig
+    assert abs(f128.max / Float('1.18973149535723176508575932662800702e+4932', precision=128) - 1) < 0.1*10**-f128.dig
+
+    # cf. np.finfo(np.float32).tiny
+    assert abs(f16.tiny / Float('6.1035e-05', precision=16) - 1) < 0.1*10**-f16.dig
+    assert abs(f32.tiny / Float('1.17549435e-38', precision=32) - 1) < 0.1*10**-f32.dig
+    assert abs(f64.tiny / Float('2.22507385850720138e-308', precision=64) - 1) < 0.1*10**-f64.dig
+    assert abs(f80.tiny / Float('3.36210314311209350626e-4932', precision=80) - 1) < 0.1*10**-f80.dig
+    assert abs(f128.tiny / Float('3.3621031431120935062626778173217526e-4932', precision=128) - 1) < 0.1*10**-f128.dig
+
+    assert f64.cast_check(0.5) == Float(0.5, 17)
+    assert abs(f64.cast_check(3.7) - 3.7) < 3e-17
+    assert isinstance(f64.cast_check(3), (Float, float))
+
+    assert f64.cast_nocheck(oo) == float('inf')
+    assert f64.cast_nocheck(-oo) == float('-inf')
+    assert f64.cast_nocheck(float(oo)) == float('inf')
+    assert f64.cast_nocheck(float(-oo)) == float('-inf')
+    assert math.isnan(f64.cast_nocheck(nan))
+
+    assert f32 != f64
+    assert f64 == f64.func(*f64.args)
+
+
+def test_Type__cast_check__floating_point():
+    raises(ValueError, lambda: f32.cast_check(123.45678949))
+    raises(ValueError, lambda: f32.cast_check(12.345678949))
+    raises(ValueError, lambda: f32.cast_check(1.2345678949))
+    raises(ValueError, lambda: f32.cast_check(.12345678949))
+    assert abs(123.456789049 - f32.cast_check(123.456789049) - 4.9e-8) < 1e-8
+    assert abs(0.12345678904 - f32.cast_check(0.12345678904) - 4e-11) < 1e-11
+
+    dcm21 = Float('0.123456789012345670499')  # 21 decimals
+    assert abs(dcm21 - f64.cast_check(dcm21) - 4.99e-19) < 1e-19
+
+    f80.cast_check(Float('0.12345678901234567890103', precision=88))
+    raises(ValueError, lambda: f80.cast_check(Float('0.12345678901234567890149', precision=88)))
+
+    v10 = 12345.67894
+    raises(ValueError, lambda: f32.cast_check(v10))
+    assert abs(Float(str(v10), precision=64+8) - f64.cast_check(v10)) < v10*1e-16
+
+    assert abs(f32.cast_check(2147483647) - 2147483650) < 1
+
+
+def test_Type__cast_check__complex_floating_point():
+    val9_11 = 123.456789049 + 0.123456789049j
+    raises(ValueError, lambda: c64.cast_check(.12345678949 + .12345678949j))
+    assert abs(val9_11 - c64.cast_check(val9_11) - 4.9e-8) < 1e-8
+
+    dcm21 = Float('0.123456789012345670499') + 1e-20j  # 21 decimals
+    assert abs(dcm21 - c128.cast_check(dcm21) - 4.99e-19) < 1e-19
+    v19 = Float('0.1234567890123456749') + 1j*Float('0.1234567890123456749')
+    raises(ValueError, lambda: c128.cast_check(v19))
+
+
+def test_While():
+    xpp = AddAugmentedAssignment(x, 1)
+    whl1 = While(x < 2, [xpp])
+    assert whl1.condition.args[0] == x
+    assert whl1.condition.args[1] == 2
+    assert whl1.condition == Lt(x, 2, evaluate=False)
+    assert whl1.body.args == (xpp,)
+    assert whl1.func(*whl1.args) == whl1
+
+    cblk = CodeBlock(AddAugmentedAssignment(x, 1))
+    whl2 = While(x < 2, cblk)
+    assert whl1 == whl2
+    assert whl1 != While(x < 3, [xpp])
+
+
+def test_Scope():
+    assign = Assignment(x, y)
+    incr = AddAugmentedAssignment(x, 1)
+    scp = Scope([assign, incr])
+    cblk = CodeBlock(assign, incr)
+    assert scp.body == cblk
+    assert scp == Scope(cblk)
+    assert scp != Scope([incr, assign])
+    assert scp.func(*scp.args) == scp
+
+
+def test_Print():
+    fmt = "%d %.3f"
+    ps = Print([n, x], fmt)
+    assert str(ps.format_string) == fmt
+    assert ps.print_args == Tuple(n, x)
+    assert ps.args == (Tuple(n, x), QuotedString(fmt), none)
+    assert ps == Print((n, x), fmt)
+    assert ps != Print([x, n], fmt)
+    assert ps.func(*ps.args) == ps
+
+    ps2 = Print([n, x])
+    assert ps2 == Print([n, x])
+    assert ps2 != ps
+    assert ps2.format_string == None
+
+
+def test_FunctionPrototype_and_FunctionDefinition():
+    vx = Variable(x, type=real)
+    vn = Variable(n, type=integer)
+    fp1 = FunctionPrototype(real, 'power', [vx, vn])
+    assert fp1.return_type == real
+    assert fp1.name == String('power')
+    assert fp1.parameters == Tuple(vx, vn)
+    assert fp1 == FunctionPrototype(real, 'power', [vx, vn])
+    assert fp1 != FunctionPrototype(real, 'power', [vn, vx])
+    assert fp1.func(*fp1.args) == fp1
+
+
+    body = [Assignment(x, x**n), Return(x)]
+    fd1 = FunctionDefinition(real, 'power', [vx, vn], body)
+    assert fd1.return_type == real
+    assert str(fd1.name) == 'power'
+    assert fd1.parameters == Tuple(vx, vn)
+    assert fd1.body == CodeBlock(*body)
+    assert fd1 == FunctionDefinition(real, 'power', [vx, vn], body)
+    assert fd1 != FunctionDefinition(real, 'power', [vx, vn], body[::-1])
+    assert fd1.func(*fd1.args) == fd1
+
+    fp2 = FunctionPrototype.from_FunctionDefinition(fd1)
+    assert fp2 == fp1
+
+    fd2 = FunctionDefinition.from_FunctionPrototype(fp1, body)
+    assert fd2 == fd1
+
+
+def test_Return():
+    rs = Return(x)
+    assert rs.args == (x,)
+    assert rs == Return(x)
+    assert rs != Return(y)
+    assert rs.func(*rs.args) == rs
+
+
+def test_FunctionCall():
+    fc = FunctionCall('power', (x, 3))
+    assert fc.function_args[0] == x
+    assert fc.function_args[1] == 3
+    assert len(fc.function_args) == 2
+    assert isinstance(fc.function_args[1], Integer)
+    assert fc == FunctionCall('power', (x, 3))
+    assert fc != FunctionCall('power', (3, x))
+    assert fc != FunctionCall('Power', (x, 3))
+    assert fc.func(*fc.args) == fc
+
+    fc2 = FunctionCall('fma', [2, 3, 4])
+    assert len(fc2.function_args) == 3
+    assert fc2.function_args[0] == 2
+    assert fc2.function_args[1] == 3
+    assert fc2.function_args[2] == 4
+    assert str(fc2) in ( # not sure if QuotedString is a better default...
+        'FunctionCall(fma, function_args=(2, 3, 4))',
+        'FunctionCall("fma", function_args=(2, 3, 4))',
+    )
+
+def test_ast_replace():
+    x = Variable('x', real)
+    y = Variable('y', real)
+    n = Variable('n', integer)
+
+    pwer = FunctionDefinition(real, 'pwer', [x, n], [pow(x.symbol, n.symbol)])
+    pname = pwer.name
+    pcall = FunctionCall('pwer', [y, 3])
+
+    tree1 = CodeBlock(pwer, pcall)
+    assert str(tree1.args[0].name) == 'pwer'
+    assert str(tree1.args[1].name) == 'pwer'
+    for a, b in zip(tree1, [pwer, pcall]):
+        assert a == b
+
+    tree2 = tree1.replace(pname, String('power'))
+    assert str(tree1.args[0].name) == 'pwer'
+    assert str(tree1.args[1].name) == 'pwer'
+    assert str(tree2.args[0].name) == 'power'
+    assert str(tree2.args[1].name) == 'power'

janus/lib/python3.10/site-packages/sympy/codegen/tests/test_cfunctions.py

@@ -0,0 +1,165 @@
+from sympy.core.numbers import (Rational, pi)
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.codegen.cfunctions import (
+    expm1, log1p, exp2, log2, fma, log10, Sqrt, Cbrt, hypot
+)
+from sympy.core.function import expand_log
+
+
+def test_expm1():
+    # Eval
+    assert expm1(0) == 0
+
+    x = Symbol('x', real=True)
+
+    # Expand and rewrite
+    assert expm1(x).expand(func=True) - exp(x) == -1
+    assert expm1(x).rewrite('tractable') - exp(x) == -1
+    assert expm1(x).rewrite('exp') - exp(x) == -1
+
+    # Precision
+    assert not ((exp(1e-10).evalf() - 1) - 1e-10 - 5e-21) < 1e-22  # for comparison
+    assert abs(expm1(1e-10).evalf() - 1e-10 - 5e-21) < 1e-22
+
+    # Properties
+    assert expm1(x).is_real
+    assert expm1(x).is_finite
+
+    # Diff
+    assert expm1(42*x).diff(x) - 42*exp(42*x) == 0
+    assert expm1(42*x).diff(x) - expm1(42*x).expand(func=True).diff(x) == 0
+
+
+def test_log1p():
+    # Eval
+    assert log1p(0) == 0
+    d = S(10)
+    assert expand_log(log1p(d**-1000) - log(d**1000 + 1) + log(d**1000)) == 0
+
+    x = Symbol('x', real=True)
+
+    # Expand and rewrite
+    assert log1p(x).expand(func=True) - log(x + 1) == 0
+    assert log1p(x).rewrite('tractable') - log(x + 1) == 0
+    assert log1p(x).rewrite('log') - log(x + 1) == 0
+
+    # Precision
+    assert not abs(log(1e-99 + 1).evalf() - 1e-99) < 1e-100  # for comparison
+    assert abs(expand_log(log1p(1e-99)).evalf() - 1e-99) < 1e-100
+
+    # Properties
+    assert log1p(-2**Rational(-1, 2)).is_real
+
+    assert not log1p(-1).is_finite
+    assert log1p(pi).is_finite
+
+    assert not log1p(x).is_positive
+    assert log1p(Symbol('y', positive=True)).is_positive
+
+    assert not log1p(x).is_zero
+    assert log1p(Symbol('z', zero=True)).is_zero
+
+    assert not log1p(x).is_nonnegative
+    assert log1p(Symbol('o', nonnegative=True)).is_nonnegative
+
+    # Diff
+    assert log1p(42*x).diff(x) - 42/(42*x + 1) == 0
+    assert log1p(42*x).diff(x) - log1p(42*x).expand(func=True).diff(x) == 0
+
+
+def test_exp2():
+    # Eval
+    assert exp2(2) == 4
+
+    x = Symbol('x', real=True)
+
+    # Expand
+    assert exp2(x).expand(func=True) - 2**x == 0
+
+    # Diff
+    assert exp2(42*x).diff(x) - 42*exp2(42*x)*log(2) == 0
+    assert exp2(42*x).diff(x) - exp2(42*x).diff(x) == 0
+
+
+def test_log2():
+    # Eval
+    assert log2(8) == 3
+    assert log2(pi) != log(pi)/log(2)  # log2 should *save* (CPU) instructions
+
+    x = Symbol('x', real=True)
+    assert log2(x) != log(x)/log(2)
+    assert log2(2**x) == x
+
+    # Expand
+    assert log2(x).expand(func=True) - log(x)/log(2) == 0
+
+    # Diff
+    assert log2(42*x).diff() - 1/(log(2)*x) == 0
+    assert log2(42*x).diff() - log2(42*x).expand(func=True).diff(x) == 0
+
+
+def test_fma():
+    x, y, z = symbols('x y z')
+
+    # Expand
+    assert fma(x, y, z).expand(func=True) - x*y - z == 0
+
+    expr = fma(17*x, 42*y, 101*z)
+
+    # Diff
+    assert expr.diff(x) - expr.expand(func=True).diff(x) == 0
+    assert expr.diff(y) - expr.expand(func=True).diff(y) == 0
+    assert expr.diff(z) - expr.expand(func=True).diff(z) == 0
+
+    assert expr.diff(x) - 17*42*y == 0
+    assert expr.diff(y) - 17*42*x == 0
+    assert expr.diff(z) - 101 == 0
+
+
+def test_log10():
+    x = Symbol('x')
+
+    # Expand
+    assert log10(x).expand(func=True) - log(x)/log(10) == 0
+
+    # Diff
+    assert log10(42*x).diff(x) - 1/(log(10)*x) == 0
+    assert log10(42*x).diff(x) - log10(42*x).expand(func=True).diff(x) == 0
+
+
+def test_Cbrt():
+    x = Symbol('x')
+
+    # Expand
+    assert Cbrt(x).expand(func=True) - x**Rational(1, 3) == 0
+
+    # Diff
+    assert Cbrt(42*x).diff(x) - 42*(42*x)**(Rational(1, 3) - 1)/3 == 0
+    assert Cbrt(42*x).diff(x) - Cbrt(42*x).expand(func=True).diff(x) == 0
+
+
+def test_Sqrt():
+    x = Symbol('x')
+
+    # Expand
+    assert Sqrt(x).expand(func=True) - x**S.Half == 0
+
+    # Diff
+    assert Sqrt(42*x).diff(x) - 42*(42*x)**(S.Half - 1)/2 == 0
+    assert Sqrt(42*x).diff(x) - Sqrt(42*x).expand(func=True).diff(x) == 0
+
+
+def test_hypot():
+    x, y = symbols('x y')
+
+    # Expand
+    assert hypot(x, y).expand(func=True) - (x**2 + y**2)**S.Half == 0
+
+    # Diff
+    assert hypot(17*x, 42*y).diff(x).expand(func=True) - hypot(17*x, 42*y).expand(func=True).diff(x) == 0
+    assert hypot(17*x, 42*y).diff(y).expand(func=True) - hypot(17*x, 42*y).expand(func=True).diff(y) == 0
+
+    assert hypot(17*x, 42*y).diff(x).expand(func=True) - 2*17*17*x*((17*x)**2 + (42*y)**2)**Rational(-1, 2)/2 == 0
+    assert hypot(17*x, 42*y).diff(y).expand(func=True) - 2*42*42*y*((17*x)**2 + (42*y)**2)**Rational(-1, 2)/2 == 0

janus/lib/python3.10/site-packages/sympy/codegen/tests/test_cnodes.py

@@ -0,0 +1,112 @@
+from sympy.core.symbol import symbols
+from sympy.printing.codeprinter import ccode
+from sympy.codegen.ast import Declaration, Variable, float64, int64, String, CodeBlock
+from sympy.codegen.cnodes import (
+    alignof, CommaOperator, goto, Label, PreDecrement, PostDecrement, PreIncrement, PostIncrement,
+    sizeof, union, struct
+)
+
+x, y = symbols('x y')
+
+
+def test_alignof():
+    ax = alignof(x)
+    assert ccode(ax) == 'alignof(x)'
+    assert ax.func(*ax.args) == ax
+
+
+def test_CommaOperator():
+    expr = CommaOperator(PreIncrement(x), 2*x)
+    assert ccode(expr) == '(++(x), 2*x)'
+    assert expr.func(*expr.args) == expr
+
+
+def test_goto_Label():
+    s = 'early_exit'
+    g = goto(s)
+    assert g.func(*g.args) == g
+    assert g != goto('foobar')
+    assert ccode(g) == 'goto early_exit'
+
+    l1 = Label(s)
+    assert ccode(l1) == 'early_exit:'
+    assert l1 == Label('early_exit')
+    assert l1 != Label('foobar')
+
+    body = [PreIncrement(x)]
+    l2 = Label(s, body)
+    assert l2.name == String("early_exit")
+    assert l2.body == CodeBlock(PreIncrement(x))
+    assert ccode(l2) == ("early_exit:\n"
+        "++(x);")
+
+    body = [PreIncrement(x), PreDecrement(y)]
+    l2 = Label(s, body)
+    assert l2.name == String("early_exit")
+    assert l2.body == CodeBlock(PreIncrement(x), PreDecrement(y))
+    assert ccode(l2) == ("early_exit:\n"
+        "{\n   ++(x);\n   --(y);\n}")
+
+
+def test_PreDecrement():
+    p = PreDecrement(x)
+    assert p.func(*p.args) == p
+    assert ccode(p) == '--(x)'
+
+
+def test_PostDecrement():
+    p = PostDecrement(x)
+    assert p.func(*p.args) == p
+    assert ccode(p) == '(x)--'
+
+
+def test_PreIncrement():
+    p = PreIncrement(x)
+    assert p.func(*p.args) == p
+    assert ccode(p) == '++(x)'
+
+
+def test_PostIncrement():
+    p = PostIncrement(x)
+    assert p.func(*p.args) == p
+    assert ccode(p) == '(x)++'
+
+
+def test_sizeof():
+    typename = 'unsigned int'
+    sz = sizeof(typename)
+    assert ccode(sz) == 'sizeof(%s)' % typename
+    assert sz.func(*sz.args) == sz
+    assert not sz.is_Atom
+    assert sz.atoms() == {String('unsigned int'), String('sizeof')}
+
+
+def test_struct():
+    vx, vy = Variable(x, type=float64), Variable(y, type=float64)
+    s = struct('vec2', [vx, vy])
+    assert s.func(*s.args) == s
+    assert s == struct('vec2', (vx, vy))
+    assert s != struct('vec2', (vy, vx))
+    assert str(s.name) == 'vec2'
+    assert len(s.declarations) == 2
+    assert all(isinstance(arg, Declaration) for arg in s.declarations)
+    assert ccode(s) == (
+        "struct vec2 {\n"
+        "   double x;\n"
+        "   double y;\n"
+        "}")
+
+
+def test_union():
+    vx, vy = Variable(x, type=float64), Variable(y, type=int64)
+    u = union('dualuse', [vx, vy])
+    assert u.func(*u.args) == u
+    assert u == union('dualuse', (vx, vy))
+    assert str(u.name) == 'dualuse'
+    assert len(u.declarations) == 2
+    assert all(isinstance(arg, Declaration) for arg in u.declarations)
+    assert ccode(u) == (
+        "union dualuse {\n"
+        "   double x;\n"
+        "   int64_t y;\n"
+        "}")