Add files using upload-large-folder tool

.gitattributes

@@ -1189,3 +1189,5 @@ evalkit_cambrian/lib/python3.10/site-packages/matplotlib/mpl-data/fonts/ttf/Deja
 evalkit_tf449/lib/python3.10/site-packages/fontTools/subset/__pycache__/__init__.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
 evalkit_tf449/lib/python3.10/site-packages/nvidia/cuda_cupti/lib/libnvperf_host.so filter=lfs diff=lfs merge=lfs -text
 evalkit_cambrian/lib/python3.10/site-packages/matplotlib/__pycache__/figure.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
+janusflow/bin/python filter=lfs diff=lfs merge=lfs -text
+evalkit_tf449/lib/python3.10/site-packages/nvidia/cufft/lib/libcufftw.so.11 filter=lfs diff=lfs merge=lfs -text

evalkit_tf449/lib/python3.10/site-packages/_distutils_hack/__init__.py

@@ -0,0 +1,239 @@
+# don't import any costly modules
+import os
+import sys
+
+report_url = (
+    "https://github.com/pypa/setuptools/issues/new?template=distutils-deprecation.yml"
+)
+
+
+def warn_distutils_present():
+    if 'distutils' not in sys.modules:
+        return
+    import warnings
+
+    warnings.warn(
+        "Distutils was imported before Setuptools, but importing Setuptools "
+        "also replaces the `distutils` module in `sys.modules`. This may lead "
+        "to undesirable behaviors or errors. To avoid these issues, avoid "
+        "using distutils directly, ensure that setuptools is installed in the "
+        "traditional way (e.g. not an editable install), and/or make sure "
+        "that setuptools is always imported before distutils."
+    )
+
+
+def clear_distutils():
+    if 'distutils' not in sys.modules:
+        return
+    import warnings
+
+    warnings.warn(
+        "Setuptools is replacing distutils. Support for replacing "
+        "an already imported distutils is deprecated. In the future, "
+        "this condition will fail. "
+        f"Register concerns at {report_url}"
+    )
+    mods = [
+        name
+        for name in sys.modules
+        if name == "distutils" or name.startswith("distutils.")
+    ]
+    for name in mods:
+        del sys.modules[name]
+
+
+def enabled():
+    """
+    Allow selection of distutils by environment variable.
+    """
+    which = os.environ.get('SETUPTOOLS_USE_DISTUTILS', 'local')
+    if which == 'stdlib':
+        import warnings
+
+        warnings.warn(
+            "Reliance on distutils from stdlib is deprecated. Users "
+            "must rely on setuptools to provide the distutils module. "
+            "Avoid importing distutils or import setuptools first, "
+            "and avoid setting SETUPTOOLS_USE_DISTUTILS=stdlib. "
+            f"Register concerns at {report_url}"
+        )
+    return which == 'local'
+
+
+def ensure_local_distutils():
+    import importlib
+
+    clear_distutils()
+
+    # With the DistutilsMetaFinder in place,
+    # perform an import to cause distutils to be
+    # loaded from setuptools._distutils. Ref #2906.
+    with shim():
+        importlib.import_module('distutils')
+
+    # check that submodules load as expected
+    core = importlib.import_module('distutils.core')
+    assert '_distutils' in core.__file__, core.__file__
+    assert 'setuptools._distutils.log' not in sys.modules
+
+
+def do_override():
+    """
+    Ensure that the local copy of distutils is preferred over stdlib.
+
+    See https://github.com/pypa/setuptools/issues/417#issuecomment-392298401
+    for more motivation.
+    """
+    if enabled():
+        warn_distutils_present()
+        ensure_local_distutils()
+
+
+class _TrivialRe:
+    def __init__(self, *patterns) -> None:
+        self._patterns = patterns
+
+    def match(self, string):
+        return all(pat in string for pat in self._patterns)
+
+
+class DistutilsMetaFinder:
+    def find_spec(self, fullname, path, target=None):
+        # optimization: only consider top level modules and those
+        # found in the CPython test suite.
+        if path is not None and not fullname.startswith('test.'):
+            return None
+
+        method_name = 'spec_for_{fullname}'.format(**locals())
+        method = getattr(self, method_name, lambda: None)
+        return method()
+
+    def spec_for_distutils(self):
+        if self.is_cpython():
+            return None
+
+        import importlib
+        import importlib.abc
+        import importlib.util
+
+        try:
+            mod = importlib.import_module('setuptools._distutils')
+        except Exception:
+            # There are a couple of cases where setuptools._distutils
+            # may not be present:
+            # - An older Setuptools without a local distutils is
+            #   taking precedence. Ref #2957.
+            # - Path manipulation during sitecustomize removes
+            #   setuptools from the path but only after the hook
+            #   has been loaded. Ref #2980.
+            # In either case, fall back to stdlib behavior.
+            return None
+
+        class DistutilsLoader(importlib.abc.Loader):
+            def create_module(self, spec):
+                mod.__name__ = 'distutils'
+                return mod
+
+            def exec_module(self, module):
+                pass
+
+        return importlib.util.spec_from_loader(
+            'distutils', DistutilsLoader(), origin=mod.__file__
+        )
+
+    @staticmethod
+    def is_cpython():
+        """
+        Suppress supplying distutils for CPython (build and tests).
+        Ref #2965 and #3007.
+        """
+        return os.path.isfile('pybuilddir.txt')
+
+    def spec_for_pip(self):
+        """
+        Ensure stdlib distutils when running under pip.
+        See pypa/pip#8761 for rationale.
+        """
+        if sys.version_info >= (3, 12) or self.pip_imported_during_build():
+            return
+        clear_distutils()
+        self.spec_for_distutils = lambda: None
+
+    @classmethod
+    def pip_imported_during_build(cls):
+        """
+        Detect if pip is being imported in a build script. Ref #2355.
+        """
+        import traceback
+
+        return any(
+            cls.frame_file_is_setup(frame) for frame, line in traceback.walk_stack(None)
+        )
+
+    @staticmethod
+    def frame_file_is_setup(frame):
+        """
+        Return True if the indicated frame suggests a setup.py file.
+        """
+        # some frames may not have __file__ (#2940)
+        return frame.f_globals.get('__file__', '').endswith('setup.py')
+
+    def spec_for_sensitive_tests(self):
+        """
+        Ensure stdlib distutils when running select tests under CPython.
+
+        python/cpython#91169
+        """
+        clear_distutils()
+        self.spec_for_distutils = lambda: None
+
+    sensitive_tests = (
+        [
+            'test.test_distutils',
+            'test.test_peg_generator',
+            'test.test_importlib',
+        ]
+        if sys.version_info < (3, 10)
+        else [
+            'test.test_distutils',
+        ]
+    )
+
+
+for name in DistutilsMetaFinder.sensitive_tests:
+    setattr(
+        DistutilsMetaFinder,
+        f'spec_for_{name}',
+        DistutilsMetaFinder.spec_for_sensitive_tests,
+    )
+
+
+DISTUTILS_FINDER = DistutilsMetaFinder()
+
+
+def add_shim():
+    DISTUTILS_FINDER in sys.meta_path or insert_shim()
+
+
+class shim:
+    def __enter__(self) -> None:
+        insert_shim()
+
+    def __exit__(self, exc: object, value: object, tb: object) -> None:
+        _remove_shim()
+
+
+def insert_shim():
+    sys.meta_path.insert(0, DISTUTILS_FINDER)
+
+
+def _remove_shim():
+    try:
+        sys.meta_path.remove(DISTUTILS_FINDER)
+    except ValueError:
+        pass
+
+
+if sys.version_info < (3, 12):
+    # DistutilsMetaFinder can only be disabled in Python < 3.12 (PEP 632)
+    remove_shim = _remove_shim

evalkit_tf449/lib/python3.10/site-packages/_distutils_hack/override.py

@@ -0,0 +1 @@
+__import__('_distutils_hack').do_override()

evalkit_tf449/lib/python3.10/site-packages/nvidia/cufft/lib/libcufftw.so.11

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

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

@@ -0,0 +1,1077 @@
+
+ /* 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_H_)
+#define CURAND_H_
+
+/**
+ * \defgroup HOST Host API
+ *
+ * @{
+ */
+#ifndef __CUDACC_RTC__
+#include <cuda_runtime.h>
+#endif
+
+#ifndef CURANDAPI
+#ifdef _WIN32
+#define CURANDAPI __stdcall
+#else
+#define CURANDAPI
+#endif
+#endif
+
+#if defined(__cplusplus)
+extern "C" {
+#endif /* __cplusplus */
+
+#define CURAND_VER_MAJOR 10
+#define CURAND_VER_MINOR 3
+#define CURAND_VER_PATCH 5
+#define CURAND_VER_BUILD 147
+#define CURAND_VERSION (CURAND_VER_MAJOR * 1000 + \
+                        CURAND_VER_MINOR *  100 + \
+                        CURAND_VER_PATCH)
+/* CURAND Host API datatypes */
+
+/**
+ * @{
+ */
+
+/**
+ * CURAND function call status types
+ */
+enum curandStatus {
+    CURAND_STATUS_SUCCESS = 0, ///< No errors
+    CURAND_STATUS_VERSION_MISMATCH = 100, ///< Header file and linked library version do not match
+    CURAND_STATUS_NOT_INITIALIZED = 101, ///< Generator not initialized
+    CURAND_STATUS_ALLOCATION_FAILED = 102, ///< Memory allocation failed
+    CURAND_STATUS_TYPE_ERROR = 103, ///< Generator is wrong type
+    CURAND_STATUS_OUT_OF_RANGE = 104, ///< Argument out of range
+    CURAND_STATUS_LENGTH_NOT_MULTIPLE = 105, ///< Length requested is not a multple of dimension
+    CURAND_STATUS_DOUBLE_PRECISION_REQUIRED = 106, ///< GPU does not have double precision required by MRG32k3a
+    CURAND_STATUS_LAUNCH_FAILURE = 201, ///< Kernel launch failure
+    CURAND_STATUS_PREEXISTING_FAILURE = 202, ///< Preexisting failure on library entry
+    CURAND_STATUS_INITIALIZATION_FAILED = 203, ///< Initialization of CUDA failed
+    CURAND_STATUS_ARCH_MISMATCH = 204, ///< Architecture mismatch, GPU does not support requested feature
+    CURAND_STATUS_INTERNAL_ERROR = 999 ///< Internal library error
+};
+
+/*
+ * CURAND function call status types
+*/
+/** \cond UNHIDE_TYPEDEFS */
+typedef enum curandStatus curandStatus_t;
+/** \endcond */
+
+/**
+ * CURAND generator types
+ */
+enum curandRngType {
+    CURAND_RNG_TEST = 0,
+    CURAND_RNG_PSEUDO_DEFAULT = 100, ///< Default pseudorandom generator
+    CURAND_RNG_PSEUDO_XORWOW = 101, ///< XORWOW pseudorandom generator
+    CURAND_RNG_PSEUDO_MRG32K3A = 121, ///< MRG32k3a pseudorandom generator
+    CURAND_RNG_PSEUDO_MTGP32 = 141, ///< Mersenne Twister MTGP32 pseudorandom generator
+    CURAND_RNG_PSEUDO_MT19937 = 142, ///< Mersenne Twister MT19937 pseudorandom generator
+    CURAND_RNG_PSEUDO_PHILOX4_32_10 = 161, ///< PHILOX-4x32-10 pseudorandom generator
+    CURAND_RNG_QUASI_DEFAULT = 200, ///< Default quasirandom generator
+    CURAND_RNG_QUASI_SOBOL32 = 201, ///< Sobol32 quasirandom generator
+    CURAND_RNG_QUASI_SCRAMBLED_SOBOL32 = 202,  ///< Scrambled Sobol32 quasirandom generator
+    CURAND_RNG_QUASI_SOBOL64 = 203, ///< Sobol64 quasirandom generator
+    CURAND_RNG_QUASI_SCRAMBLED_SOBOL64 = 204  ///< Scrambled Sobol64 quasirandom generator
+};
+
+/*
+ * CURAND generator types
+ */
+/** \cond UNHIDE_TYPEDEFS */
+typedef enum curandRngType curandRngType_t;
+/** \endcond */
+
+/**
+ * CURAND ordering of results in memory
+ */
+enum curandOrdering {
+    CURAND_ORDERING_PSEUDO_BEST = 100, ///< Best ordering for pseudorandom results
+    CURAND_ORDERING_PSEUDO_DEFAULT = 101, ///< Specific default thread sequence for pseudorandom results, same as CURAND_ORDERING_PSEUDO_BEST
+    CURAND_ORDERING_PSEUDO_SEEDED = 102, ///< Specific seeding pattern for fast lower quality pseudorandom results
+    CURAND_ORDERING_PSEUDO_LEGACY = 103, ///< Specific legacy sequence for pseudorandom results, guaranteed to remain the same for all cuRAND release
+    CURAND_ORDERING_PSEUDO_DYNAMIC = 104, ///< Specific ordering adjusted to the device it is being executed on, provides the best performance
+    CURAND_ORDERING_QUASI_DEFAULT = 201 ///< Specific n-dimensional ordering for quasirandom results
+};
+
+/*
+ * CURAND ordering of results in memory
+ */
+/** \cond UNHIDE_TYPEDEFS */
+typedef enum curandOrdering curandOrdering_t;
+/** \endcond */
+
+/**
+ * CURAND choice of direction vector set
+ */
+enum curandDirectionVectorSet {
+    CURAND_DIRECTION_VECTORS_32_JOEKUO6 = 101, ///< Specific set of 32-bit direction vectors generated from polynomials recommended by S. Joe and F. Y. Kuo, for up to 20,000 dimensions
+    CURAND_SCRAMBLED_DIRECTION_VECTORS_32_JOEKUO6 = 102, ///< Specific set of 32-bit direction vectors generated from polynomials recommended by S. Joe and F. Y. Kuo, for up to 20,000 dimensions, and scrambled
+    CURAND_DIRECTION_VECTORS_64_JOEKUO6 = 103, ///< Specific set of 64-bit direction vectors generated from polynomials recommended by S. Joe and F. Y. Kuo, for up to 20,000 dimensions
+    CURAND_SCRAMBLED_DIRECTION_VECTORS_64_JOEKUO6 = 104 ///< Specific set of 64-bit direction vectors generated from polynomials recommended by S. Joe and F. Y. Kuo, for up to 20,000 dimensions, and scrambled
+};
+
+/*
+ * CURAND choice of direction vector set
+ */
+/** \cond UNHIDE_TYPEDEFS */
+typedef enum curandDirectionVectorSet curandDirectionVectorSet_t;
+/** \endcond */
+
+/**
+ * CURAND array of 32-bit direction vectors
+ */
+/** \cond UNHIDE_TYPEDEFS */
+typedef unsigned int curandDirectionVectors32_t[32];
+/** \endcond */
+
+ /**
+ * CURAND array of 64-bit direction vectors
+ */
+/** \cond UNHIDE_TYPEDEFS */
+typedef unsigned long long curandDirectionVectors64_t[64];
+/** \endcond **/
+
+/**
+ * CURAND generator (opaque)
+ */
+struct curandGenerator_st;
+
+/**
+ * CURAND generator
+ */
+/** \cond UNHIDE_TYPEDEFS */
+typedef struct curandGenerator_st *curandGenerator_t;
+/** \endcond */
+
+/**
+ * CURAND distribution
+ */
+/** \cond UNHIDE_TYPEDEFS */
+typedef double curandDistribution_st;
+typedef curandDistribution_st *curandDistribution_t;
+typedef struct curandDistributionShift_st *curandDistributionShift_t;
+/** \endcond */
+/**
+ * CURAND distribution M2
+ */
+/** \cond UNHIDE_TYPEDEFS */
+typedef struct curandDistributionM2Shift_st *curandDistributionM2Shift_t;
+typedef struct curandHistogramM2_st *curandHistogramM2_t;
+typedef unsigned int curandHistogramM2K_st;
+typedef curandHistogramM2K_st *curandHistogramM2K_t;
+typedef curandDistribution_st curandHistogramM2V_st;
+typedef curandHistogramM2V_st *curandHistogramM2V_t;
+
+typedef struct curandDiscreteDistribution_st *curandDiscreteDistribution_t;
+/** \endcond */
+
+/*
+ * CURAND METHOD
+ */
+/** \cond UNHIDE_ENUMS */
+enum curandMethod {
+    CURAND_CHOOSE_BEST = 0, // choose best depends on args
+    CURAND_ITR = 1,
+    CURAND_KNUTH = 2,
+    CURAND_HITR = 3,
+    CURAND_M1 = 4,
+    CURAND_M2 = 5,
+    CURAND_BINARY_SEARCH = 6,
+    CURAND_DISCRETE_GAUSS = 7,
+    CURAND_REJECTION = 8,
+    CURAND_DEVICE_API = 9,
+    CURAND_FAST_REJECTION = 10,
+    CURAND_3RD = 11,
+    CURAND_DEFINITION = 12,
+    CURAND_POISSON = 13
+};
+
+typedef enum curandMethod curandMethod_t;
+/** \endcond */
+
+
+#ifndef __CUDACC_RTC__
+
+/**
+ * @}
+ */
+
+/**
+ * \brief Create new random number generator.
+ *
+ * Creates a new random number generator of type \p rng_type
+ * and returns it in \p *generator.
+ *
+ * Legal values for \p rng_type are:
+ * - CURAND_RNG_PSEUDO_DEFAULT
+ * - CURAND_RNG_PSEUDO_XORWOW
+ * - CURAND_RNG_PSEUDO_MRG32K3A
+ * - CURAND_RNG_PSEUDO_MTGP32
+ * - CURAND_RNG_PSEUDO_MT19937
+ * - CURAND_RNG_PSEUDO_PHILOX4_32_10
+ * - CURAND_RNG_QUASI_DEFAULT
+ * - CURAND_RNG_QUASI_SOBOL32
+ * - CURAND_RNG_QUASI_SCRAMBLED_SOBOL32
+ * - CURAND_RNG_QUASI_SOBOL64
+ * - CURAND_RNG_QUASI_SCRAMBLED_SOBOL64
+ *
+ * When \p rng_type is CURAND_RNG_PSEUDO_DEFAULT, the type chosen
+ * is CURAND_RNG_PSEUDO_XORWOW.  \n
+ * When \p rng_type is CURAND_RNG_QUASI_DEFAULT,
+ * the type chosen is CURAND_RNG_QUASI_SOBOL32.
+ *
+ * The default values for \p rng_type = CURAND_RNG_PSEUDO_XORWOW are:
+ * - \p seed = 0
+ * - \p offset = 0
+ * - \p ordering = CURAND_ORDERING_PSEUDO_DEFAULT
+ *
+ * The default values for \p rng_type = CURAND_RNG_PSEUDO_MRG32K3A are:
+ * - \p seed = 0
+ * - \p offset = 0
+ * - \p ordering = CURAND_ORDERING_PSEUDO_DEFAULT
+ *
+ * The default values for \p rng_type = CURAND_RNG_PSEUDO_MTGP32 are:
+ * - \p seed = 0
+ * - \p offset = 0
+ * - \p ordering = CURAND_ORDERING_PSEUDO_DEFAULT
+ *
+ * The default values for \p rng_type = CURAND_RNG_PSEUDO_MT19937 are:
+ * - \p seed = 0
+ * - \p offset = 0
+ * - \p ordering = CURAND_ORDERING_PSEUDO_DEFAULT
+ *
+ * * The default values for \p rng_type = CURAND_RNG_PSEUDO_PHILOX4_32_10 are:
+ * - \p seed = 0
+ * - \p offset = 0
+ * - \p ordering = CURAND_ORDERING_PSEUDO_DEFAULT
+ *
+ * The default values for \p rng_type = CURAND_RNG_QUASI_SOBOL32 are:
+ * - \p dimensions = 1
+ * - \p offset = 0
+ * - \p ordering = CURAND_ORDERING_QUASI_DEFAULT
+ *
+ * The default values for \p rng_type = CURAND_RNG_QUASI_SOBOL64 are:
+ * - \p dimensions = 1
+ * - \p offset = 0
+ * - \p ordering = CURAND_ORDERING_QUASI_DEFAULT
+ *
+ * The default values for \p rng_type = CURAND_RNG_QUASI_SCRAMBBLED_SOBOL32 are:
+ * - \p dimensions = 1
+ * - \p offset = 0
+ * - \p ordering = CURAND_ORDERING_QUASI_DEFAULT
+ *
+ * The default values for \p rng_type = CURAND_RNG_QUASI_SCRAMBLED_SOBOL64 are:
+ * - \p dimensions = 1
+ * - \p offset = 0
+ * - \p ordering = CURAND_ORDERING_QUASI_DEFAULT
+ *
+ * \param generator - Pointer to generator
+ * \param rng_type - Type of generator to create
+ *
+ * \return
+ * - CURAND_STATUS_ALLOCATION_FAILED, if memory could not be allocated \n
+ * - CURAND_STATUS_INITIALIZATION_FAILED if there was a problem setting up the GPU \n
+ * - CURAND_STATUS_VERSION_MISMATCH if the header file version does not match the
+ *   dynamically linked library version \n
+ * - CURAND_STATUS_TYPE_ERROR if the value for \p rng_type is invalid \n
+ * - CURAND_STATUS_SUCCESS if generator was created successfully \n
+ *
+ */
+curandStatus_t CURANDAPI
+curandCreateGenerator(curandGenerator_t *generator, curandRngType_t rng_type);
+
+/**
+ * \brief Create new host CPU random number generator.
+ *
+ * Creates a new host CPU random number generator of type \p rng_type
+ * and returns it in \p *generator.
+ *
+ * Legal values for \p rng_type are:
+ * - CURAND_RNG_PSEUDO_DEFAULT
+ * - CURAND_RNG_PSEUDO_XORWOW
+ * - CURAND_RNG_PSEUDO_MRG32K3A
+ * - CURAND_RNG_PSEUDO_MTGP32
+ * - CURAND_RNG_PSEUDO_MT19937
+ * - CURAND_RNG_PSEUDO_PHILOX4_32_10
+ * - CURAND_RNG_QUASI_DEFAULT
+ * - CURAND_RNG_QUASI_SOBOL32
+ *
+ * When \p rng_type is CURAND_RNG_PSEUDO_DEFAULT, the type chosen
+ * is CURAND_RNG_PSEUDO_XORWOW.  \n
+ * When \p rng_type is CURAND_RNG_QUASI_DEFAULT,
+ * the type chosen is CURAND_RNG_QUASI_SOBOL32.
+ *
+ * The default values for \p rng_type = CURAND_RNG_PSEUDO_XORWOW are:
+ * - \p seed = 0
+ * - \p offset = 0
+ * - \p ordering = CURAND_ORDERING_PSEUDO_DEFAULT
+ *
+ * The default values for \p rng_type = CURAND_RNG_PSEUDO_MRG32K3A are:
+ * - \p seed = 0
+ * - \p offset = 0
+ * - \p ordering = CURAND_ORDERING_PSEUDO_DEFAULT
+ *
+ * The default values for \p rng_type = CURAND_RNG_PSEUDO_MTGP32 are:
+ * - \p seed = 0
+ * - \p offset = 0
+ * - \p ordering = CURAND_ORDERING_PSEUDO_DEFAULT
+ *
+ * The default values for \p rng_type = CURAND_RNG_PSEUDO_MT19937 are:
+ * - \p seed = 0
+ * - \p offset = 0
+ * - \p ordering = CURAND_ORDERING_PSEUDO_DEFAULT
+ *
+ * * The default values for \p rng_type = CURAND_RNG_PSEUDO_PHILOX4_32_10 are:
+ * - \p seed = 0
+ * - \p offset = 0
+ * - \p ordering = CURAND_ORDERING_PSEUDO_DEFAULT
+ *
+ * The default values for \p rng_type = CURAND_RNG_QUASI_SOBOL32 are:
+ * - \p dimensions = 1
+ * - \p offset = 0
+ * - \p ordering = CURAND_ORDERING_QUASI_DEFAULT
+ *
+ * The default values for \p rng_type = CURAND_RNG_QUASI_SOBOL64 are:
+ * - \p dimensions = 1
+ * - \p offset = 0
+ * - \p ordering = CURAND_ORDERING_QUASI_DEFAULT
+ *
+ * The default values for \p rng_type = CURAND_RNG_QUASI_SCRAMBLED_SOBOL32 are:
+ * - \p dimensions = 1
+ * - \p offset = 0
+ * - \p ordering = CURAND_ORDERING_QUASI_DEFAULT
+ *
+ * The default values for \p rng_type = CURAND_RNG_QUASI_SCRAMBLED_SOBOL64 are:
+ * - \p dimensions = 1
+ * - \p offset = 0
+ * - \p ordering = CURAND_ORDERING_QUASI_DEFAULT
+ *
+ * \param generator - Pointer to generator
+ * \param rng_type - Type of generator to create
+ *
+ * \return
+ * - CURAND_STATUS_ALLOCATION_FAILED if memory could not be allocated \n
+ * - CURAND_STATUS_INITIALIZATION_FAILED if there was a problem setting up the GPU \n
+ * - CURAND_STATUS_VERSION_MISMATCH if the header file version does not match the
+ *   dynamically linked library version \n
+ * - CURAND_STATUS_TYPE_ERROR if the value for \p rng_type is invalid \n
+ * - CURAND_STATUS_SUCCESS if generator was created successfully \n
+ */
+curandStatus_t CURANDAPI
+curandCreateGeneratorHost(curandGenerator_t *generator, curandRngType_t rng_type);
+
+/**
+ * \brief Destroy an existing generator.
+ *
+ * Destroy an existing generator and free all memory associated with its state.
+ *
+ * \param generator - Generator to destroy
+ *
+ * \return
+ * - CURAND_STATUS_NOT_INITIALIZED if the generator was never created \n
+ * - CURAND_STATUS_SUCCESS if generator was destroyed successfully \n
+ */
+curandStatus_t CURANDAPI
+curandDestroyGenerator(curandGenerator_t generator);
+
+/**
+ * \brief Return the version number of the library.
+ *
+ * Return in \p *version the version number of the dynamically linked CURAND
+ * library.  The format is the same as CUDART_VERSION from the CUDA Runtime.
+ * The only supported configuration is CURAND version equal to CUDA Runtime
+ * version.
+ *
+ * \param version - CURAND library version
+ *
+ * \return
+ * - CURAND_STATUS_SUCCESS if the version number was successfully returned \n
+ */
+curandStatus_t CURANDAPI
+curandGetVersion(int *version);
+
+/**
+* \brief Return the value of the curand property.
+*
+* Return in \p *value the number for the property described by \p type of the
+* dynamically linked CURAND library.
+*
+* \param type - CUDA library property
+* \param value - integer value for the requested property
+*
+* \return
+* - CURAND_STATUS_SUCCESS if the property value was successfully returned \n
+* - CURAND_STATUS_OUT_OF_RANGE if the property type is not recognized \n
+*/
+curandStatus_t CURANDAPI
+curandGetProperty(libraryPropertyType type, int *value);
+
+
+/**
+ * \brief Set the current stream for CURAND kernel launches.
+ *
+ * Set the current stream for CURAND kernel launches.  All library functions
+ * will use this stream until set again.
+ *
+ * \param generator - Generator to modify
+ * \param stream - Stream to use or ::NULL for null stream
+ *
+ * \return
+ * - CURAND_STATUS_NOT_INITIALIZED if the generator was never created \n
+ * - CURAND_STATUS_SUCCESS if stream was set successfully \n
+ */
+curandStatus_t CURANDAPI
+curandSetStream(curandGenerator_t generator, cudaStream_t stream);
+
+/**
+ * \brief Set the seed value of the pseudo-random number generator.
+ *
+ * Set the seed value of the pseudorandom number generator.
+ * All values of seed are valid.  Different seeds will produce different sequences.
+ * Different seeds will often not be statistically correlated with each other,
+ * but some pairs of seed values may generate sequences which are statistically correlated.
+ *
+ * \param generator - Generator to modify
+ * \param seed - Seed value
+ *
+ * \return
+ * - CURAND_STATUS_NOT_INITIALIZED if the generator was never created \n
+ * - CURAND_STATUS_TYPE_ERROR if the generator is not a pseudorandom number generator \n
+ * - CURAND_STATUS_SUCCESS if generator seed was set successfully \n
+ */
+curandStatus_t CURANDAPI
+curandSetPseudoRandomGeneratorSeed(curandGenerator_t generator, unsigned long long seed);
+
+/**
+ * \brief Set the absolute offset of the pseudo or quasirandom number generator.
+ *
+ * Set the absolute offset of the pseudo or quasirandom number generator.
+ *
+ * All values of offset are valid.  The offset position is absolute, not
+ * relative to the current position in the sequence.
+ *
+ * \param generator - Generator to modify
+ * \param offset - Absolute offset position
+ *
+ * \return
+ * - CURAND_STATUS_NOT_INITIALIZED if the generator was never created \n
+ * - CURAND_STATUS_SUCCESS if generator offset was set successfully \n
+ */
+curandStatus_t CURANDAPI
+curandSetGeneratorOffset(curandGenerator_t generator, unsigned long long offset);
+
+/**
+ * \brief Set the ordering of results of the pseudo or quasirandom number generator.
+ *
+ * Set the ordering of results of the pseudo or quasirandom number generator.
+ *
+ * Legal values of \p order for pseudorandom generators are:
+ * - CURAND_ORDERING_PSEUDO_DEFAULT
+ * - CURAND_ORDERING_PSEUDO_BEST
+ * - CURAND_ORDERING_PSEUDO_SEEDED
+ * - CURAND_ORDERING_PSEUDO_LEGACY
+ *
+ * Legal values of \p order for quasirandom generators are:
+ * - CURAND_ORDERING_QUASI_DEFAULT
+ *
+ * \param generator - Generator to modify
+ * \param order - Ordering of results
+ *
+ * \return
+ * - CURAND_STATUS_NOT_INITIALIZED if the generator was never created \n
+ * - CURAND_STATUS_OUT_OF_RANGE if the ordering is not valid \n
+ * - CURAND_STATUS_SUCCESS if generator ordering was set successfully \n
+ */
+curandStatus_t CURANDAPI
+curandSetGeneratorOrdering(curandGenerator_t generator, curandOrdering_t order);
+
+/**
+ * \brief Set the number of dimensions.
+ *
+ * Set the number of dimensions to be generated by the quasirandom number
+ * generator.
+ *
+ * Legal values for \p num_dimensions are 1 to 20000.
+ *
+ * \param generator - Generator to modify
+ * \param num_dimensions - Number of dimensions
+ *
+ * \return
+ * - CURAND_STATUS_NOT_INITIALIZED if the generator was never created \n
+ * - CURAND_STATUS_OUT_OF_RANGE if num_dimensions is not valid \n
+ * - CURAND_STATUS_TYPE_ERROR if the generator is not a quasirandom number generator \n
+ * - CURAND_STATUS_SUCCESS if generator ordering was set successfully \n
+ */
+curandStatus_t CURANDAPI
+curandSetQuasiRandomGeneratorDimensions(curandGenerator_t generator, unsigned int num_dimensions);
+
+/**
+ * \brief Generate 32-bit pseudo or quasirandom numbers.
+ *
+ * Use \p generator to generate \p num 32-bit results into the device memory at
+ * \p outputPtr.  The device memory must have been previously allocated and be
+ * large enough to hold all the results.  Launches are done with the stream
+ * set using ::curandSetStream(), or the null stream if no stream has been set.
+ *
+ * Results are 32-bit values with every bit random.
+ *
+ * \param generator - Generator to use
+ * \param outputPtr - Pointer to device memory to store CUDA-generated results, or
+ *                 Pointer to host memory to store CPU-generated results
+ * \param num - Number of random 32-bit values to generate
+ *
+ * \return
+ * - CURAND_STATUS_ALLOCATION_FAILED if memory could not be allocated \n
+ * - CURAND_STATUS_NOT_INITIALIZED if the generator was never created \n
+ * - CURAND_STATUS_PREEXISTING_FAILURE if there was an existing error from
+ *     a previous kernel launch \n
+ * - CURAND_STATUS_LENGTH_NOT_MULTIPLE if the number of output samples is
+ *    not a multiple of the quasirandom dimension \n
+ * - CURAND_STATUS_LAUNCH_FAILURE if the kernel launch failed for any reason \n
+ * - CURAND_STATUS_TYPE_ERROR if the generator is a 64 bit quasirandom generator.
+ * (use ::curandGenerateLongLong() with 64 bit quasirandom generators)
+ * - CURAND_STATUS_SUCCESS if the results were generated successfully \n
+ */
+curandStatus_t CURANDAPI
+curandGenerate(curandGenerator_t generator, unsigned int *outputPtr, size_t num);
+
+/**
+ * \brief Generate 64-bit quasirandom numbers.
+ *
+ * Use \p generator to generate \p num 64-bit results into the device memory at
+ * \p outputPtr.  The device memory must have been previously allocated and be
+ * large enough to hold all the results.  Launches are done with the stream
+ * set using ::curandSetStream(), or the null stream if no stream has been set.
+ *
+ * Results are 64-bit values with every bit random.
+ *
+ * \param generator - Generator to use
+ * \param outputPtr - Pointer to device memory to store CUDA-generated results, or
+ *                 Pointer to host memory to store CPU-generated results
+ * \param num - Number of random 64-bit values to generate
+ *
+ * \return
+ * - CURAND_STATUS_NOT_INITIALIZED if the generator was never created \n
+ * - CURAND_STATUS_PREEXISTING_FAILURE if there was an existing error from
+ *     a previous kernel launch \n
+ * - CURAND_STATUS_LENGTH_NOT_MULTIPLE if the number of output samples is
+ *    not a multiple of the quasirandom dimension \n
+ * - CURAND_STATUS_LAUNCH_FAILURE if the kernel launch failed for any reason \n
+ * - CURAND_STATUS_TYPE_ERROR if the generator is not a 64 bit quasirandom generator\n
+ * - CURAND_STATUS_SUCCESS if the results were generated successfully \n
+ */
+curandStatus_t CURANDAPI
+curandGenerateLongLong(curandGenerator_t generator, unsigned long long *outputPtr, size_t num);
+
+/**
+ * \brief Generate uniformly distributed floats.
+ *
+ * Use \p generator to generate \p num float results into the device memory at
+ * \p outputPtr.  The device memory must have been previously allocated and be
+ * large enough to hold all the results.  Launches are done with the stream
+ * set using ::curandSetStream(), or the null stream if no stream has been set.
+ *
+ * Results are 32-bit floating point values between \p 0.0f and \p 1.0f,
+ * excluding \p 0.0f and including \p 1.0f.
+ *
+ * \param generator - Generator to use
+ * \param outputPtr - Pointer to device memory to store CUDA-generated results, or
+ *                 Pointer to host memory to store CPU-generated results
+ * \param num - Number of floats to generate
+ *
+ * \return
+ * - CURAND_STATUS_ALLOCATION_FAILED if memory could not be allocated \n
+ * - CURAND_STATUS_NOT_INITIALIZED if the generator was never created \n
+ * - CURAND_STATUS_PREEXISTING_FAILURE if there was an existing error from
+ *    a previous kernel launch \n
+ * - CURAND_STATUS_LAUNCH_FAILURE if the kernel launch failed for any reason \n
+ * - CURAND_STATUS_LENGTH_NOT_MULTIPLE if the number of output samples is
+ *    not a multiple of the quasirandom dimension \n
+ * - CURAND_STATUS_SUCCESS if the results were generated successfully \n
+ */
+curandStatus_t CURANDAPI
+curandGenerateUniform(curandGenerator_t generator, float *outputPtr, size_t num);
+
+/**
+ * \brief Generate uniformly distributed doubles.
+ *
+ * Use \p generator to generate \p num double results into the device memory at
+ * \p outputPtr.  The device memory must have been previously allocated and be
+ * large enough to hold all the results.  Launches are done with the stream
+ * set using ::curandSetStream(), or the null stream if no stream has been set.
+ *
+ * Results are 64-bit double precision floating point values between
+ * \p 0.0 and \p 1.0, excluding \p 0.0 and including \p 1.0.
+ *
+ * \param generator - Generator to use
+ * \param outputPtr - Pointer to device memory to store CUDA-generated results, or
+ *                 Pointer to host memory to store CPU-generated results
+ * \param num - Number of doubles to generate
+ *
+ * \return
+ * - CURAND_STATUS_ALLOCATION_FAILED if memory could not be allocated \n
+ * - CURAND_STATUS_NOT_INITIALIZED if the generator was never created \n
+ * - CURAND_STATUS_PREEXISTING_FAILURE if there was an existing error from
+ *    a previous kernel launch \n
+ * - CURAND_STATUS_LAUNCH_FAILURE if the kernel launch failed for any reason \n
+ * - CURAND_STATUS_LENGTH_NOT_MULTIPLE if the number of output samples is
+ *    not a multiple of the quasirandom dimension \n
+ * - CURAND_STATUS_DOUBLE_PRECISION_REQUIRED if the GPU does not support double precision \n
+ * - CURAND_STATUS_SUCCESS if the results were generated successfully \n
+ */
+curandStatus_t CURANDAPI
+curandGenerateUniformDouble(curandGenerator_t generator, double *outputPtr, size_t num);
+
+/**
+ * \brief Generate normally distributed doubles.
+ *
+ * Use \p generator to generate \p n float results into the device memory at
+ * \p outputPtr.  The device memory must have been previously allocated and be
+ * large enough to hold all the results.  Launches are done with the stream
+ * set using ::curandSetStream(), or the null stream if no stream has been set.
+ *
+ * Results are 32-bit floating point values with mean \p mean and standard
+ * deviation \p stddev.
+ *
+ * Normally distributed results are generated from pseudorandom generators
+ * with a Box-Muller transform, and so require \p n to be even.
+ * Quasirandom generators use an inverse cumulative distribution
+ * function to preserve dimensionality.
+ *
+ * There may be slight numerical differences between results generated
+ * on the GPU with generators created with ::curandCreateGenerator()
+ * and results calculated on the CPU with generators created with
+ * ::curandCreateGeneratorHost().  These differences arise because of
+ * differences in results for transcendental functions.  In addition,
+ * future versions of CURAND may use newer versions of the CUDA math
+ * library, so different versions of CURAND may give slightly different
+ * numerical values.
+ *
+ * \param generator - Generator to use
+ * \param outputPtr - Pointer to device memory to store CUDA-generated results, or
+ *                 Pointer to host memory to store CPU-generated results
+ * \param n - Number of floats to generate
+ * \param mean - Mean of normal distribution
+ * \param stddev - Standard deviation of normal distribution
+ *
+ * \return
+ * - CURAND_STATUS_ALLOCATION_FAILED if memory could not be allocated \n
+ * - CURAND_STATUS_NOT_INITIALIZED if the generator was never created \n
+ * - CURAND_STATUS_PREEXISTING_FAILURE if there was an existing error from
+ *    a previous kernel launch \n
+ * - CURAND_STATUS_LAUNCH_FAILURE if the kernel launch failed for any reason \n
+ * - CURAND_STATUS_LENGTH_NOT_MULTIPLE if the number of output samples is
+ *    not a multiple of the quasirandom dimension, or is not a multiple
+ *    of two for pseudorandom generators \n
+ * - CURAND_STATUS_SUCCESS if the results were generated successfully \n
+ */
+curandStatus_t CURANDAPI
+curandGenerateNormal(curandGenerator_t generator, float *outputPtr,
+                     size_t n, float mean, float stddev);
+
+/**
+ * \brief Generate normally distributed doubles.
+ *
+ * Use \p generator to generate \p n double results into the device memory at
+ * \p outputPtr.  The device memory must have been previously allocated and be
+ * large enough to hold all the results.  Launches are done with the stream
+ * set using ::curandSetStream(), or the null stream if no stream has been set.
+ *
+ * Results are 64-bit floating point values with mean \p mean and standard
+ * deviation \p stddev.
+ *
+ * Normally distributed results are generated from pseudorandom generators
+ * with a Box-Muller transform, and so require \p n to be even.
+ * Quasirandom generators use an inverse cumulative distribution
+ * function to preserve dimensionality.
+ *
+ * There may be slight numerical differences between results generated
+ * on the GPU with generators created with ::curandCreateGenerator()
+ * and results calculated on the CPU with generators created with
+ * ::curandCreateGeneratorHost().  These differences arise because of
+ * differences in results for transcendental functions.  In addition,
+ * future versions of CURAND may use newer versions of the CUDA math
+ * library, so different versions of CURAND may give slightly different
+ * numerical values.
+ *
+ * \param generator - Generator to use
+ * \param outputPtr - Pointer to device memory to store CUDA-generated results, or
+ *                 Pointer to host memory to store CPU-generated results
+ * \param n - Number of doubles to generate
+ * \param mean - Mean of normal distribution
+ * \param stddev - Standard deviation of normal distribution
+ *
+ * \return
+ * - CURAND_STATUS_ALLOCATION_FAILED if memory could not be allocated \n
+ * - CURAND_STATUS_NOT_INITIALIZED if the generator was never created \n
+ * - CURAND_STATUS_PREEXISTING_FAILURE if there was an existing error from
+ *    a previous kernel launch \n
+ * - CURAND_STATUS_LAUNCH_FAILURE if the kernel launch failed for any reason \n
+ * - CURAND_STATUS_LENGTH_NOT_MULTIPLE if the number of output samples is
+ *    not a multiple of the quasirandom dimension, or is not a multiple
+ *    of two for pseudorandom generators \n
+ * - CURAND_STATUS_DOUBLE_PRECISION_REQUIRED if the GPU does not support double precision \n
+ * - CURAND_STATUS_SUCCESS if the results were generated successfully \n
+ */
+curandStatus_t CURANDAPI
+curandGenerateNormalDouble(curandGenerator_t generator, double *outputPtr,
+                     size_t n, double mean, double stddev);
+
+/**
+ * \brief Generate log-normally distributed floats.
+ *
+ * Use \p generator to generate \p n float results into the device memory at
+ * \p outputPtr.  The device memory must have been previously allocated and be
+ * large enough to hold all the results.  Launches are done with the stream
+ * set using ::curandSetStream(), or the null stream if no stream has been set.
+ *
+ * Results are 32-bit floating point values with log-normal distribution based on
+ * an associated normal distribution with mean \p mean and standard deviation \p stddev.
+ *
+ * Normally distributed results are generated from pseudorandom generators
+ * with a Box-Muller transform, and so require \p n to be even.
+ * Quasirandom generators use an inverse cumulative distribution
+ * function to preserve dimensionality.
+ * The normally distributed results are transformed into log-normal distribution.
+ *
+ * There may be slight numerical differences between results generated
+ * on the GPU with generators created with ::curandCreateGenerator()
+ * and results calculated on the CPU with generators created with
+ * ::curandCreateGeneratorHost().  These differences arise because of
+ * differences in results for transcendental functions.  In addition,
+ * future versions of CURAND may use newer versions of the CUDA math
+ * library, so different versions of CURAND may give slightly different
+ * numerical values.
+ *
+ * \param generator - Generator to use
+ * \param outputPtr - Pointer to device memory to store CUDA-generated results, or
+ *                 Pointer to host memory to store CPU-generated results
+ * \param n - Number of floats to generate
+ * \param mean - Mean of associated normal distribution
+ * \param stddev - Standard deviation of associated normal distribution
+ *
+ * \return
+ * - CURAND_STATUS_ALLOCATION_FAILED if memory could not be allocated \n
+ * - CURAND_STATUS_NOT_INITIALIZED if the generator was never created \n
+ * - CURAND_STATUS_PREEXISTING_FAILURE if there was an existing error from
+ *    a previous kernel launch \n
+ * - CURAND_STATUS_LAUNCH_FAILURE if the kernel launch failed for any reason \n
+ * - CURAND_STATUS_LENGTH_NOT_MULTIPLE if the number of output samples is
+ *    not a multiple of the quasirandom dimension, or is not a multiple
+ *    of two for pseudorandom generators \n
+ * - CURAND_STATUS_SUCCESS if the results were generated successfully \n
+ */
+curandStatus_t CURANDAPI
+curandGenerateLogNormal(curandGenerator_t generator, float *outputPtr,
+                     size_t n, float mean, float stddev);
+
+/**
+ * \brief Generate log-normally distributed doubles.
+ *
+ * Use \p generator to generate \p n double results into the device memory at
+ * \p outputPtr.  The device memory must have been previously allocated and be
+ * large enough to hold all the results.  Launches are done with the stream
+ * set using ::curandSetStream(), or the null stream if no stream has been set.
+ *
+ * Results are 64-bit floating point values with log-normal distribution based on
+ * an associated normal distribution with mean \p mean and standard deviation \p stddev.
+ *
+ * Normally distributed results are generated from pseudorandom generators
+ * with a Box-Muller transform, and so require \p n to be even.
+ * Quasirandom generators use an inverse cumulative distribution
+ * function to preserve dimensionality.
+ * The normally distributed results are transformed into log-normal distribution.
+ *
+ * There may be slight numerical differences between results generated
+ * on the GPU with generators created with ::curandCreateGenerator()
+ * and results calculated on the CPU with generators created with
+ * ::curandCreateGeneratorHost().  These differences arise because of
+ * differences in results for transcendental functions.  In addition,
+ * future versions of CURAND may use newer versions of the CUDA math
+ * library, so different versions of CURAND may give slightly different
+ * numerical values.
+ *
+ * \param generator - Generator to use
+ * \param outputPtr - Pointer to device memory to store CUDA-generated results, or
+ *                 Pointer to host memory to store CPU-generated results
+ * \param n - Number of doubles to generate
+ * \param mean - Mean of normal distribution
+ * \param stddev - Standard deviation of normal distribution
+ *
+ * \return
+ * - CURAND_STATUS_ALLOCATION_FAILED if memory could not be allocated \n
+ * - CURAND_STATUS_NOT_INITIALIZED if the generator was never created \n
+ * - CURAND_STATUS_PREEXISTING_FAILURE if there was an existing error from
+ *    a previous kernel launch \n
+ * - CURAND_STATUS_LAUNCH_FAILURE if the kernel launch failed for any reason \n
+ * - CURAND_STATUS_LENGTH_NOT_MULTIPLE if the number of output samples is
+ *    not a multiple of the quasirandom dimension, or is not a multiple
+ *    of two for pseudorandom generators \n
+ * - CURAND_STATUS_DOUBLE_PRECISION_REQUIRED if the GPU does not support double precision \n
+ * - CURAND_STATUS_SUCCESS if the results were generated successfully \n
+ */
+curandStatus_t CURANDAPI
+curandGenerateLogNormalDouble(curandGenerator_t generator, double *outputPtr,
+                     size_t n, double mean, double stddev);
+
+/**
+ * \brief Construct the histogram array for a Poisson distribution.
+ *
+ * Construct the histogram array for the Poisson distribution with lambda \p lambda.
+ * For lambda greater than 2000, an approximation with a normal distribution is used.
+ *
+ * \param lambda - lambda for the Poisson distribution
+ *
+ *
+ * \param discrete_distribution - pointer to the histogram in device memory
+ *
+ * \return
+ * - CURAND_STATUS_ALLOCATION_FAILED if memory could not be allocated \n
+ * - CURAND_STATUS_DOUBLE_PRECISION_REQUIRED if the GPU does not support double precision \n
+ * - CURAND_STATUS_INITIALIZATION_FAILED if there was a problem setting up the GPU \n
+ * - CURAND_STATUS_NOT_INITIALIZED if the distribution pointer was null \n
+ * - CURAND_STATUS_PREEXISTING_FAILURE if there was an existing error from
+ *    a previous kernel launch \n
+ * - CURAND_STATUS_OUT_OF_RANGE if lambda is non-positive or greater than 400,000 \n
+ * - CURAND_STATUS_SUCCESS if the histogram was generated successfully \n
+ */
+
+curandStatus_t CURANDAPI
+curandCreatePoissonDistribution(double lambda, curandDiscreteDistribution_t *discrete_distribution);
+
+
+
+/**
+ * \brief Destroy the histogram array for a discrete distribution (e.g. Poisson).
+ *
+ * Destroy the histogram array for a discrete distribution created by curandCreatePoissonDistribution.
+ *
+ * \param discrete_distribution - pointer to device memory where the histogram is stored
+ *
+ * \return
+ * - CURAND_STATUS_NOT_INITIALIZED if the histogram was never created \n
+ * - CURAND_STATUS_SUCCESS if the histogram was destroyed successfully \n
+ */
+curandStatus_t CURANDAPI
+curandDestroyDistribution(curandDiscreteDistribution_t discrete_distribution);
+
+
+/**
+ * \brief Generate Poisson-distributed unsigned ints.
+ *
+ * Use \p generator to generate \p n unsigned int results into device memory at
+ * \p outputPtr.  The device memory must have been previously allocated and must be
+ * large enough to hold all the results.  Launches are done with the stream
+ * set using ::curandSetStream(), or the null stream if no stream has been set.
+ *
+ * Results are 32-bit unsigned int point values with Poisson distribution, with lambda \p lambda.
+ *
+ * \param generator - Generator to use
+ * \param outputPtr - Pointer to device memory to store CUDA-generated results, or
+ *                 Pointer to host memory to store CPU-generated results
+ * \param n - Number of unsigned ints to generate
+ * \param lambda - lambda for the Poisson distribution
+ *
+ * \return
+ * - CURAND_STATUS_ALLOCATION_FAILED if memory could not be allocated \n
+ * - CURAND_STATUS_NOT_INITIALIZED if the generator was never created \n
+ * - CURAND_STATUS_PREEXISTING_FAILURE if there was an existing error from
+ *    a previous kernel launch \n
+ * - CURAND_STATUS_LAUNCH_FAILURE if the kernel launch failed for any reason \n
+ * - CURAND_STATUS_LENGTH_NOT_MULTIPLE if the number of output samples is
+ *    not a multiple of the quasirandom dimension\n
+ * - CURAND_STATUS_DOUBLE_PRECISION_REQUIRED if the GPU or sm does not support double precision \n
+ * - CURAND_STATUS_OUT_OF_RANGE if lambda is non-positive or greater than 400,000 \n
+ * - CURAND_STATUS_SUCCESS if the results were generated successfully \n
+ */
+
+curandStatus_t CURANDAPI
+curandGeneratePoisson(curandGenerator_t generator, unsigned int *outputPtr,
+                     size_t n, double lambda);
+// just for internal usage
+curandStatus_t CURANDAPI
+curandGeneratePoissonMethod(curandGenerator_t generator, unsigned int *outputPtr,
+                     size_t n, double lambda, curandMethod_t method);
+
+
+curandStatus_t CURANDAPI
+curandGenerateBinomial(curandGenerator_t generator, unsigned int *outputPtr,
+                       size_t num, unsigned int n, double p);
+// just for internal usage
+curandStatus_t CURANDAPI
+curandGenerateBinomialMethod(curandGenerator_t generator,
+                             unsigned int *outputPtr,
+                             size_t num, unsigned int n, double p,
+                             curandMethod_t method);
+
+
+/**
+ * \brief Setup starting states.
+ *
+ * Generate the starting state of the generator.  This function is
+ * automatically called by generation functions such as
+ * ::curandGenerate() and ::curandGenerateUniform().
+ * It can be called manually for performance testing reasons to separate
+ * timings for starting state generation and random number generation.
+ *
+ * \param generator - Generator to update
+ *
+ * \return
+ * - CURAND_STATUS_ALLOCATION_FAILED if memory could not be allocated \n
+ * - CURAND_STATUS_NOT_INITIALIZED if the generator was never created \n
+ * - CURAND_STATUS_PREEXISTING_FAILURE if there was an existing error from
+ *     a previous kernel launch \n
+ * - CURAND_STATUS_LAUNCH_FAILURE if the kernel launch failed for any reason \n
+ * - CURAND_STATUS_SUCCESS if the seeds were generated successfully \n
+ */
+curandStatus_t CURANDAPI
+curandGenerateSeeds(curandGenerator_t generator);
+
+/**
+ * \brief Get direction vectors for 32-bit quasirandom number generation.
+ *
+ * Get a pointer to an array of direction vectors that can be used
+ * for quasirandom number generation.  The resulting pointer will
+ * reference an array of direction vectors in host memory.
+ *
+ * The array contains vectors for many dimensions.  Each dimension
+ * has 32 vectors.  Each individual vector is an unsigned int.
+ *
+ * Legal values for \p set are:
+ * - CURAND_DIRECTION_VECTORS_32_JOEKUO6 (20,000 dimensions)
+ * - CURAND_SCRAMBLED_DIRECTION_VECTORS_32_JOEKUO6 (20,000 dimensions)
+ *
+ * \param vectors - Address of pointer in which to return direction vectors
+ * \param set - Which set of direction vectors to use
+ *
+ * \return
+ * - CURAND_STATUS_OUT_OF_RANGE if the choice of set is invalid \n
+ * - CURAND_STATUS_SUCCESS if the pointer was set successfully \n
+ */
+curandStatus_t CURANDAPI
+curandGetDirectionVectors32(curandDirectionVectors32_t *vectors[], curandDirectionVectorSet_t set);
+
+/**
+ * \brief Get scramble constants for 32-bit scrambled Sobol' .
+ *
+ * Get a pointer to an array of scramble constants that can be used
+ * for quasirandom number generation.  The resulting pointer will
+ * reference an array of unsinged ints in host memory.
+ *
+ * The array contains constants for many dimensions.  Each dimension
+ * has a single unsigned int constant.
+ *
+ * \param constants - Address of pointer in which to return scramble constants
+ *
+ * \return
+ * - CURAND_STATUS_SUCCESS if the pointer was set successfully \n
+ */
+curandStatus_t CURANDAPI
+curandGetScrambleConstants32(unsigned int * * constants);
+
+/**
+ * \brief Get direction vectors for 64-bit quasirandom number generation.
+ *
+ * Get a pointer to an array of direction vectors that can be used
+ * for quasirandom number generation.  The resulting pointer will
+ * reference an array of direction vectors in host memory.
+ *
+ * The array contains vectors for many dimensions.  Each dimension
+ * has 64 vectors.  Each individual vector is an unsigned long long.
+ *
+ * Legal values for \p set are:
+ * - CURAND_DIRECTION_VECTORS_64_JOEKUO6 (20,000 dimensions)
+ * - CURAND_SCRAMBLED_DIRECTION_VECTORS_64_JOEKUO6 (20,000 dimensions)
+ *
+ * \param vectors - Address of pointer in which to return direction vectors
+ * \param set - Which set of direction vectors to use
+ *
+ * \return
+ * - CURAND_STATUS_OUT_OF_RANGE if the choice of set is invalid \n
+ * - CURAND_STATUS_SUCCESS if the pointer was set successfully \n
+ */
+curandStatus_t CURANDAPI
+curandGetDirectionVectors64(curandDirectionVectors64_t *vectors[], curandDirectionVectorSet_t set);
+
+/**
+ * \brief Get scramble constants for 64-bit scrambled Sobol' .
+ *
+ * Get a pointer to an array of scramble constants that can be used
+ * for quasirandom number generation.  The resulting pointer will
+ * reference an array of unsinged long longs in host memory.
+ *
+ * The array contains constants for many dimensions.  Each dimension
+ * has a single unsigned long long constant.
+ *
+ * \param constants - Address of pointer in which to return scramble constants
+ *
+ * \return
+ * - CURAND_STATUS_SUCCESS if the pointer was set successfully \n
+ */
+curandStatus_t CURANDAPI
+curandGetScrambleConstants64(unsigned long long * * constants);
+
+/** @} */
+
+#endif // __CUDACC_RTC__
+
+#if defined(__cplusplus)
+}
+#endif /* __cplusplus */
+
+
+#endif /* !defined(CURAND_H_) */

evalkit_tf449/lib/python3.10/site-packages/nvidia/curand/include/curand_discrete.h

@@ -0,0 +1,87 @@
+ /* 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(CURANDDISCRETE_H_)
+#define CURANDDISCRETE_H_
+
+struct curandDistributionShift_st {
+    curandDistribution_t probability;
+    curandDistribution_t host_probability;
+    unsigned int shift;
+    unsigned int length;
+    unsigned int host_gen;
+};
+
+struct curandHistogramM2_st {
+    curandHistogramM2V_t V; 
+    curandHistogramM2V_t host_V; 
+    curandHistogramM2K_t K; 
+    curandHistogramM2K_t host_K; 
+    unsigned int host_gen;
+};
+
+
+struct curandDistributionM2Shift_st {
+    curandHistogramM2_t histogram;
+    curandHistogramM2_t host_histogram;
+    unsigned int shift;
+    unsigned int length;
+    unsigned int host_gen;
+};
+
+struct curandDiscreteDistribution_st {
+    curandDiscreteDistribution_t self_host_ptr;
+    curandDistributionM2Shift_t M2;
+    curandDistributionM2Shift_t host_M2;
+    double stddev;
+    double mean;
+    curandMethod_t method;
+    unsigned int host_gen; 
+};
+
+#endif // !defined(CURANDDISCRETE_H_)

evalkit_tf449/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_)

evalkit_tf449/lib/python3.10/site-packages/nvidia/curand/include/curand_globals.h

@@ -0,0 +1,93 @@
+ /* 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.
+  */
+#ifndef CURAND_GLOBALS_H
+#define CURAND_GLOBALS_H
+
+#define MAX_XOR_N (5)
+#define SKIPAHEAD_BLOCKSIZE (4)
+#define SKIPAHEAD_MASK ((1<<SKIPAHEAD_BLOCKSIZE)-1)
+#define CURAND_2POW32 (4294967296.f)
+#define CURAND_2POW32_DOUBLE (4294967296.)
+#define CURAND_2POW32_INV (2.3283064e-10f)
+#define CURAND_2POW32_INV_DOUBLE (2.3283064365386963e-10) 
+#define CURAND_2POW53_INV_DOUBLE (1.1102230246251565e-16)
+#define CURAND_2POW32_INV_2PI (2.3283064e-10f * 6.2831855f)
+#define CURAND_2PI (6.2831855f)
+#define CURAND_2POW53_INV_2PI_DOUBLE (1.1102230246251565e-16 * 6.2831853071795860)
+#define CURAND_PI_DOUBLE  (3.1415926535897932)
+#define CURAND_2PI_DOUBLE (6.2831853071795860)
+#define CURAND_SQRT2 (-1.4142135f)
+#define CURAND_SQRT2_DOUBLE (-1.4142135623730951)
+
+#define SOBOL64_ITR_BINARY_DIVIDE 2
+#define SOBOL_M2_BINARY_DIVIDE 10
+#define MTGP32_M2_BINARY_DIVIDE 32
+#define MAX_LAMBDA 400000
+#define MIN_GAUSS_LAMBDA 2000
+
+struct normal_args_st {
+    float mean;
+    float stddev;
+};
+
+typedef struct normal_args_st normal_args_t;
+
+struct normal_args_double_st {
+    double mean;
+    double stddev;
+};
+
+typedef struct normal_args_double_st normal_args_double_t;
+
+
+
+
+
+
+
+#endif

evalkit_tf449/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_)

evalkit_tf449/lib/python3.10/site-packages/nvidia/curand/include/curand_lognormal.h

@@ -0,0 +1,697 @@
+
+ /* 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_LOGNORMAL_H_)
+#define CURAND_LOGNORMAL_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"
+
+/**
+ * \brief Return a log-normally distributed float from an XORWOW generator.
+ *
+ * Return a single log-normally distributed float derived from a normal
+ * distribution with mean \p mean and standard deviation \p stddev
+ * 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, transforms them to log-normal distribution,
+ * then returns them one at a time.
+ * See ::curand_log_normal2() for a more efficient version that returns
+ * both results at once.
+ *
+ * \param state  - Pointer to state to update
+ * \param mean   - Mean of the related normal distribution
+ * \param stddev - Standard deviation of the related normal distribution
+ *
+ * \return Log-normally distributed float with mean \p mean and standard deviation \p stddev
+ */
+QUALIFIERS float curand_log_normal(curandStateXORWOW_t *state, float mean, float stddev)
+{
+    if(state->boxmuller_flag != EXTRA_FLAG_LOG_NORMAL) {
+        unsigned int x, y;
+        x = curand(state);
+        y = curand(state);
+        float2 v = _curand_box_muller(x, y);
+        state->boxmuller_extra = expf(mean + (stddev * v.y));
+        state->boxmuller_flag = EXTRA_FLAG_LOG_NORMAL;
+        return expf(mean + (stddev * v.x));
+    }
+    state->boxmuller_flag = 0;
+    return state->boxmuller_extra;
+}
+
+/**
+ * \brief Return a log-normally distributed float from an Philox4_32_10 generator.
+ *
+ * Return a single log-normally distributed float derived from a normal
+ * distribution with mean \p mean and standard deviation \p stddev
+ * 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, transforms them to log-normal distribution,
+ * then returns them one at a time.
+ * See ::curand_log_normal2() for a more efficient version that returns
+ * both results at once.
+ *
+ * \param state  - Pointer to state to update
+ * \param mean   - Mean of the related normal distribution
+ * \param stddev - Standard deviation of the related normal distribution
+ *
+ * \return Log-normally distributed float with mean \p mean and standard deviation \p stddev
+ */
+
+QUALIFIERS float curand_log_normal(curandStatePhilox4_32_10_t *state, float mean, float stddev)
+{
+    if(state->boxmuller_flag != EXTRA_FLAG_LOG_NORMAL) {
+        unsigned int x, y;
+        x = curand(state);
+        y = curand(state);
+        float2 v = _curand_box_muller(x, y);
+        state->boxmuller_extra = expf(mean + (stddev * v.y));
+        state->boxmuller_flag = EXTRA_FLAG_LOG_NORMAL;
+        return expf(mean + (stddev * v.x));
+    }
+    state->boxmuller_flag = 0;
+    return state->boxmuller_extra;
+}
+
+/**
+ * \brief Return two normally distributed floats from an XORWOW generator.
+ *
+ * Return two log-normally distributed floats derived from a normal
+ * distribution with mean \p mean and standard deviation \p stddev
+ * 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, then transforms them to log-normal.
+ *
+ * \param state - Pointer to state to update
+ * \param mean   - Mean of the related normal distribution
+ * \param stddev - Standard deviation of the related normal distribution
+ *
+ * \return Log-normally distributed float2 where each element is from a
+ * distribution with mean \p mean and standard deviation \p stddev
+ */
+QUALIFIERS float2 curand_log_normal2(curandStateXORWOW_t *state, float mean, float stddev)
+{
+    float2 v = curand_box_muller(state);
+    v.x = expf(mean + (stddev * v.x));
+    v.y = expf(mean + (stddev * v.y));
+    return v;
+}
+
+/**
+ * \brief Return two normally distributed floats from an Philox4_32_10 generator.
+ *
+ * Return two log-normally distributed floats derived from a normal
+ * distribution with mean \p mean and standard deviation \p stddev
+ * 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, then transforms them to log-normal.
+ *
+ * \param state - Pointer to state to update
+ * \param mean   - Mean of the related normal distribution
+ * \param stddev - Standard deviation of the related normal distribution
+ *
+ * \return Log-normally distributed float2 where each element is from a
+ * distribution with mean \p mean and standard deviation \p stddev
+ */
+QUALIFIERS float2 curand_log_normal2(curandStatePhilox4_32_10_t *state, float mean, float stddev)
+{
+    float2 v = curand_box_muller(state);
+    v.x = expf(mean + (stddev * v.x));
+    v.y = expf(mean + (stddev * v.y));
+    return v;
+}
+/**
+ * \brief Return four normally distributed floats from an Philox4_32_10 generator.
+ *
+ * Return four log-normally distributed floats derived from a normal
+ * distribution with mean \p mean and standard deviation \p stddev
+ * 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, then transforms them to log-normal.
+ *
+ * \param state - Pointer to state to update
+ * \param mean   - Mean of the related normal distribution
+ * \param stddev - Standard deviation of the related normal distribution
+ *
+ * \return Log-normally distributed float4 where each element is from a
+ * distribution with mean \p mean and standard deviation \p stddev
+ */
+QUALIFIERS float4 curand_log_normal4(curandStatePhilox4_32_10_t *state, float mean, float stddev)
+{
+    float4 v = curand_box_muller4(state);
+    v.x = expf(mean + (stddev * v.x));
+    v.y = expf(mean + (stddev * v.y));
+    v.z = expf(mean + (stddev * v.z));
+    v.w = expf(mean + (stddev * v.w));
+    return v;
+}
+
+/**
+ * \brief Return a log-normally distributed float from an MRG32k3a generator.
+ *
+ * Return a single log-normally distributed float derived from a normal
+ * distribution with mean \p mean and standard deviation \p stddev
+ * 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, transforms them to log-normal distribution,
+ * then returns them one at a time.
+ * See ::curand_log_normal2() for a more efficient version that returns
+ * both results at once.
+ *
+ * \param state  - Pointer to state to update
+ * \param mean   - Mean of the related normal distribution
+ * \param stddev - Standard deviation of the related normal distribution
+ *
+ * \return Log-normally distributed float with mean \p mean and standard deviation \p stddev
+ */
+QUALIFIERS float curand_log_normal(curandStateMRG32k3a_t *state, float mean, float stddev)
+{
+    if(state->boxmuller_flag != EXTRA_FLAG_LOG_NORMAL) {
+        float2 v = curand_box_muller_mrg(state);
+        state->boxmuller_extra = expf(mean + (stddev * v.y));
+        state->boxmuller_flag = EXTRA_FLAG_LOG_NORMAL;
+        return expf(mean + (stddev * v.x));
+    }
+    state->boxmuller_flag = 0;
+    return state->boxmuller_extra;
+}
+
+/**
+ * \brief Return two normally distributed floats from an MRG32k3a generator.
+ *
+ * Return two log-normally distributed floats derived from a normal
+ * distribution with mean \p mean and standard deviation \p stddev
+ * 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, then transforms them to log-normal.
+ *
+ * \param state - Pointer to state to update
+ * \param mean   - Mean of the related normal distribution
+ * \param stddev - Standard deviation of the related normal distribution
+ *
+ * \return Log-normally distributed float2 where each element is from a
+ * distribution with mean \p mean and standard deviation \p stddev
+ */
+QUALIFIERS float2 curand_log_normal2(curandStateMRG32k3a_t *state, float mean, float stddev)
+{
+    float2 v = curand_box_muller_mrg(state);
+    v.x = expf(mean + (stddev * v.x));
+    v.y = expf(mean + (stddev * v.y));
+    return v;
+}
+
+/**
+ * \brief Return a log-normally distributed float from an MTGP32 generator.
+ *
+ * Return a single log-normally distributed float derived from a normal
+ * distribution with mean \p mean and standard deviation \p stddev
+ * from the MTGP32 generator in \p state,
+ * increment position of generator.
+ *
+ * The implementation uses the inverse cumulative distribution function
+ * to generate a normally distributed result, then transforms the result
+ * to log-normal.
+ *
+ * \param state - Pointer to state to update
+ * \param mean   - Mean of the related normal distribution
+ * \param stddev - Standard deviation of the related normal distribution
+ *
+ * \return Log-normally distributed float with mean \p mean and standard deviation \p stddev
+ */
+QUALIFIERS float curand_log_normal(curandStateMtgp32_t *state, float mean, float stddev)
+{
+    return expf(mean + (stddev * _curand_normal_icdf(curand(state))));
+}
+
+/**
+ * \brief Return a log-normally distributed float from a Sobol32 generator.
+ *
+ * Return a single log-normally distributed float derived from a normal
+ * distribution with mean \p mean and standard deviation \p stddev
+ * from the Sobol32 generator in \p state,
+ * increment position of generator by one.
+ *
+ * The implementation uses the inverse cumulative distribution function
+ * to generate a normally distributed result, then transforms the result
+ * to log-normal.
+ *
+ * \param state - Pointer to state to update
+ * \param mean   - Mean of the related normal distribution
+ * \param stddev - Standard deviation of the related normal distribution
+ *
+ * \return Log-normally distributed float with mean \p mean and standard deviation \p stddev
+ */
+QUALIFIERS float curand_log_normal(curandStateSobol32_t *state, float mean, float stddev)
+{
+    return expf(mean + (stddev * _curand_normal_icdf(curand(state))));
+}
+/**
+ * \brief Return a log-normally distributed float from a scrambled Sobol32 generator.
+ *
+ * Return a single log-normally distributed float derived from a normal
+ * distribution with mean \p mean and standard deviation \p stddev
+ * from the scrambled Sobol32 generator in \p state,
+ * increment position of generator by one.
+ *
+ * The implementation uses the inverse cumulative distribution function
+ * to generate a normally distributed result, then transforms the result
+ * to log-normal.
+ *
+ * \param state - Pointer to state to update
+ * \param mean   - Mean of the related normal distribution
+ * \param stddev - Standard deviation of the related normal distribution
+ *
+ * \return Log-normally distributed float with mean \p mean and standard deviation \p stddev
+ */
+QUALIFIERS float curand_log_normal(curandStateScrambledSobol32_t *state, float mean, float stddev)
+{
+    return expf(mean + (stddev * _curand_normal_icdf(curand(state))));
+}
+
+/**
+ * \brief Return a log-normally distributed float from a Sobol64 generator.
+ *
+ * Return a single log-normally distributed float derived from a normal
+ * distribution with mean \p mean and standard deviation \p stddev
+ * 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, then converts to log-normal
+ * distribution.
+ *
+ * \param state - Pointer to state to update
+ * \param mean   - Mean of the related normal distribution
+ * \param stddev - Standard deviation of the related normal distribution
+ *
+ * \return Log-normally distributed float with mean \p mean and standard deviation \p stddev
+ */
+QUALIFIERS float curand_log_normal(curandStateSobol64_t *state, float mean, float stddev)
+{
+    return expf(mean + (stddev * _curand_normal_icdf(curand(state))));
+}
+
+/**
+ * \brief Return a log-normally distributed float from a scrambled Sobol64 generator.
+ *
+ * Return a single log-normally distributed float derived from a normal
+ * distribution with mean \p mean and standard deviation \p stddev
+ * 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, then converts to log-normal
+ * distribution.
+ *
+ * \param state - Pointer to state to update
+ * \param mean   - Mean of the related normal distribution
+ * \param stddev - Standard deviation of the related normal distribution
+ *
+ * \return Log-normally distributed float with mean \p mean and standard deviation \p stddev
+ */
+QUALIFIERS float curand_log_normal(curandStateScrambledSobol64_t *state, float mean, float stddev)
+{
+    return expf(mean + (stddev * _curand_normal_icdf(curand(state))));
+}
+
+/**
+ * \brief Return a log-normally distributed double from an XORWOW generator.
+ *
+ * Return a single normally distributed double derived from a normal
+ * distribution with mean \p mean and standard deviation \p stddev
+ * from the XORWOW generator in \p state,
+ * increment position of generator.
+ *
+ * The implementation uses a Box-Muller transform to generate two
+ * normally distributed results, transforms them to log-normal distribution,
+ * then returns them one at a time.
+ * See ::curand_log_normal2_double() for a more efficient version that returns
+ * both results at once.
+ *
+ * \param state - Pointer to state to update
+ * \param mean   - Mean of the related normal distribution
+ * \param stddev - Standard deviation of the related normal distribution
+ *
+ * \return Log-normally distributed double with mean \p mean and standard deviation \p stddev
+ */
+
+QUALIFIERS double curand_log_normal_double(curandStateXORWOW_t *state, double mean, double stddev)
+{
+    if(state->boxmuller_flag_double != EXTRA_FLAG_LOG_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 = exp(mean + (stddev * v.y));
+        state->boxmuller_flag_double = EXTRA_FLAG_LOG_NORMAL;
+        return exp(mean + (stddev * v.x));
+    }
+    state->boxmuller_flag_double = 0;
+    return state->boxmuller_extra_double;
+}
+
+/**
+ * \brief Return a log-normally distributed double from an Philox4_32_10 generator.
+ *
+ * Return a single normally distributed double derived from a normal
+ * distribution with mean \p mean and standard deviation \p stddev
+ * 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, transforms them to log-normal distribution,
+ * then returns them one at a time.
+ * See ::curand_log_normal2_double() for a more efficient version that returns
+ * both results at once.
+ *
+ * \param state - Pointer to state to update
+ * \param mean   - Mean of the related normal distribution
+ * \param stddev - Standard deviation of the related normal distribution
+ *
+ * \return Log-normally distributed double with mean \p mean and standard deviation \p stddev
+ */
+
+QUALIFIERS double curand_log_normal_double(curandStatePhilox4_32_10_t *state, double mean, double stddev)
+{
+    if(state->boxmuller_flag_double != EXTRA_FLAG_LOG_NORMAL) {
+        uint4 _x;
+        _x = curand4(state);
+        double2 v = _curand_box_muller_double(_x.x, _x.y, _x.z, _x.w);
+        state->boxmuller_extra_double = exp(mean + (stddev * v.y));
+        state->boxmuller_flag_double = EXTRA_FLAG_LOG_NORMAL;
+        return exp(mean + (stddev * v.x));
+    }
+    state->boxmuller_flag_double = 0;
+    return state->boxmuller_extra_double;
+}
+
+
+/**
+ * \brief Return two log-normally distributed doubles from an XORWOW generator.
+ *
+ * Return two log-normally distributed doubles derived from a normal
+ * distribution with mean \p mean and standard deviation \p stddev
+ * 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, and transforms them to log-normal distribution,.
+ *
+ * \param state - Pointer to state to update
+ * \param mean   - Mean of the related normal distribution
+ * \param stddev - Standard deviation of the related normal distribution
+ *
+ * \return Log-normally distributed double2 where each element is from a
+ * distribution with mean \p mean and standard deviation \p stddev
+ */
+QUALIFIERS double2 curand_log_normal2_double(curandStateXORWOW_t *state, double mean, double stddev)
+{
+    double2 v = curand_box_muller_double(state);
+    v.x = exp(mean + (stddev * v.x));
+    v.y = exp(mean + (stddev * v.y));
+    return v;
+}
+
+/**
+ * \brief Return two log-normally distributed doubles from an Philox4_32_10 generator.
+ *
+ * Return two log-normally distributed doubles derived from a normal
+ * distribution with mean \p mean and standard deviation \p stddev
+ * 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, and transforms them to log-normal distribution,.
+ *
+ * \param state - Pointer to state to update
+ * \param mean   - Mean of the related normal distribution
+ * \param stddev - Standard deviation of the related normal distribution
+ *
+ * \return Log-normally distributed double4 where each element is from a
+ * distribution with mean \p mean and standard deviation \p stddev
+ */
+QUALIFIERS double2 curand_log_normal2_double(curandStatePhilox4_32_10_t *state, double mean, double stddev)
+{
+    double2 v = curand_box_muller2_double(state);
+    v.x = exp(mean + (stddev * v.x));
+    v.y = exp(mean + (stddev * v.y));
+    return v;
+}
+// nor part of API
+QUALIFIERS double4 curand_log_normal4_double(curandStatePhilox4_32_10_t *state, double mean, double stddev)
+{
+    double4 v = curand_box_muller4_double(state);
+    v.x = exp(mean + (stddev * v.x));
+    v.y = exp(mean + (stddev * v.y));
+    v.z = exp(mean + (stddev * v.z));
+    v.w = exp(mean + (stddev * v.w));
+    return v;
+}
+
+/**
+ * \brief Return a log-normally distributed double from an MRG32k3a generator.
+ *
+ * Return a single normally distributed double derived from a normal
+ * distribution with mean \p mean and standard deviation \p stddev
+ * from the MRG32k3a generator in \p state,
+ * increment position of generator.
+ *
+ * The implementation uses a Box-Muller transform to generate two
+ * normally distributed results, transforms them to log-normal distribution,
+ * then returns them one at a time.
+ * See ::curand_log_normal2_double() for a more efficient version that returns
+ * both results at once.
+ *
+ * \param state - Pointer to state to update
+ * \param mean   - Mean of the related normal distribution
+ * \param stddev - Standard deviation of the related normal distribution
+ *
+ * \return Log-normally distributed double with mean \p mean and standard deviation \p stddev
+ */
+QUALIFIERS double curand_log_normal_double(curandStateMRG32k3a_t *state, double mean, double stddev)
+{
+    if(state->boxmuller_flag_double != EXTRA_FLAG_LOG_NORMAL) {
+        double2 v = curand_box_muller_mrg_double(state);
+        state->boxmuller_extra_double = exp(mean + (stddev * v.y));
+        state->boxmuller_flag_double = EXTRA_FLAG_LOG_NORMAL;
+        return exp(mean + (stddev * v.x));
+    }
+    state->boxmuller_flag_double = 0;
+    return state->boxmuller_extra_double;
+}
+
+/**
+ * \brief Return two log-normally distributed doubles from an MRG32k3a generator.
+ *
+ * Return two log-normally distributed doubles derived from a normal
+ * distribution with mean \p mean and standard deviation \p stddev
+ * 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, and transforms them to log-normal distribution,.
+ *
+ * \param state - Pointer to state to update
+ * \param mean   - Mean of the related normal distribution
+ * \param stddev - Standard deviation of the related normal distribution
+ *
+ * \return Log-normally distributed double2 where each element is from a
+ * distribution with mean \p mean and standard deviation \p stddev
+ */
+QUALIFIERS double2 curand_log_normal2_double(curandStateMRG32k3a_t *state, double mean, double stddev)
+{
+    double2 v = curand_box_muller_mrg_double(state);
+    v.x = exp(mean + (stddev * v.x));
+    v.y = exp(mean + (stddev * v.y));
+    return v;
+}
+
+/**
+ * \brief Return a log-normally distributed double from an MTGP32 generator.
+ *
+ * Return a single log-normally distributed double derived from a normal
+ * distribution with mean \p mean and standard deviation \p stddev
+ * from the MTGP32 generator in \p state,
+ * increment position of generator.
+ *
+ * The implementation uses the inverse cumulative distribution function
+ * to generate normally distributed results, and transforms them into
+ * log-normal distribution.
+ *
+ * \param state - Pointer to state to update
+ * \param mean   - Mean of the related normal distribution
+ * \param stddev - Standard deviation of the related normal distribution
+ *
+ * \return Log-normally distributed double with mean \p mean and standard deviation \p stddev
+ */
+QUALIFIERS double curand_log_normal_double(curandStateMtgp32_t *state, double mean, double stddev)
+{
+    return exp(mean + (stddev * _curand_normal_icdf_double(curand(state))));
+}
+
+/**
+ * \brief Return a log-normally distributed double from a Sobol32 generator.
+ *
+ * Return a single log-normally distributed double derived from a normal
+ * distribution with mean \p mean and standard deviation \p stddev
+ * 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, and transforms them into
+ * log-normal distribution.
+ *
+ * \param state - Pointer to state to update
+ * \param mean   - Mean of the related normal distribution
+ * \param stddev - Standard deviation of the related normal distribution
+ *
+ * \return Log-normally distributed double with mean \p mean and standard deviation \p stddev
+ */
+QUALIFIERS double curand_log_normal_double(curandStateSobol32_t *state, double mean, double stddev)
+{
+    return exp(mean + (stddev * _curand_normal_icdf_double(curand(state))));
+}
+
+/**
+ * \brief Return a log-normally distributed double from a scrambled Sobol32 generator.
+ *
+ * Return a single log-normally distributed double derived from a normal
+ * distribution with mean \p mean and standard deviation \p stddev
+ * 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, and transforms them into
+ * log-normal distribution.
+ *
+ * \param state - Pointer to state to update
+ * \param mean   - Mean of the related normal distribution
+ * \param stddev - Standard deviation of the related normal distribution
+ *
+ * \return Log-normally distributed double with mean \p mean and standard deviation \p stddev
+ */
+QUALIFIERS double curand_log_normal_double(curandStateScrambledSobol32_t *state, double mean, double stddev)
+{
+    return exp(mean + (stddev * _curand_normal_icdf_double(curand(state))));
+}
+
+/**
+ * \brief Return a log-normally distributed double from a Sobol64 generator.
+ *
+ * Return a single normally distributed double derived from a normal
+ * distribution with mean \p mean and standard deviation \p stddev
+ * 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
+ * \param mean   - Mean of the related normal distribution
+ * \param stddev - Standard deviation of the related normal distribution
+ *
+ * \return Log-normally distributed double with mean \p mean and standard deviation \p stddev
+ */
+QUALIFIERS double curand_log_normal_double(curandStateSobol64_t *state, double mean, double stddev)
+{
+    return exp(mean + (stddev * _curand_normal_icdf_double(curand(state))));
+}
+
+/**
+ * \brief Return a log-normally distributed double from a scrambled Sobol64 generator.
+ *
+ * Return a single normally distributed double derived from a normal
+ * distribution with mean \p mean and standard deviation \p stddev
+ * 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
+ * \param mean   - Mean of the related normal distribution
+ * \param stddev - Standard deviation of the related normal distribution
+ *
+ * \return Log-normally distributed double with mean \p mean and standard deviation \p stddev
+ */
+QUALIFIERS double curand_log_normal_double(curandStateScrambledSobol64_t *state, double mean, double stddev)
+{
+    return exp(mean + (stddev * _curand_normal_icdf_double(curand(state))));
+}
+
+#endif // !defined(CURAND_LOGNORMAL_H_)

evalkit_tf449/lib/python3.10/site-packages/nvidia/curand/include/curand_mtgp32.h

@@ -0,0 +1,210 @@
+/*
+ * 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.
+ */
+
+#ifndef CURAND_MTGP32_H
+#define CURAND_MTGP32_H
+/*
+ * @file curand_mtgp32.h
+ *
+ * @brief Mersenne Twister for Graphic Processors (mtgp32), which
+ * generates 32-bit unsigned integers and single precision floating
+ * point numbers based on IEEE 754 format.
+ *
+ * @author Mutsuo Saito (Hiroshima University)
+ * @author Makoto Matsumoto (Hiroshima University)
+ *
+ */
+/*
+ * 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.
+ */
+
+
+#define MTGPDC_MEXP 11213
+#define MTGPDC_N 351
+#define MTGPDC_FLOOR_2P 256
+#define MTGPDC_CEIL_2P 512
+#define MTGPDC_PARAM_TABLE mtgp32dc_params_fast_11213
+#define MTGP32_STATE_SIZE 1024
+#define MTGP32_STATE_MASK 1023
+#define CURAND_NUM_MTGP32_PARAMS 200
+#define MEXP 11213
+#define THREAD_NUM MTGPDC_FLOOR_2P
+#define LARGE_SIZE (THREAD_NUM * 3)
+#define TBL_SIZE 16
+
+/**
+ * \addtogroup DEVICE Device API
+ *
+ * @{
+ */
+
+/*
+ * \struct MTGP32_PARAMS_FAST_T
+ * MTGP32 parameters.
+ * Some element is redundant to keep structure simple.
+ *
+ * \b pos is a pick up position which is selected to have good
+ * performance on graphic processors.  3 < \b pos < Q, where Q is a
+ * maximum number such that the size of status array - Q is a power of
+ * 2.  For example, when \b mexp is 44497, size of 32-bit status array
+ * is 696, and Q is 184, then \b pos is between 4 and 183. This means
+ * 512 parallel calculations is allowed when \b mexp is 44497.
+ *
+ * \b poly_sha1 is SHA1 digest of the characteristic polynomial of
+ * state transition function. SHA1 is calculated based on printing
+ * form of the polynomial. This is important when we use parameters
+ * generated by the dynamic creator which
+ *
+ * \b mask This is a mask to make the dimension of state space have
+ * just Mersenne Prime. This is redundant.
+ */
+
+struct mtgp32_params_fast;
+
+struct mtgp32_params_fast {
+    int mexp;			/*< Mersenne exponent. This is redundant. */
+    int pos;			/*< pick up position. */
+    int sh1;			/*< shift value 1. 0 < sh1 < 32. */
+    int sh2;			/*< shift value 2. 0 < sh2 < 32. */
+    unsigned int tbl[16];		/*< a small matrix. */
+    unsigned int tmp_tbl[16];	/*< a small matrix for tempering. */
+    unsigned int flt_tmp_tbl[16];	/*< a small matrix for tempering and
+                 converting to float. */
+    unsigned int mask;		/*< This is a mask for state space */
+    unsigned char poly_sha1[21]; /*< SHA1 digest */
+};
+
+/** \cond UNHIDE_TYPEDEFS */
+typedef struct mtgp32_params_fast mtgp32_params_fast_t;
+/** \endcond */
+
+/*
+ * Generator Parameters.
+ */
+struct mtgp32_kernel_params;
+struct mtgp32_kernel_params {
+    unsigned int pos_tbl[CURAND_NUM_MTGP32_PARAMS];
+    unsigned int param_tbl[CURAND_NUM_MTGP32_PARAMS][TBL_SIZE];
+    unsigned int temper_tbl[CURAND_NUM_MTGP32_PARAMS][TBL_SIZE];
+    unsigned int single_temper_tbl[CURAND_NUM_MTGP32_PARAMS][TBL_SIZE];
+    unsigned int sh1_tbl[CURAND_NUM_MTGP32_PARAMS];
+    unsigned int sh2_tbl[CURAND_NUM_MTGP32_PARAMS];
+    unsigned int mask[1];
+};
+
+/** \cond UNHIDE_TYPEDEFS */
+typedef struct mtgp32_kernel_params mtgp32_kernel_params_t;
+/** \endcond */
+
+
+
+/*
+ * kernel I/O
+ * This structure must be initialized before first use.
+ */
+
+/* MTGP (Mersenne Twister) RNG */
+/* This generator uses the Mersenne Twister algorithm of
+ * http://arxiv.org/abs/1005.4973v2
+ * Has period 2^11213.
+*/
+
+/**
+ * CURAND MTGP32 state 
+ */
+struct curandStateMtgp32;
+
+struct curandStateMtgp32 {
+    unsigned int s[MTGP32_STATE_SIZE];
+    int offset;
+    int pIdx;
+    mtgp32_kernel_params_t * k;
+};
+
+/*
+ * CURAND MTGP32 state 
+ */
+/** \cond UNHIDE_TYPEDEFS */
+typedef struct curandStateMtgp32 curandStateMtgp32_t;
+/** \endcond */
+
+/** @} */
+
+#endif
+

evalkit_tf449/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
+
+

evalkit_tf449/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

evalkit_tf449/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_)

evalkit_tf449/lib/python3.10/site-packages/nvidia/curand/include/curand_normal_static.h

@@ -0,0 +1,134 @@
+ /* 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.
+  */
+#ifndef CURAND_NORMAL_STATIC_H
+#define CURAND_NORMAL_STATIC_H
+
+#define QUALIFIERS_STATIC __host__ __device__ __forceinline__
+
+#include <nv/target>
+#if defined(HOST_HAVE_ERFCINVF)
+  #define IF_DEVICE_OR_HAVE_ERFCINVF(t, f) _NV_BLOCK_EXPAND(t)
+#else
+  #define IF_DEVICE_OR_HAVE_ERFCINVF(t, f) NV_IF_ELSE_TARGET(NV_IS_DEVICE, t, f)
+#endif
+
+QUALIFIERS_STATIC float _curand_normal_icdf(unsigned int x)
+{
+IF_DEVICE_OR_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);
+,
+    x++;    //suppress warnings
+    return 0.0f;
+)
+}
+
+QUALIFIERS_STATIC float _curand_normal_icdf(unsigned long long x)
+{
+IF_DEVICE_OR_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);
+,
+    x++;
+    return 0.0f;
+)
+}
+
+QUALIFIERS_STATIC double _curand_normal_icdf_double(unsigned int x)
+{
+IF_DEVICE_OR_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);
+,
+    x++;
+    return 0.0;
+)
+}
+
+QUALIFIERS_STATIC double _curand_normal_icdf_double(unsigned long long x)
+{
+IF_DEVICE_OR_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);
+,
+    x++;
+    return 0.0;
+)
+}
+#undef QUALIFIERS_STATIC
+#endif

evalkit_tf449/lib/python3.10/site-packages/nvidia/curand/include/curand_philox4x32_x.h

@@ -0,0 +1,195 @@
+/* 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.
+ */
+/*
+   Copyright 2010-2011, D. E. Shaw Research.
+   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 D. E. Shaw Research 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.
+ */
+
+#ifndef CURAND_PHILOX4X32_X__H_
+#define CURAND_PHILOX4X32_X__H_
+#include <nv/target>
+
+#if !defined(QUALIFIERS)
+#define QUALIFIERS static __forceinline__ __device__
+#endif
+
+#define PHILOX_W32_0   (0x9E3779B9)
+#define PHILOX_W32_1   (0xBB67AE85)
+#define PHILOX_M4x32_0 (0xD2511F53)
+#define PHILOX_M4x32_1 (0xCD9E8D57)
+
+struct curandStatePhilox4_32_10 {
+   uint4 ctr;
+   uint4 output;
+   uint2 key;
+   unsigned int STATE;
+   int boxmuller_flag;
+   int boxmuller_flag_double;
+   float boxmuller_extra;
+   double boxmuller_extra_double;
+};
+
+typedef struct curandStatePhilox4_32_10 curandStatePhilox4_32_10_t;
+
+
+QUALIFIERS void Philox_State_Incr(curandStatePhilox4_32_10_t* s, unsigned long long n)
+{
+   unsigned int nlo = (unsigned int)(n);
+   unsigned int nhi = (unsigned int)(n>>32);
+
+   s->ctr.x += nlo;
+   if( s->ctr.x < nlo )
+      nhi++;
+
+   s->ctr.y += nhi;
+   if(nhi <= s->ctr.y)
+      return;
+   if(++s->ctr.z) return;
+   ++s->ctr.w;
+}
+
+QUALIFIERS void Philox_State_Incr_hi(curandStatePhilox4_32_10_t* s, unsigned long long n)
+{
+   unsigned int nlo = (unsigned int)(n);
+   unsigned int nhi = (unsigned int)(n>>32);
+
+   s->ctr.z += nlo;
+   if( s->ctr.z < nlo )
+      nhi++;
+
+   s->ctr.w += nhi;
+}
+
+
+
+QUALIFIERS void Philox_State_Incr(curandStatePhilox4_32_10_t* s)
+{
+   if(++s->ctr.x) return;
+   if(++s->ctr.y) return;
+   if(++s->ctr.z) return;
+   ++s->ctr.w;
+}
+
+
+QUALIFIERS unsigned int mulhilo32(unsigned int a, unsigned int b, unsigned int* hip)
+{
+NV_IF_ELSE_TARGET(NV_IS_HOST,
+   // host code
+   unsigned long long product = ((unsigned long long)a) * ((unsigned long long)b);
+   *hip = product >> 32;
+   return (unsigned int)product;
+,
+   // device code
+   *hip = __umulhi(a,b);
+   return a*b;
+)
+}
+
+QUALIFIERS uint4 _philox4x32round(uint4 ctr, uint2 key)
+{
+   unsigned int hi0;
+   unsigned int hi1;
+   unsigned int lo0 = mulhilo32(PHILOX_M4x32_0, ctr.x, &hi0);
+   unsigned int lo1 = mulhilo32(PHILOX_M4x32_1, ctr.z, &hi1);
+
+   uint4 ret  = {hi1^ctr.y^key.x, lo1, hi0^ctr.w^key.y, lo0};
+   return ret;
+}
+
+QUALIFIERS uint4 curand_Philox4x32_10( uint4 c, uint2 k)
+{
+   c = _philox4x32round(c, k);                           // 1 
+   k.x += PHILOX_W32_0; k.y += PHILOX_W32_1;
+   c = _philox4x32round(c, k);                           // 2
+   k.x += PHILOX_W32_0; k.y += PHILOX_W32_1;
+   c = _philox4x32round(c, k);                           // 3 
+   k.x += PHILOX_W32_0; k.y += PHILOX_W32_1;
+   c = _philox4x32round(c, k);                           // 4 
+   k.x += PHILOX_W32_0; k.y += PHILOX_W32_1;
+   c = _philox4x32round(c, k);                           // 5 
+   k.x += PHILOX_W32_0; k.y += PHILOX_W32_1;
+   c = _philox4x32round(c, k);                           // 6 
+   k.x += PHILOX_W32_0; k.y += PHILOX_W32_1;
+   c = _philox4x32round(c, k);                           // 7 
+   k.x += PHILOX_W32_0; k.y += PHILOX_W32_1;
+   c = _philox4x32round(c, k);                           // 8 
+   k.x += PHILOX_W32_0; k.y += PHILOX_W32_1;
+   c = _philox4x32round(c, k);                           // 9 
+   k.x += PHILOX_W32_0; k.y += PHILOX_W32_1;
+   return _philox4x32round(c, k);                        // 10
+}
+
+
+#endif

evalkit_tf449/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_)

evalkit_tf449/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_)

evalkit_tf449/lib/python3.10/site-packages/nvidia/cusolver/include/cusolverMg.h

@@ -0,0 +1,318 @@
+/*
+ * Copyright 2019 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.
+ */
+
+#if !defined(CUSOLVERMG_H_)
+  #define CUSOLVERMG_H_
+
+  #include <stdint.h>
+  #include "cusolverDn.h"
+
+  #if defined(__cplusplus)
+extern "C" {
+  #endif /* __cplusplus */
+
+  struct cusolverMgContext;
+  typedef struct cusolverMgContext *cusolverMgHandle_t;
+
+  /**
+   * \beief This enum decides how 1D device Ids (or process ranks) get mapped to
+   * a 2D grid.
+   */
+  typedef enum {
+
+    CUDALIBMG_GRID_MAPPING_ROW_MAJOR = 1,
+    CUDALIBMG_GRID_MAPPING_COL_MAJOR = 0
+
+  } cusolverMgGridMapping_t;
+
+  /** \brief Opaque structure of the distributed grid */
+  typedef void *cudaLibMgGrid_t;
+  /** \brief Opaque structure of the distributed matrix descriptor */
+  typedef void *cudaLibMgMatrixDesc_t;
+
+  cusolverStatus_t CUSOLVERAPI cusolverMgCreate(cusolverMgHandle_t *handle);
+
+  cusolverStatus_t CUSOLVERAPI cusolverMgDestroy(cusolverMgHandle_t handle);
+
+  cusolverStatus_t CUSOLVERAPI cusolverMgDeviceSelect(
+    cusolverMgHandle_t handle,
+    int                nbDevices,
+    int                deviceId[]);
+
+  /**
+   * \brief Allocates resources related to the shared memory device grid.
+   * \param[out] grid the opaque data strcuture that holds the grid
+   * \param[in] numRowDevices number of devices in the row
+   * \param[in] numColDevices number of devices in the column
+   * \param[in] deviceId This array of size height * width stores the
+   *            device-ids of the 2D grid; each entry must correspond to a valid
+   * gpu or to -1 (denoting CPU). \param[in] mapping whether the 2D grid is in
+   * row/column major \returns the status code
+   */
+  cusolverStatus_t CUSOLVERAPI cusolverMgCreateDeviceGrid(
+    cudaLibMgGrid_t *       grid,
+    int32_t                 numRowDevices,
+    int32_t                 numColDevices,
+    const int32_t           deviceId[],
+    cusolverMgGridMapping_t mapping);
+
+  /**
+   * \brief Releases the allocated resources related to the distributed grid.
+   * \param[in] grid the opaque data strcuture that holds the distributed grid
+   * \returns the status code
+   */
+  cusolverStatus_t CUSOLVERAPI cusolverMgDestroyGrid(cudaLibMgGrid_t grid);
+
+  /**
+   * \brief Allocates resources related to the distributed matrix descriptor.
+   * \param[out] desc the opaque data strcuture that holds the descriptor
+   * \param[in] numRows number of total rows
+   * \param[in] numCols number of total columns
+   * \param[in] rowBlockSize row block size
+   * \param[in] colBlockSize column block size
+   * \param[in] dataType the data type of each element in cudaDataType
+   * \param[in] grid the opaque data structure of the distributed grid
+   * \returns the status code
+   */
+  cusolverStatus_t CUSOLVERAPI cusolverMgCreateMatrixDesc(
+    cudaLibMgMatrixDesc_t *desc,
+    int64_t                numRows,
+    int64_t                numCols,
+    int64_t                rowBlockSize,
+    int64_t                colBlockSize,
+    cudaDataType           dataType,
+    const cudaLibMgGrid_t  grid);
+
+  /**
+   * \brief Releases the allocated resources related to the distributed matrix
+   * descriptor. \param[in] desc the opaque data strcuture that holds the
+   * descriptor \returns the status code
+   */
+  cusolverStatus_t CUSOLVERAPI
+    cusolverMgDestroyMatrixDesc(cudaLibMgMatrixDesc_t desc);
+
+  cusolverStatus_t CUSOLVERAPI cusolverMgSyevd_bufferSize(
+    cusolverMgHandle_t    handle,
+    cusolverEigMode_t     jobz,
+    cublasFillMode_t      uplo,
+    int                   N,
+    void *                array_d_A[],
+    int                   IA,
+    int                   JA,
+    cudaLibMgMatrixDesc_t descrA,
+    void *                W,
+    cudaDataType          dataTypeW,
+    cudaDataType          computeType,
+    int64_t *             lwork);
+
+  cusolverStatus_t CUSOLVERAPI cusolverMgSyevd(
+    cusolverMgHandle_t    handle,
+    cusolverEigMode_t     jobz,
+    cublasFillMode_t      uplo,
+    int                   N,
+    void *                array_d_A[],
+    int                   IA,
+    int                   JA,
+    cudaLibMgMatrixDesc_t descrA,
+    void *                W,
+    cudaDataType          dataTypeW,
+    cudaDataType          computeType,
+    void *                array_d_work[],
+    int64_t               lwork,
+    int *                 info);
+
+  cusolverStatus_t CUSOLVERAPI cusolverMgGetrf_bufferSize(
+    cusolverMgHandle_t    handle,
+    int                   M,
+    int                   N,
+    void *                array_d_A[],
+    int                   IA,
+    int                   JA,
+    cudaLibMgMatrixDesc_t descrA,
+    int *                 array_d_IPIV[],
+    cudaDataType          computeType,
+    int64_t *             lwork);
+
+  cusolverStatus_t CUSOLVERAPI cusolverMgGetrf(
+    cusolverMgHandle_t    handle,
+    int                   M,
+    int                   N,
+    void *                array_d_A[],
+    int                   IA,
+    int                   JA,
+    cudaLibMgMatrixDesc_t descrA,
+    int *                 array_d_IPIV[],
+    cudaDataType          computeType,
+    void *                array_d_work[],
+    int64_t               lwork,
+    int *                 info);
+
+  cusolverStatus_t CUSOLVERAPI cusolverMgGetrs_bufferSize(
+    cusolverMgHandle_t    handle,
+    cublasOperation_t     TRANS,
+    int                   N,
+    int                   NRHS,
+    void *                array_d_A[],
+    int                   IA,
+    int                   JA,
+    cudaLibMgMatrixDesc_t descrA,
+    int *                 array_d_IPIV[],
+    void *                array_d_B[],
+    int                   IB,
+    int                   JB,
+    cudaLibMgMatrixDesc_t descrB,
+    cudaDataType          computeType,
+    int64_t *             lwork);
+
+  cusolverStatus_t CUSOLVERAPI cusolverMgGetrs(
+    cusolverMgHandle_t    handle,
+    cublasOperation_t     TRANS,
+    int                   N,
+    int                   NRHS,
+    void *                array_d_A[],
+    int                   IA,
+    int                   JA,
+    cudaLibMgMatrixDesc_t descrA,
+    int *                 array_d_IPIV[],
+    void *                array_d_B[],
+    int                   IB,
+    int                   JB,
+    cudaLibMgMatrixDesc_t descrB,
+    cudaDataType          computeType,
+    void *                array_d_work[],
+    int64_t               lwork,
+    int *                 info);
+
+  cusolverStatus_t CUSOLVERAPI cusolverMgPotrf_bufferSize(
+    cusolverMgHandle_t    handle,
+    cublasFillMode_t      uplo,
+    int                   N,
+    void *                array_d_A[],
+    int                   IA,
+    int                   JA,
+    cudaLibMgMatrixDesc_t descrA,
+    cudaDataType          computeType,
+    int64_t *             lwork);
+
+  cusolverStatus_t CUSOLVERAPI cusolverMgPotrf(
+    cusolverMgHandle_t    handle,
+    cublasFillMode_t      uplo,
+    int                   N,
+    void *                array_d_A[],
+    int                   IA,
+    int                   JA,
+    cudaLibMgMatrixDesc_t descrA,
+    cudaDataType          computeType,
+    void *                array_d_work[],
+    int64_t               lwork,
+    int *                 h_info);
+
+  cusolverStatus_t CUSOLVERAPI cusolverMgPotrs_bufferSize(
+    cusolverMgHandle_t    handle,
+    cublasFillMode_t      uplo,
+    int                   n,
+    int                   nrhs,
+    void *                array_d_A[],
+    int                   IA,
+    int                   JA,
+    cudaLibMgMatrixDesc_t descrA,
+    void *                array_d_B[],
+    int                   IB,
+    int                   JB,
+    cudaLibMgMatrixDesc_t descrB,
+    cudaDataType          computeType,
+    int64_t *             lwork);
+
+  cusolverStatus_t CUSOLVERAPI cusolverMgPotrs(
+    cusolverMgHandle_t    handle,
+    cublasFillMode_t      uplo,
+    int                   n,
+    int                   nrhs,
+    void *                array_d_A[],
+    int                   IA,
+    int                   JA,
+    cudaLibMgMatrixDesc_t descrA,
+    void *                array_d_B[],
+    int                   IB,
+    int                   JB,
+    cudaLibMgMatrixDesc_t descrB,
+    cudaDataType          computeType,
+    void *                array_d_work[],
+    int64_t               lwork,
+    int *                 h_info);
+
+  cusolverStatus_t CUSOLVERAPI cusolverMgPotri_bufferSize(
+    cusolverMgHandle_t    handle,
+    cublasFillMode_t      uplo,
+    int                   N,
+    void *                array_d_A[],
+    int                   IA,
+    int                   JA,
+    cudaLibMgMatrixDesc_t descrA,
+    cudaDataType          computeType,
+    int64_t *             lwork);
+
+  cusolverStatus_t CUSOLVERAPI cusolverMgPotri(
+    cusolverMgHandle_t    handle,
+    cublasFillMode_t      uplo,
+    int                   N,
+    void *                array_d_A[],
+    int                   IA,
+    int                   JA,
+    cudaLibMgMatrixDesc_t descrA,
+    cudaDataType          computeType,
+    void *                array_d_work[],
+    int64_t               lwork,
+    int *                 h_info);
+
+  #if defined(__cplusplus)
+}
+  #endif /* __cplusplus */
+
+#endif // CUSOLVERMG_H_

evalkit_tf449/lib/python3.10/site-packages/nvidia/cusolver/include/cusolverRf.h

@@ -0,0 +1,339 @@
+/*
+ * Copyright 1993-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.
+ */
+
+#if !defined(CUSOLVERRF_H_)
+  #define CUSOLVERRF_H_
+
+  #include "driver_types.h"
+  #include "cuComplex.h"
+  #include "cusolver_common.h"
+
+  #if defined(__cplusplus)
+extern "C" {
+  #endif /* __cplusplus */
+
+  /* CUSOLVERRF mode */
+  typedef enum {
+    CUSOLVERRF_RESET_VALUES_FAST_MODE_OFF = 0, // default
+    CUSOLVERRF_RESET_VALUES_FAST_MODE_ON = 1
+  } cusolverRfResetValuesFastMode_t;
+
+  /* CUSOLVERRF matrix format */
+  typedef enum {
+    CUSOLVERRF_MATRIX_FORMAT_CSR = 0, // default
+    CUSOLVERRF_MATRIX_FORMAT_CSC = 1
+  } cusolverRfMatrixFormat_t;
+
+  /* CUSOLVERRF unit diagonal */
+  typedef enum {
+    CUSOLVERRF_UNIT_DIAGONAL_STORED_L = 0, // default
+    CUSOLVERRF_UNIT_DIAGONAL_STORED_U = 1,
+    CUSOLVERRF_UNIT_DIAGONAL_ASSUMED_L = 2,
+    CUSOLVERRF_UNIT_DIAGONAL_ASSUMED_U = 3
+  } cusolverRfUnitDiagonal_t;
+
+  /* CUSOLVERRF factorization algorithm */
+  typedef enum {
+    CUSOLVERRF_FACTORIZATION_ALG0 = 0, // default
+    CUSOLVERRF_FACTORIZATION_ALG1 = 1,
+    CUSOLVERRF_FACTORIZATION_ALG2 = 2,
+  } cusolverRfFactorization_t;
+
+  /* CUSOLVERRF triangular solve algorithm */
+  typedef enum {
+    CUSOLVERRF_TRIANGULAR_SOLVE_ALG1 = 1, // default
+    CUSOLVERRF_TRIANGULAR_SOLVE_ALG2 = 2,
+    CUSOLVERRF_TRIANGULAR_SOLVE_ALG3 = 3
+  } cusolverRfTriangularSolve_t;
+
+  /* CUSOLVERRF numeric boost report */
+  typedef enum {
+    CUSOLVERRF_NUMERIC_BOOST_NOT_USED = 0, // default
+    CUSOLVERRF_NUMERIC_BOOST_USED = 1
+  } cusolverRfNumericBoostReport_t;
+
+  /* Opaque structure holding CUSOLVERRF library common */
+  struct cusolverRfCommon;
+  typedef struct cusolverRfCommon* cusolverRfHandle_t;
+
+  /* CUSOLVERRF create (allocate memory) and destroy (free memory) in the handle
+   */
+  cusolverStatus_t CUSOLVERAPI cusolverRfCreate(cusolverRfHandle_t* handle);
+  cusolverStatus_t CUSOLVERAPI cusolverRfDestroy(cusolverRfHandle_t handle);
+
+  /* CUSOLVERRF set and get input format */
+  cusolverStatus_t CUSOLVERAPI cusolverRfGetMatrixFormat(
+    cusolverRfHandle_t        handle,
+    cusolverRfMatrixFormat_t* format,
+    cusolverRfUnitDiagonal_t* diag);
+
+  cusolverStatus_t CUSOLVERAPI cusolverRfSetMatrixFormat(
+    cusolverRfHandle_t       handle,
+    cusolverRfMatrixFormat_t format,
+    cusolverRfUnitDiagonal_t diag);
+
+  /* CUSOLVERRF set and get numeric properties */
+  cusolverStatus_t CUSOLVERAPI cusolverRfSetNumericProperties(
+    cusolverRfHandle_t handle,
+    double             zero,
+    double             boost);
+
+  cusolverStatus_t CUSOLVERAPI cusolverRfGetNumericProperties(
+    cusolverRfHandle_t handle,
+    double*            zero,
+    double*            boost);
+
+  cusolverStatus_t CUSOLVERAPI cusolverRfGetNumericBoostReport(
+    cusolverRfHandle_t              handle,
+    cusolverRfNumericBoostReport_t* report);
+
+  /* CUSOLVERRF choose the triangular solve algorithm */
+  cusolverStatus_t CUSOLVERAPI cusolverRfSetAlgs(
+    cusolverRfHandle_t          handle,
+    cusolverRfFactorization_t   factAlg,
+    cusolverRfTriangularSolve_t solveAlg);
+
+  cusolverStatus_t CUSOLVERAPI cusolverRfGetAlgs(
+    cusolverRfHandle_t           handle,
+    cusolverRfFactorization_t*   factAlg,
+    cusolverRfTriangularSolve_t* solveAlg);
+
+  /* CUSOLVERRF set and get fast mode */
+  cusolverStatus_t CUSOLVERAPI cusolverRfGetResetValuesFastMode(
+    cusolverRfHandle_t               handle,
+    cusolverRfResetValuesFastMode_t* fastMode);
+
+  cusolverStatus_t CUSOLVERAPI cusolverRfSetResetValuesFastMode(
+    cusolverRfHandle_t              handle,
+    cusolverRfResetValuesFastMode_t fastMode);
+
+  /*** Non-Batched Routines ***/
+  /* CUSOLVERRF setup of internal structures from host or device memory */
+  cusolverStatus_t CUSOLVERAPI
+    cusolverRfSetupHost(/* Input (in the host memory) */
+                        int     n,
+                        int     nnzA,
+                        int*    h_csrRowPtrA,
+                        int*    h_csrColIndA,
+                        double* h_csrValA,
+                        int     nnzL,
+                        int*    h_csrRowPtrL,
+                        int*    h_csrColIndL,
+                        double* h_csrValL,
+                        int     nnzU,
+                        int*    h_csrRowPtrU,
+                        int*    h_csrColIndU,
+                        double* h_csrValU,
+                        int*    h_P,
+                        int*    h_Q,
+                        /* Output */
+                        cusolverRfHandle_t handle);
+
+  cusolverStatus_t CUSOLVERAPI
+    cusolverRfSetupDevice(/* Input (in the device memory) */
+                          int     n,
+                          int     nnzA,
+                          int*    csrRowPtrA,
+                          int*    csrColIndA,
+                          double* csrValA,
+                          int     nnzL,
+                          int*    csrRowPtrL,
+                          int*    csrColIndL,
+                          double* csrValL,
+                          int     nnzU,
+                          int*    csrRowPtrU,
+                          int*    csrColIndU,
+                          double* csrValU,
+                          int*    P,
+                          int*    Q,
+                          /* Output */
+                          cusolverRfHandle_t handle);
+
+  /* CUSOLVERRF update the matrix values (assuming the reordering, pivoting
+     and consequently the sparsity pattern of L and U did not change),
+     and zero out the remaining values. */
+  cusolverStatus_t CUSOLVERAPI
+    cusolverRfResetValues(/* Input (in the device memory) */
+                          int     n,
+                          int     nnzA,
+                          int*    csrRowPtrA,
+                          int*    csrColIndA,
+                          double* csrValA,
+                          int*    P,
+                          int*    Q,
+                          /* Output */
+                          cusolverRfHandle_t handle);
+
+  /* CUSOLVERRF analysis (for parallelism) */
+  cusolverStatus_t CUSOLVERAPI cusolverRfAnalyze(cusolverRfHandle_t handle);
+
+  /* CUSOLVERRF re-factorization (for parallelism) */
+  cusolverStatus_t CUSOLVERAPI cusolverRfRefactor(cusolverRfHandle_t handle);
+
+  /* CUSOLVERRF extraction: Get L & U packed into a single matrix M */
+  cusolverStatus_t CUSOLVERAPI
+    cusolverRfAccessBundledFactorsDevice(/* Input */
+                                         cusolverRfHandle_t handle,
+                                         /* Output (in the host memory) */
+                                         int* nnzM,
+                                         /* Output (in the device memory) */
+                                         int**    Mp,
+                                         int**    Mi,
+                                         double** Mx);
+
+  cusolverStatus_t CUSOLVERAPI
+    cusolverRfExtractBundledFactorsHost(/* Input */
+                                        cusolverRfHandle_t handle,
+                                        /* Output (in the host memory) */
+                                        int*     h_nnzM,
+                                        int**    h_Mp,
+                                        int**    h_Mi,
+                                        double** h_Mx);
+
+  /* CUSOLVERRF extraction: Get L & U individually */
+  cusolverStatus_t CUSOLVERAPI
+    cusolverRfExtractSplitFactorsHost(/* Input */
+                                      cusolverRfHandle_t handle,
+                                      /* Output (in the host memory) */
+                                      int*     h_nnzL,
+                                      int**    h_csrRowPtrL,
+                                      int**    h_csrColIndL,
+                                      double** h_csrValL,
+                                      int*     h_nnzU,
+                                      int**    h_csrRowPtrU,
+                                      int**    h_csrColIndU,
+                                      double** h_csrValU);
+
+  /* CUSOLVERRF (forward and backward triangular) solves */
+  cusolverStatus_t CUSOLVERAPI
+    cusolverRfSolve(/* Input (in the device memory) */
+                    cusolverRfHandle_t handle,
+                    int*               P,
+                    int*               Q,
+                    int                nrhs, // only nrhs=1 is supported
+                    double*            Temp, // of size ldt*nrhs (ldt>=n)
+                    int                ldt,
+                    /* Input/Output (in the device memory) */
+                    double* XF,
+                    /* Input */
+                    int ldxf);
+
+  /*** Batched Routines ***/
+  /* CUSOLVERRF-batch setup of internal structures from host */
+  cusolverStatus_t CUSOLVERAPI
+    cusolverRfBatchSetupHost(/* Input (in the host memory)*/
+                             int     batchSize,
+                             int     n,
+                             int     nnzA,
+                             int*    h_csrRowPtrA,
+                             int*    h_csrColIndA,
+                             double* h_csrValA_array[],
+                             int     nnzL,
+                             int*    h_csrRowPtrL,
+                             int*    h_csrColIndL,
+                             double* h_csrValL,
+                             int     nnzU,
+                             int*    h_csrRowPtrU,
+                             int*    h_csrColIndU,
+                             double* h_csrValU,
+                             int*    h_P,
+                             int*    h_Q,
+                             /* Output (in the device memory) */
+                             cusolverRfHandle_t handle);
+
+  /* CUSOLVERRF-batch update the matrix values (assuming the reordering,
+     pivoting and consequently the sparsity pattern of L and U did not change),
+     and zero out the remaining values. */
+  cusolverStatus_t CUSOLVERAPI
+    cusolverRfBatchResetValues(/* Input (in the device memory) */
+                               int     batchSize,
+                               int     n,
+                               int     nnzA,
+                               int*    csrRowPtrA,
+                               int*    csrColIndA,
+                               double* csrValA_array[],
+                               int*    P,
+                               int*    Q,
+                               /* Output */
+                               cusolverRfHandle_t handle);
+
+  /* CUSOLVERRF-batch analysis (for parallelism) */
+  cusolverStatus_t CUSOLVERAPI
+    cusolverRfBatchAnalyze(cusolverRfHandle_t handle);
+
+  /* CUSOLVERRF-batch re-factorization (for parallelism) */
+  cusolverStatus_t CUSOLVERAPI
+    cusolverRfBatchRefactor(cusolverRfHandle_t handle);
+
+  /* CUSOLVERRF-batch (forward and backward triangular) solves */
+  cusolverStatus_t CUSOLVERAPI
+    cusolverRfBatchSolve(/* Input (in the device memory) */
+                         cusolverRfHandle_t handle,
+                         int*               P,
+                         int*               Q,
+                         int                nrhs, // only nrhs=1 is supported
+                         double* Temp, // of size 2*batchSize*(n*nrhs)
+                         int     ldt,  // only ldt=n is supported
+                         /* Input/Output (in the device memory) */
+                         double* XF_array[],
+                         /* Input */
+                         int ldxf);
+
+  /* CUSOLVERRF-batch obtain the position of zero pivot */
+  cusolverStatus_t CUSOLVERAPI
+    cusolverRfBatchZeroPivot(/* Input */
+                             cusolverRfHandle_t handle,
+                             /* Output (in the host memory) */
+                             int* position);
+
+  #if defined(__cplusplus)
+}
+  #endif /* __cplusplus */
+
+#endif /* CUSOLVERRF_H_ */

evalkit_tf449/lib/python3.10/site-packages/nvidia/cusolver/include/cusolverSp.h

@@ -0,0 +1,923 @@
+/*
+ * Copyright 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.
+ */
+
+#if !defined(CUSOLVERSP_H_)
+  #define CUSOLVERSP_H_
+
+  #include "cusparse.h"
+  #include "cublas_v2.h"
+  #include "cusolver_common.h"
+
+  #if defined(__cplusplus)
+extern "C" {
+  #endif /* __cplusplus */
+
+  struct cusolverSpContext;
+  typedef struct cusolverSpContext *cusolverSpHandle_t;
+
+  struct csrqrInfo;
+  typedef struct csrqrInfo *csrqrInfo_t;
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpCreate(cusolverSpHandle_t *handle);
+  cusolverStatus_t CUSOLVERAPI cusolverSpDestroy(cusolverSpHandle_t handle);
+  cusolverStatus_t CUSOLVERAPI
+    cusolverSpSetStream(cusolverSpHandle_t handle, cudaStream_t streamId);
+  cusolverStatus_t CUSOLVERAPI
+    cusolverSpGetStream(cusolverSpHandle_t handle, cudaStream_t *streamId);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpXcsrissymHost(
+    cusolverSpHandle_t       handle,
+    int                      m,
+    int                      nnzA,
+    const cusparseMatDescr_t descrA,
+    const int *              csrRowPtrA,
+    const int *              csrEndPtrA,
+    const int *              csrColIndA,
+    int *                    issym);
+
+  /* -------- GPU linear solver by LU factorization
+   *       solve A*x = b, A can be singular
+   * [ls] stands for linear solve
+   * [v] stands for vector
+   * [lu] stands for LU factorization
+   */
+  cusolverStatus_t CUSOLVERAPI cusolverSpScsrlsvluHost(
+    cusolverSpHandle_t       handle,
+    int                      n,
+    int                      nnzA,
+    const cusparseMatDescr_t descrA,
+    const float *            csrValA,
+    const int *              csrRowPtrA,
+    const int *              csrColIndA,
+    const float *            b,
+    float                    tol,
+    int                      reorder,
+    float *                  x,
+    int *                    singularity);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpDcsrlsvluHost(
+    cusolverSpHandle_t       handle,
+    int                      n,
+    int                      nnzA,
+    const cusparseMatDescr_t descrA,
+    const double *           csrValA,
+    const int *              csrRowPtrA,
+    const int *              csrColIndA,
+    const double *           b,
+    double                   tol,
+    int                      reorder,
+    double *                 x,
+    int *                    singularity);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpCcsrlsvluHost(
+    cusolverSpHandle_t       handle,
+    int                      n,
+    int                      nnzA,
+    const cusparseMatDescr_t descrA,
+    const cuComplex *        csrValA,
+    const int *              csrRowPtrA,
+    const int *              csrColIndA,
+    const cuComplex *        b,
+    float                    tol,
+    int                      reorder,
+    cuComplex *              x,
+    int *                    singularity);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpZcsrlsvluHost(
+    cusolverSpHandle_t       handle,
+    int                      n,
+    int                      nnzA,
+    const cusparseMatDescr_t descrA,
+    const cuDoubleComplex *  csrValA,
+    const int *              csrRowPtrA,
+    const int *              csrColIndA,
+    const cuDoubleComplex *  b,
+    double                   tol,
+    int                      reorder,
+    cuDoubleComplex *        x,
+    int *                    singularity);
+
+  /* -------- GPU linear solver by QR factorization
+   *       solve A*x = b, A can be singular
+   * [ls] stands for linear solve
+   * [v] stands for vector
+   * [qr] stands for QR factorization
+   */
+  cusolverStatus_t CUSOLVERAPI cusolverSpScsrlsvqr(
+    cusolverSpHandle_t       handle,
+    int                      m,
+    int                      nnz,
+    const cusparseMatDescr_t descrA,
+    const float *            csrVal,
+    const int *              csrRowPtr,
+    const int *              csrColInd,
+    const float *            b,
+    float                    tol,
+    int                      reorder,
+    float *                  x,
+    int *                    singularity);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpDcsrlsvqr(
+    cusolverSpHandle_t       handle,
+    int                      m,
+    int                      nnz,
+    const cusparseMatDescr_t descrA,
+    const double *           csrVal,
+    const int *              csrRowPtr,
+    const int *              csrColInd,
+    const double *           b,
+    double                   tol,
+    int                      reorder,
+    double *                 x,
+    int *                    singularity);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpCcsrlsvqr(
+    cusolverSpHandle_t       handle,
+    int                      m,
+    int                      nnz,
+    const cusparseMatDescr_t descrA,
+    const cuComplex *        csrVal,
+    const int *              csrRowPtr,
+    const int *              csrColInd,
+    const cuComplex *        b,
+    float                    tol,
+    int                      reorder,
+    cuComplex *              x,
+    int *                    singularity);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpZcsrlsvqr(
+    cusolverSpHandle_t       handle,
+    int                      m,
+    int                      nnz,
+    const cusparseMatDescr_t descrA,
+    const cuDoubleComplex *  csrVal,
+    const int *              csrRowPtr,
+    const int *              csrColInd,
+    const cuDoubleComplex *  b,
+    double                   tol,
+    int                      reorder,
+    cuDoubleComplex *        x,
+    int *                    singularity);
+
+  /* -------- CPU linear solver by QR factorization
+   *       solve A*x = b, A can be singular
+   * [ls] stands for linear solve
+   * [v] stands for vector
+   * [qr] stands for QR factorization
+   */
+  cusolverStatus_t CUSOLVERAPI cusolverSpScsrlsvqrHost(
+    cusolverSpHandle_t       handle,
+    int                      m,
+    int                      nnz,
+    const cusparseMatDescr_t descrA,
+    const float *            csrValA,
+    const int *              csrRowPtrA,
+    const int *              csrColIndA,
+    const float *            b,
+    float                    tol,
+    int                      reorder,
+    float *                  x,
+    int *                    singularity);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpDcsrlsvqrHost(
+    cusolverSpHandle_t       handle,
+    int                      m,
+    int                      nnz,
+    const cusparseMatDescr_t descrA,
+    const double *           csrValA,
+    const int *              csrRowPtrA,
+    const int *              csrColIndA,
+    const double *           b,
+    double                   tol,
+    int                      reorder,
+    double *                 x,
+    int *                    singularity);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpCcsrlsvqrHost(
+    cusolverSpHandle_t       handle,
+    int                      m,
+    int                      nnz,
+    const cusparseMatDescr_t descrA,
+    const cuComplex *        csrValA,
+    const int *              csrRowPtrA,
+    const int *              csrColIndA,
+    const cuComplex *        b,
+    float                    tol,
+    int                      reorder,
+    cuComplex *              x,
+    int *                    singularity);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpZcsrlsvqrHost(
+    cusolverSpHandle_t       handle,
+    int                      m,
+    int                      nnz,
+    const cusparseMatDescr_t descrA,
+    const cuDoubleComplex *  csrValA,
+    const int *              csrRowPtrA,
+    const int *              csrColIndA,
+    const cuDoubleComplex *  b,
+    double                   tol,
+    int                      reorder,
+    cuDoubleComplex *        x,
+    int *                    singularity);
+
+  /* -------- CPU linear solver by Cholesky factorization
+   *       solve A*x = b, A can be singular
+   * [ls] stands for linear solve
+   * [v] stands for vector
+   * [chol] stands for Cholesky factorization
+   *
+   * Only works for symmetric positive definite matrix.
+   * The upper part of A is ignored.
+   */
+  cusolverStatus_t CUSOLVERAPI cusolverSpScsrlsvcholHost(
+    cusolverSpHandle_t       handle,
+    int                      m,
+    int                      nnz,
+    const cusparseMatDescr_t descrA,
+    const float *            csrVal,
+    const int *              csrRowPtr,
+    const int *              csrColInd,
+    const float *            b,
+    float                    tol,
+    int                      reorder,
+    float *                  x,
+    int *                    singularity);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpDcsrlsvcholHost(
+    cusolverSpHandle_t       handle,
+    int                      m,
+    int                      nnz,
+    const cusparseMatDescr_t descrA,
+    const double *           csrVal,
+    const int *              csrRowPtr,
+    const int *              csrColInd,
+    const double *           b,
+    double                   tol,
+    int                      reorder,
+    double *                 x,
+    int *                    singularity);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpCcsrlsvcholHost(
+    cusolverSpHandle_t       handle,
+    int                      m,
+    int                      nnz,
+    const cusparseMatDescr_t descrA,
+    const cuComplex *        csrVal,
+    const int *              csrRowPtr,
+    const int *              csrColInd,
+    const cuComplex *        b,
+    float                    tol,
+    int                      reorder,
+    cuComplex *              x,
+    int *                    singularity);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpZcsrlsvcholHost(
+    cusolverSpHandle_t       handle,
+    int                      m,
+    int                      nnz,
+    const cusparseMatDescr_t descrA,
+    const cuDoubleComplex *  csrVal,
+    const int *              csrRowPtr,
+    const int *              csrColInd,
+    const cuDoubleComplex *  b,
+    double                   tol,
+    int                      reorder,
+    cuDoubleComplex *        x,
+    int *                    singularity);
+
+  /* -------- GPU linear solver by Cholesky factorization
+   *       solve A*x = b, A can be singular
+   * [ls] stands for linear solve
+   * [v] stands for vector
+   * [chol] stands for Cholesky factorization
+   *
+   * Only works for symmetric positive definite matrix.
+   * The upper part of A is ignored.
+   */
+  cusolverStatus_t CUSOLVERAPI cusolverSpScsrlsvchol(
+    cusolverSpHandle_t       handle,
+    int                      m,
+    int                      nnz,
+    const cusparseMatDescr_t descrA,
+    const float *            csrVal,
+    const int *              csrRowPtr,
+    const int *              csrColInd,
+    const float *            b,
+    float                    tol,
+    int                      reorder,
+    // output
+    float *x,
+    int *  singularity);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpDcsrlsvchol(
+    cusolverSpHandle_t       handle,
+    int                      m,
+    int                      nnz,
+    const cusparseMatDescr_t descrA,
+    const double *           csrVal,
+    const int *              csrRowPtr,
+    const int *              csrColInd,
+    const double *           b,
+    double                   tol,
+    int                      reorder,
+    // output
+    double *x,
+    int *   singularity);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpCcsrlsvchol(
+    cusolverSpHandle_t       handle,
+    int                      m,
+    int                      nnz,
+    const cusparseMatDescr_t descrA,
+    const cuComplex *        csrVal,
+    const int *              csrRowPtr,
+    const int *              csrColInd,
+    const cuComplex *        b,
+    float                    tol,
+    int                      reorder,
+    // output
+    cuComplex *x,
+    int *      singularity);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpZcsrlsvchol(
+    cusolverSpHandle_t       handle,
+    int                      m,
+    int                      nnz,
+    const cusparseMatDescr_t descrA,
+    const cuDoubleComplex *  csrVal,
+    const int *              csrRowPtr,
+    const int *              csrColInd,
+    const cuDoubleComplex *  b,
+    double                   tol,
+    int                      reorder,
+    // output
+    cuDoubleComplex *x,
+    int *            singularity);
+
+  /* ----------- CPU least square solver by QR factorization
+   *       solve min|b - A*x|
+   * [lsq] stands for least square
+   * [v] stands for vector
+   * [qr] stands for QR factorization
+   */
+  cusolverStatus_t CUSOLVERAPI cusolverSpScsrlsqvqrHost(
+    cusolverSpHandle_t       handle,
+    int                      m,
+    int                      n,
+    int                      nnz,
+    const cusparseMatDescr_t descrA,
+    const float *            csrValA,
+    const int *              csrRowPtrA,
+    const int *              csrColIndA,
+    const float *            b,
+    float                    tol,
+    int *                    rankA,
+    float *                  x,
+    int *                    p,
+    float *                  min_norm);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpDcsrlsqvqrHost(
+    cusolverSpHandle_t       handle,
+    int                      m,
+    int                      n,
+    int                      nnz,
+    const cusparseMatDescr_t descrA,
+    const double *           csrValA,
+    const int *              csrRowPtrA,
+    const int *              csrColIndA,
+    const double *           b,
+    double                   tol,
+    int *                    rankA,
+    double *                 x,
+    int *                    p,
+    double *                 min_norm);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpCcsrlsqvqrHost(
+    cusolverSpHandle_t       handle,
+    int                      m,
+    int                      n,
+    int                      nnz,
+    const cusparseMatDescr_t descrA,
+    const cuComplex *        csrValA,
+    const int *              csrRowPtrA,
+    const int *              csrColIndA,
+    const cuComplex *        b,
+    float                    tol,
+    int *                    rankA,
+    cuComplex *              x,
+    int *                    p,
+    float *                  min_norm);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpZcsrlsqvqrHost(
+    cusolverSpHandle_t       handle,
+    int                      m,
+    int                      n,
+    int                      nnz,
+    const cusparseMatDescr_t descrA,
+    const cuDoubleComplex *  csrValA,
+    const int *              csrRowPtrA,
+    const int *              csrColIndA,
+    const cuDoubleComplex *  b,
+    double                   tol,
+    int *                    rankA,
+    cuDoubleComplex *        x,
+    int *                    p,
+    double *                 min_norm);
+
+  /* --------- CPU eigenvalue solver by shift inverse
+   *      solve A*x = lambda * x
+   *   where lambda is the eigenvalue nearest mu0.
+   * [eig] stands for eigenvalue solver
+   * [si] stands for shift-inverse
+   */
+  cusolverStatus_t CUSOLVERAPI cusolverSpScsreigvsiHost(
+    cusolverSpHandle_t       handle,
+    int                      m,
+    int                      nnz,
+    const cusparseMatDescr_t descrA,
+    const float *            csrValA,
+    const int *              csrRowPtrA,
+    const int *              csrColIndA,
+    float                    mu0,
+    const float *            x0,
+    int                      maxite,
+    float                    tol,
+    float *                  mu,
+    float *                  x);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpDcsreigvsiHost(
+    cusolverSpHandle_t       handle,
+    int                      m,
+    int                      nnz,
+    const cusparseMatDescr_t descrA,
+    const double *           csrValA,
+    const int *              csrRowPtrA,
+    const int *              csrColIndA,
+    double                   mu0,
+    const double *           x0,
+    int                      maxite,
+    double                   tol,
+    double *                 mu,
+    double *                 x);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpCcsreigvsiHost(
+    cusolverSpHandle_t       handle,
+    int                      m,
+    int                      nnz,
+    const cusparseMatDescr_t descrA,
+    const cuComplex *        csrValA,
+    const int *              csrRowPtrA,
+    const int *              csrColIndA,
+    cuComplex                mu0,
+    const cuComplex *        x0,
+    int                      maxite,
+    float                    tol,
+    cuComplex *              mu,
+    cuComplex *              x);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpZcsreigvsiHost(
+    cusolverSpHandle_t       handle,
+    int                      m,
+    int                      nnz,
+    const cusparseMatDescr_t descrA,
+    const cuDoubleComplex *  csrValA,
+    const int *              csrRowPtrA,
+    const int *              csrColIndA,
+    cuDoubleComplex          mu0,
+    const cuDoubleComplex *  x0,
+    int                      maxite,
+    double                   tol,
+    cuDoubleComplex *        mu,
+    cuDoubleComplex *        x);
+
+  /* --------- GPU eigenvalue solver by shift inverse
+   *      solve A*x = lambda * x
+   *   where lambda is the eigenvalue nearest mu0.
+   * [eig] stands for eigenvalue solver
+   * [si] stands for shift-inverse
+   */
+  cusolverStatus_t CUSOLVERAPI cusolverSpScsreigvsi(
+    cusolverSpHandle_t       handle,
+    int                      m,
+    int                      nnz,
+    const cusparseMatDescr_t descrA,
+    const float *            csrValA,
+    const int *              csrRowPtrA,
+    const int *              csrColIndA,
+    float                    mu0,
+    const float *            x0,
+    int                      maxite,
+    float                    eps,
+    float *                  mu,
+    float *                  x);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpDcsreigvsi(
+    cusolverSpHandle_t       handle,
+    int                      m,
+    int                      nnz,
+    const cusparseMatDescr_t descrA,
+    const double *           csrValA,
+    const int *              csrRowPtrA,
+    const int *              csrColIndA,
+    double                   mu0,
+    const double *           x0,
+    int                      maxite,
+    double                   eps,
+    double *                 mu,
+    double *                 x);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpCcsreigvsi(
+    cusolverSpHandle_t       handle,
+    int                      m,
+    int                      nnz,
+    const cusparseMatDescr_t descrA,
+    const cuComplex *        csrValA,
+    const int *              csrRowPtrA,
+    const int *              csrColIndA,
+    cuComplex                mu0,
+    const cuComplex *        x0,
+    int                      maxite,
+    float                    eps,
+    cuComplex *              mu,
+    cuComplex *              x);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpZcsreigvsi(
+    cusolverSpHandle_t       handle,
+    int                      m,
+    int                      nnz,
+    const cusparseMatDescr_t descrA,
+    const cuDoubleComplex *  csrValA,
+    const int *              csrRowPtrA,
+    const int *              csrColIndA,
+    cuDoubleComplex          mu0,
+    const cuDoubleComplex *  x0,
+    int                      maxite,
+    double                   eps,
+    cuDoubleComplex *        mu,
+    cuDoubleComplex *        x);
+
+  // ----------- enclosed eigenvalues
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpScsreigsHost(
+    cusolverSpHandle_t       handle,
+    int                      m,
+    int                      nnz,
+    const cusparseMatDescr_t descrA,
+    const float *            csrValA,
+    const int *              csrRowPtrA,
+    const int *              csrColIndA,
+    cuComplex                left_bottom_corner,
+    cuComplex                right_upper_corner,
+    int *                    num_eigs);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpDcsreigsHost(
+    cusolverSpHandle_t       handle,
+    int                      m,
+    int                      nnz,
+    const cusparseMatDescr_t descrA,
+    const double *           csrValA,
+    const int *              csrRowPtrA,
+    const int *              csrColIndA,
+    cuDoubleComplex          left_bottom_corner,
+    cuDoubleComplex          right_upper_corner,
+    int *                    num_eigs);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpCcsreigsHost(
+    cusolverSpHandle_t       handle,
+    int                      m,
+    int                      nnz,
+    const cusparseMatDescr_t descrA,
+    const cuComplex *        csrValA,
+    const int *              csrRowPtrA,
+    const int *              csrColIndA,
+    cuComplex                left_bottom_corner,
+    cuComplex                right_upper_corner,
+    int *                    num_eigs);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpZcsreigsHost(
+    cusolverSpHandle_t       handle,
+    int                      m,
+    int                      nnz,
+    const cusparseMatDescr_t descrA,
+    const cuDoubleComplex *  csrValA,
+    const int *              csrRowPtrA,
+    const int *              csrColIndA,
+    cuDoubleComplex          left_bottom_corner,
+    cuDoubleComplex          right_upper_corner,
+    int *                    num_eigs);
+
+  /* --------- CPU symrcm
+   *   Symmetric reverse Cuthill McKee permutation
+   *
+   */
+  cusolverStatus_t CUSOLVERAPI cusolverSpXcsrsymrcmHost(
+    cusolverSpHandle_t       handle,
+    int                      n,
+    int                      nnzA,
+    const cusparseMatDescr_t descrA,
+    const int *              csrRowPtrA,
+    const int *              csrColIndA,
+    int *                    p);
+
+  /* --------- CPU symmdq
+   *   Symmetric minimum degree algorithm by quotient graph
+   *
+   */
+  cusolverStatus_t CUSOLVERAPI cusolverSpXcsrsymmdqHost(
+    cusolverSpHandle_t       handle,
+    int                      n,
+    int                      nnzA,
+    const cusparseMatDescr_t descrA,
+    const int *              csrRowPtrA,
+    const int *              csrColIndA,
+    int *                    p);
+
+  /* --------- CPU symmdq
+   *   Symmetric Approximate minimum degree algorithm by quotient graph
+   *
+   */
+  cusolverStatus_t CUSOLVERAPI cusolverSpXcsrsymamdHost(
+    cusolverSpHandle_t       handle,
+    int                      n,
+    int                      nnzA,
+    const cusparseMatDescr_t descrA,
+    const int *              csrRowPtrA,
+    const int *              csrColIndA,
+    int *                    p);
+
+  /* --------- CPU metis
+   *   symmetric reordering
+   */
+  cusolverStatus_t CUSOLVERAPI cusolverSpXcsrmetisndHost(
+    cusolverSpHandle_t       handle,
+    int                      n,
+    int                      nnzA,
+    const cusparseMatDescr_t descrA,
+    const int *              csrRowPtrA,
+    const int *              csrColIndA,
+    const int64_t *          options,
+    int *                    p);
+
+  /* --------- CPU zfd
+   *  Zero free diagonal reordering
+   */
+  cusolverStatus_t CUSOLVERAPI cusolverSpScsrzfdHost(
+    cusolverSpHandle_t       handle,
+    int                      n,
+    int                      nnz,
+    const cusparseMatDescr_t descrA,
+    const float *            csrValA,
+    const int *              csrRowPtrA,
+    const int *              csrColIndA,
+    int *                    P,
+    int *                    numnz);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpDcsrzfdHost(
+    cusolverSpHandle_t       handle,
+    int                      n,
+    int                      nnz,
+    const cusparseMatDescr_t descrA,
+    const double *           csrValA,
+    const int *              csrRowPtrA,
+    const int *              csrColIndA,
+    int *                    P,
+    int *                    numnz);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpCcsrzfdHost(
+    cusolverSpHandle_t       handle,
+    int                      n,
+    int                      nnz,
+    const cusparseMatDescr_t descrA,
+    const cuComplex *        csrValA,
+    const int *              csrRowPtrA,
+    const int *              csrColIndA,
+    int *                    P,
+    int *                    numnz);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpZcsrzfdHost(
+    cusolverSpHandle_t       handle,
+    int                      n,
+    int                      nnz,
+    const cusparseMatDescr_t descrA,
+    const cuDoubleComplex *  csrValA,
+    const int *              csrRowPtrA,
+    const int *              csrColIndA,
+    int *                    P,
+    int *                    numnz);
+
+  /* --------- CPU permuation
+   *   P*A*Q^T
+   *
+   */
+  cusolverStatus_t CUSOLVERAPI cusolverSpXcsrperm_bufferSizeHost(
+    cusolverSpHandle_t       handle,
+    int                      m,
+    int                      n,
+    int                      nnzA,
+    const cusparseMatDescr_t descrA,
+    const int *              csrRowPtrA,
+    const int *              csrColIndA,
+    const int *              p,
+    const int *              q,
+    size_t *                 bufferSizeInBytes);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpXcsrpermHost(
+    cusolverSpHandle_t       handle,
+    int                      m,
+    int                      n,
+    int                      nnzA,
+    const cusparseMatDescr_t descrA,
+    int *                    csrRowPtrA,
+    int *                    csrColIndA,
+    const int *              p,
+    const int *              q,
+    int *                    map,
+    void *                   pBuffer);
+
+  /*
+   *  Low-level API: Batched QR
+   *
+   */
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpCreateCsrqrInfo(csrqrInfo_t *info);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpDestroyCsrqrInfo(csrqrInfo_t info);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpXcsrqrAnalysisBatched(
+    cusolverSpHandle_t       handle,
+    int                      m,
+    int                      n,
+    int                      nnzA,
+    const cusparseMatDescr_t descrA,
+    const int *              csrRowPtrA,
+    const int *              csrColIndA,
+    csrqrInfo_t              info);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpScsrqrBufferInfoBatched(
+    cusolverSpHandle_t       handle,
+    int                      m,
+    int                      n,
+    int                      nnz,
+    const cusparseMatDescr_t descrA,
+    const float *            csrVal,
+    const int *              csrRowPtr,
+    const int *              csrColInd,
+    int                      batchSize,
+    csrqrInfo_t              info,
+    size_t *                 internalDataInBytes,
+    size_t *                 workspaceInBytes);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpDcsrqrBufferInfoBatched(
+    cusolverSpHandle_t       handle,
+    int                      m,
+    int                      n,
+    int                      nnz,
+    const cusparseMatDescr_t descrA,
+    const double *           csrVal,
+    const int *              csrRowPtr,
+    const int *              csrColInd,
+    int                      batchSize,
+    csrqrInfo_t              info,
+    size_t *                 internalDataInBytes,
+    size_t *                 workspaceInBytes);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpCcsrqrBufferInfoBatched(
+    cusolverSpHandle_t       handle,
+    int                      m,
+    int                      n,
+    int                      nnz,
+    const cusparseMatDescr_t descrA,
+    const cuComplex *        csrVal,
+    const int *              csrRowPtr,
+    const int *              csrColInd,
+    int                      batchSize,
+    csrqrInfo_t              info,
+    size_t *                 internalDataInBytes,
+    size_t *                 workspaceInBytes);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpZcsrqrBufferInfoBatched(
+    cusolverSpHandle_t       handle,
+    int                      m,
+    int                      n,
+    int                      nnz,
+    const cusparseMatDescr_t descrA,
+    const cuDoubleComplex *  csrVal,
+    const int *              csrRowPtr,
+    const int *              csrColInd,
+    int                      batchSize,
+    csrqrInfo_t              info,
+    size_t *                 internalDataInBytes,
+    size_t *                 workspaceInBytes);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpScsrqrsvBatched(
+    cusolverSpHandle_t       handle,
+    int                      m,
+    int                      n,
+    int                      nnz,
+    const cusparseMatDescr_t descrA,
+    const float *            csrValA,
+    const int *              csrRowPtrA,
+    const int *              csrColIndA,
+    const float *            b,
+    float *                  x,
+    int                      batchSize,
+    csrqrInfo_t              info,
+    void *                   pBuffer);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpDcsrqrsvBatched(
+    cusolverSpHandle_t       handle,
+    int                      m,
+    int                      n,
+    int                      nnz,
+    const cusparseMatDescr_t descrA,
+    const double *           csrValA,
+    const int *              csrRowPtrA,
+    const int *              csrColIndA,
+    const double *           b,
+    double *                 x,
+    int                      batchSize,
+    csrqrInfo_t              info,
+    void *                   pBuffer);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpCcsrqrsvBatched(
+    cusolverSpHandle_t       handle,
+    int                      m,
+    int                      n,
+    int                      nnz,
+    const cusparseMatDescr_t descrA,
+    const cuComplex *        csrValA,
+    const int *              csrRowPtrA,
+    const int *              csrColIndA,
+    const cuComplex *        b,
+    cuComplex *              x,
+    int                      batchSize,
+    csrqrInfo_t              info,
+    void *                   pBuffer);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpZcsrqrsvBatched(
+    cusolverSpHandle_t       handle,
+    int                      m,
+    int                      n,
+    int                      nnz,
+    const cusparseMatDescr_t descrA,
+    const cuDoubleComplex *  csrValA,
+    const int *              csrRowPtrA,
+    const int *              csrColIndA,
+    const cuDoubleComplex *  b,
+    cuDoubleComplex *        x,
+    int                      batchSize,
+    csrqrInfo_t              info,
+    void *                   pBuffer);
+
+  #if defined(__cplusplus)
+}
+  #endif /* __cplusplus */
+
+#endif // define CUSOLVERSP_H_

evalkit_tf449/lib/python3.10/site-packages/nvidia/cusolver/include/cusolverSp_LOWLEVEL_PREVIEW.h

@@ -0,0 +1,1107 @@
+/*
+ * Copyright 2015 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.
+ */
+
+#if !defined(CUSOLVERSP_LOWLEVEL_PREVIEW_H_)
+  #define CUSOLVERSP_LOWLEVEL_PREVIEW_H_
+
+  #include "cusolverSp.h"
+
+  #if defined(__cplusplus)
+extern "C" {
+  #endif /* __cplusplus */
+
+  struct csrluInfoHost;
+  typedef struct csrluInfoHost *csrluInfoHost_t;
+
+  struct csrqrInfoHost;
+  typedef struct csrqrInfoHost *csrqrInfoHost_t;
+
+  struct csrcholInfoHost;
+  typedef struct csrcholInfoHost *csrcholInfoHost_t;
+
+  struct csrcholInfo;
+  typedef struct csrcholInfo *csrcholInfo_t;
+
+  /*
+   * Low level API for CPU LU
+   *
+   */
+  cusolverStatus_t CUSOLVERAPI
+    cusolverSpCreateCsrluInfoHost(csrluInfoHost_t *info);
+
+  cusolverStatus_t CUSOLVERAPI
+    cusolverSpDestroyCsrluInfoHost(csrluInfoHost_t info);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpXcsrluAnalysisHost(
+    cusolverSpHandle_t       handle,
+    int                      n,
+    int                      nnzA,
+    const cusparseMatDescr_t descrA,
+    const int *              csrRowPtrA,
+    const int *              csrColIndA,
+    csrluInfoHost_t          info);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpScsrluBufferInfoHost(
+    cusolverSpHandle_t       handle,
+    int                      n,
+    int                      nnzA,
+    const cusparseMatDescr_t descrA,
+    const float *            csrValA,
+    const int *              csrRowPtrA,
+    const int *              csrColIndA,
+    csrluInfoHost_t          info,
+    size_t *                 internalDataInBytes,
+    size_t *                 workspaceInBytes);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpDcsrluBufferInfoHost(
+    cusolverSpHandle_t       handle,
+    int                      n,
+    int                      nnzA,
+    const cusparseMatDescr_t descrA,
+    const double *           csrValA,
+    const int *              csrRowPtrA,
+    const int *              csrColIndA,
+    csrluInfoHost_t          info,
+    size_t *                 internalDataInBytes,
+    size_t *                 workspaceInBytes);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpCcsrluBufferInfoHost(
+    cusolverSpHandle_t       handle,
+    int                      n,
+    int                      nnzA,
+    const cusparseMatDescr_t descrA,
+    const cuComplex *        csrValA,
+    const int *              csrRowPtrA,
+    const int *              csrColIndA,
+    csrluInfoHost_t          info,
+    size_t *                 internalDataInBytes,
+    size_t *                 workspaceInBytes);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpZcsrluBufferInfoHost(
+    cusolverSpHandle_t       handle,
+    int                      n,
+    int                      nnzA,
+    const cusparseMatDescr_t descrA,
+    const cuDoubleComplex *  csrValA,
+    const int *              csrRowPtrA,
+    const int *              csrColIndA,
+    csrluInfoHost_t          info,
+    size_t *                 internalDataInBytes,
+    size_t *                 workspaceInBytes);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpScsrluFactorHost(
+    cusolverSpHandle_t       handle,
+    int                      n,
+    int                      nnzA,
+    const cusparseMatDescr_t descrA,
+    const float *            csrValA,
+    const int *              csrRowPtrA,
+    const int *              csrColIndA,
+    csrluInfoHost_t          info,
+    float                    pivot_threshold,
+    void *                   pBuffer);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpDcsrluFactorHost(
+    cusolverSpHandle_t       handle,
+    int                      n,
+    int                      nnzA,
+    const cusparseMatDescr_t descrA,
+    const double *           csrValA,
+    const int *              csrRowPtrA,
+    const int *              csrColIndA,
+    csrluInfoHost_t          info,
+    double                   pivot_threshold,
+    void *                   pBuffer);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpCcsrluFactorHost(
+    cusolverSpHandle_t       handle,
+    int                      n,
+    int                      nnzA,
+    const cusparseMatDescr_t descrA,
+    const cuComplex *        csrValA,
+    const int *              csrRowPtrA,
+    const int *              csrColIndA,
+    csrluInfoHost_t          info,
+    float                    pivot_threshold,
+    void *                   pBuffer);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpZcsrluFactorHost(
+    cusolverSpHandle_t       handle,
+    int                      n,
+    int                      nnzA,
+    const cusparseMatDescr_t descrA,
+    const cuDoubleComplex *  csrValA,
+    const int *              csrRowPtrA,
+    const int *              csrColIndA,
+    csrluInfoHost_t          info,
+    double                   pivot_threshold,
+    void *                   pBuffer);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpScsrluZeroPivotHost(
+    cusolverSpHandle_t handle,
+    csrluInfoHost_t    info,
+    float              tol,
+    int *              position);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpDcsrluZeroPivotHost(
+    cusolverSpHandle_t handle,
+    csrluInfoHost_t    info,
+    double             tol,
+    int *              position);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpCcsrluZeroPivotHost(
+    cusolverSpHandle_t handle,
+    csrluInfoHost_t    info,
+    float              tol,
+    int *              position);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpZcsrluZeroPivotHost(
+    cusolverSpHandle_t handle,
+    csrluInfoHost_t    info,
+    double             tol,
+    int *              position);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpScsrluSolveHost(
+    cusolverSpHandle_t handle,
+    int                n,
+    const float *      b,
+    float *            x,
+    csrluInfoHost_t    info,
+    void *             pBuffer);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpDcsrluSolveHost(
+    cusolverSpHandle_t handle,
+    int                n,
+    const double *     b,
+    double *           x,
+    csrluInfoHost_t    info,
+    void *             pBuffer);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpCcsrluSolveHost(
+    cusolverSpHandle_t handle,
+    int                n,
+    const cuComplex *  b,
+    cuComplex *        x,
+    csrluInfoHost_t    info,
+    void *             pBuffer);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpZcsrluSolveHost(
+    cusolverSpHandle_t     handle,
+    int                    n,
+    const cuDoubleComplex *b,
+    cuDoubleComplex *      x,
+    csrluInfoHost_t        info,
+    void *                 pBuffer);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpXcsrluNnzHost(
+    cusolverSpHandle_t handle,
+    int *              nnzLRef,
+    int *              nnzURef,
+    csrluInfoHost_t    info);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpScsrluExtractHost(
+    cusolverSpHandle_t       handle,
+    int *                    P,
+    int *                    Q,
+    const cusparseMatDescr_t descrL,
+    float *                  csrValL,
+    int *                    csrRowPtrL,
+    int *                    csrColIndL,
+    const cusparseMatDescr_t descrU,
+    float *                  csrValU,
+    int *                    csrRowPtrU,
+    int *                    csrColIndU,
+    csrluInfoHost_t          info,
+    void *                   pBuffer);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpDcsrluExtractHost(
+    cusolverSpHandle_t       handle,
+    int *                    P,
+    int *                    Q,
+    const cusparseMatDescr_t descrL,
+    double *                 csrValL,
+    int *                    csrRowPtrL,
+    int *                    csrColIndL,
+    const cusparseMatDescr_t descrU,
+    double *                 csrValU,
+    int *                    csrRowPtrU,
+    int *                    csrColIndU,
+    csrluInfoHost_t          info,
+    void *                   pBuffer);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpCcsrluExtractHost(
+    cusolverSpHandle_t       handle,
+    int *                    P,
+    int *                    Q,
+    const cusparseMatDescr_t descrL,
+    cuComplex *              csrValL,
+    int *                    csrRowPtrL,
+    int *                    csrColIndL,
+    const cusparseMatDescr_t descrU,
+    cuComplex *              csrValU,
+    int *                    csrRowPtrU,
+    int *                    csrColIndU,
+    csrluInfoHost_t          info,
+    void *                   pBuffer);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpZcsrluExtractHost(
+    cusolverSpHandle_t       handle,
+    int *                    P,
+    int *                    Q,
+    const cusparseMatDescr_t descrL,
+    cuDoubleComplex *        csrValL,
+    int *                    csrRowPtrL,
+    int *                    csrColIndL,
+    const cusparseMatDescr_t descrU,
+    cuDoubleComplex *        csrValU,
+    int *                    csrRowPtrU,
+    int *                    csrColIndU,
+    csrluInfoHost_t          info,
+    void *                   pBuffer);
+
+  /*
+   * Low level API for CPU QR
+   *
+   */
+  cusolverStatus_t CUSOLVERAPI
+    cusolverSpCreateCsrqrInfoHost(csrqrInfoHost_t *info);
+
+  cusolverStatus_t CUSOLVERAPI
+    cusolverSpDestroyCsrqrInfoHost(csrqrInfoHost_t info);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpXcsrqrAnalysisHost(
+    cusolverSpHandle_t       handle,
+    int                      m,
+    int                      n,
+    int                      nnzA,
+    const cusparseMatDescr_t descrA,
+    const int *              csrRowPtrA,
+    const int *              csrColIndA,
+    csrqrInfoHost_t          info);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpScsrqrBufferInfoHost(
+    cusolverSpHandle_t       handle,
+    int                      m,
+    int                      n,
+    int                      nnzA,
+    const cusparseMatDescr_t descrA,
+    const float *            csrValA,
+    const int *              csrRowPtrA,
+    const int *              csrColIndA,
+    csrqrInfoHost_t          info,
+    size_t *                 internalDataInBytes,
+    size_t *                 workspaceInBytes);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpDcsrqrBufferInfoHost(
+    cusolverSpHandle_t       handle,
+    int                      m,
+    int                      n,
+    int                      nnzA,
+    const cusparseMatDescr_t descrA,
+    const double *           csrValA,
+    const int *              csrRowPtrA,
+    const int *              csrColIndA,
+    csrqrInfoHost_t          info,
+    size_t *                 internalDataInBytes,
+    size_t *                 workspaceInBytes);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpCcsrqrBufferInfoHost(
+    cusolverSpHandle_t       handle,
+    int                      m,
+    int                      n,
+    int                      nnzA,
+    const cusparseMatDescr_t descrA,
+    const cuComplex *        csrValA,
+    const int *              csrRowPtrA,
+    const int *              csrColIndA,
+    csrqrInfoHost_t          info,
+    size_t *                 internalDataInBytes,
+    size_t *                 workspaceInBytes);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpZcsrqrBufferInfoHost(
+    cusolverSpHandle_t       handle,
+    int                      m,
+    int                      n,
+    int                      nnzA,
+    const cusparseMatDescr_t descrA,
+    const cuDoubleComplex *  csrValA,
+    const int *              csrRowPtrA,
+    const int *              csrColIndA,
+    csrqrInfoHost_t          info,
+    size_t *                 internalDataInBytes,
+    size_t *                 workspaceInBytes);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpScsrqrSetupHost(
+    cusolverSpHandle_t       handle,
+    int                      m,
+    int                      n,
+    int                      nnzA,
+    const cusparseMatDescr_t descrA,
+    const float *            csrValA,
+    const int *              csrRowPtrA,
+    const int *              csrColIndA,
+    float                    mu,
+    csrqrInfoHost_t          info);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpDcsrqrSetupHost(
+    cusolverSpHandle_t       handle,
+    int                      m,
+    int                      n,
+    int                      nnzA,
+    const cusparseMatDescr_t descrA,
+    const double *           csrValA,
+    const int *              csrRowPtrA,
+    const int *              csrColIndA,
+    double                   mu,
+    csrqrInfoHost_t          info);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpCcsrqrSetupHost(
+    cusolverSpHandle_t       handle,
+    int                      m,
+    int                      n,
+    int                      nnzA,
+    const cusparseMatDescr_t descrA,
+    const cuComplex *        csrValA,
+    const int *              csrRowPtrA,
+    const int *              csrColIndA,
+    cuComplex                mu,
+    csrqrInfoHost_t          info);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpZcsrqrSetupHost(
+    cusolverSpHandle_t       handle,
+    int                      m,
+    int                      n,
+    int                      nnzA,
+    const cusparseMatDescr_t descrA,
+    const cuDoubleComplex *  csrValA,
+    const int *              csrRowPtrA,
+    const int *              csrColIndA,
+    cuDoubleComplex          mu,
+    csrqrInfoHost_t          info);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpScsrqrFactorHost(
+    cusolverSpHandle_t handle,
+    int                m,
+    int                n,
+    int                nnzA,
+    float *            b,
+    float *            x,
+    csrqrInfoHost_t    info,
+    void *             pBuffer);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpDcsrqrFactorHost(
+    cusolverSpHandle_t handle,
+    int                m,
+    int                n,
+    int                nnzA,
+    double *           b,
+    double *           x,
+    csrqrInfoHost_t    info,
+    void *             pBuffer);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpCcsrqrFactorHost(
+    cusolverSpHandle_t handle,
+    int                m,
+    int                n,
+    int                nnzA,
+    cuComplex *        b,
+    cuComplex *        x,
+    csrqrInfoHost_t    info,
+    void *             pBuffer);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpZcsrqrFactorHost(
+    cusolverSpHandle_t handle,
+    int                m,
+    int                n,
+    int                nnzA,
+    cuDoubleComplex *  b,
+    cuDoubleComplex *  x,
+    csrqrInfoHost_t    info,
+    void *             pBuffer);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpScsrqrZeroPivotHost(
+    cusolverSpHandle_t handle,
+    csrqrInfoHost_t    info,
+    float              tol,
+    int *              position);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpDcsrqrZeroPivotHost(
+    cusolverSpHandle_t handle,
+    csrqrInfoHost_t    info,
+    double             tol,
+    int *              position);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpCcsrqrZeroPivotHost(
+    cusolverSpHandle_t handle,
+    csrqrInfoHost_t    info,
+    float              tol,
+    int *              position);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpZcsrqrZeroPivotHost(
+    cusolverSpHandle_t handle,
+    csrqrInfoHost_t    info,
+    double             tol,
+    int *              position);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpScsrqrSolveHost(
+    cusolverSpHandle_t handle,
+    int                m,
+    int                n,
+    float *            b,
+    float *            x,
+    csrqrInfoHost_t    info,
+    void *             pBuffer);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpDcsrqrSolveHost(
+    cusolverSpHandle_t handle,
+    int                m,
+    int                n,
+    double *           b,
+    double *           x,
+    csrqrInfoHost_t    info,
+    void *             pBuffer);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpCcsrqrSolveHost(
+    cusolverSpHandle_t handle,
+    int                m,
+    int                n,
+    cuComplex *        b,
+    cuComplex *        x,
+    csrqrInfoHost_t    info,
+    void *             pBuffer);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpZcsrqrSolveHost(
+    cusolverSpHandle_t handle,
+    int                m,
+    int                n,
+    cuDoubleComplex *  b,
+    cuDoubleComplex *  x,
+    csrqrInfoHost_t    info,
+    void *             pBuffer);
+
+  /*
+   * Low level API for GPU QR
+   *
+   */
+  cusolverStatus_t CUSOLVERAPI cusolverSpXcsrqrAnalysis(
+    cusolverSpHandle_t       handle,
+    int                      m,
+    int                      n,
+    int                      nnzA,
+    const cusparseMatDescr_t descrA,
+    const int *              csrRowPtrA,
+    const int *              csrColIndA,
+    csrqrInfo_t              info);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpScsrqrBufferInfo(
+    cusolverSpHandle_t       handle,
+    int                      m,
+    int                      n,
+    int                      nnzA,
+    const cusparseMatDescr_t descrA,
+    const float *            csrValA,
+    const int *              csrRowPtrA,
+    const int *              csrColIndA,
+    csrqrInfo_t              info,
+    size_t *                 internalDataInBytes,
+    size_t *                 workspaceInBytes);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpDcsrqrBufferInfo(
+    cusolverSpHandle_t       handle,
+    int                      m,
+    int                      n,
+    int                      nnzA,
+    const cusparseMatDescr_t descrA,
+    const double *           csrValA,
+    const int *              csrRowPtrA,
+    const int *              csrColIndA,
+    csrqrInfo_t              info,
+    size_t *                 internalDataInBytes,
+    size_t *                 workspaceInBytes);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpCcsrqrBufferInfo(
+    cusolverSpHandle_t       handle,
+    int                      m,
+    int                      n,
+    int                      nnzA,
+    const cusparseMatDescr_t descrA,
+    const cuComplex *        csrValA,
+    const int *              csrRowPtrA,
+    const int *              csrColIndA,
+    csrqrInfo_t              info,
+    size_t *                 internalDataInBytes,
+    size_t *                 workspaceInBytes);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpZcsrqrBufferInfo(
+    cusolverSpHandle_t       handle,
+    int                      m,
+    int                      n,
+    int                      nnzA,
+    const cusparseMatDescr_t descrA,
+    const cuDoubleComplex *  csrValA,
+    const int *              csrRowPtrA,
+    const int *              csrColIndA,
+    csrqrInfo_t              info,
+    size_t *                 internalDataInBytes,
+    size_t *                 workspaceInBytes);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpScsrqrSetup(
+    cusolverSpHandle_t       handle,
+    int                      m,
+    int                      n,
+    int                      nnzA,
+    const cusparseMatDescr_t descrA,
+    const float *            csrValA,
+    const int *              csrRowPtrA,
+    const int *              csrColIndA,
+    float                    mu,
+    csrqrInfo_t              info);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpDcsrqrSetup(
+    cusolverSpHandle_t       handle,
+    int                      m,
+    int                      n,
+    int                      nnzA,
+    const cusparseMatDescr_t descrA,
+    const double *           csrValA,
+    const int *              csrRowPtrA,
+    const int *              csrColIndA,
+    double                   mu,
+    csrqrInfo_t              info);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpCcsrqrSetup(
+    cusolverSpHandle_t       handle,
+    int                      m,
+    int                      n,
+    int                      nnzA,
+    const cusparseMatDescr_t descrA,
+    const cuComplex *        csrValA,
+    const int *              csrRowPtrA,
+    const int *              csrColIndA,
+    cuComplex                mu,
+    csrqrInfo_t              info);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpZcsrqrSetup(
+    cusolverSpHandle_t       handle,
+    int                      m,
+    int                      n,
+    int                      nnzA,
+    const cusparseMatDescr_t descrA,
+    const cuDoubleComplex *  csrValA,
+    const int *              csrRowPtrA,
+    const int *              csrColIndA,
+    cuDoubleComplex          mu,
+    csrqrInfo_t              info);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpScsrqrFactor(
+    cusolverSpHandle_t handle,
+    int                m,
+    int                n,
+    int                nnzA,
+    float *            b,
+    float *            x,
+    csrqrInfo_t        info,
+    void *             pBuffer);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpDcsrqrFactor(
+    cusolverSpHandle_t handle,
+    int                m,
+    int                n,
+    int                nnzA,
+    double *           b,
+    double *           x,
+    csrqrInfo_t        info,
+    void *             pBuffer);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpCcsrqrFactor(
+    cusolverSpHandle_t handle,
+    int                m,
+    int                n,
+    int                nnzA,
+    cuComplex *        b,
+    cuComplex *        x,
+    csrqrInfo_t        info,
+    void *             pBuffer);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpZcsrqrFactor(
+    cusolverSpHandle_t handle,
+    int                m,
+    int                n,
+    int                nnzA,
+    cuDoubleComplex *  b,
+    cuDoubleComplex *  x,
+    csrqrInfo_t        info,
+    void *             pBuffer);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpScsrqrZeroPivot(
+    cusolverSpHandle_t handle,
+    csrqrInfo_t        info,
+    float              tol,
+    int *              position);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpDcsrqrZeroPivot(
+    cusolverSpHandle_t handle,
+    csrqrInfo_t        info,
+    double             tol,
+    int *              position);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpCcsrqrZeroPivot(
+    cusolverSpHandle_t handle,
+    csrqrInfo_t        info,
+    float              tol,
+    int *              position);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpZcsrqrZeroPivot(
+    cusolverSpHandle_t handle,
+    csrqrInfo_t        info,
+    double             tol,
+    int *              position);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpScsrqrSolve(
+    cusolverSpHandle_t handle,
+    int                m,
+    int                n,
+    float *            b,
+    float *            x,
+    csrqrInfo_t        info,
+    void *             pBuffer);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpDcsrqrSolve(
+    cusolverSpHandle_t handle,
+    int                m,
+    int                n,
+    double *           b,
+    double *           x,
+    csrqrInfo_t        info,
+    void *             pBuffer);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpCcsrqrSolve(
+    cusolverSpHandle_t handle,
+    int                m,
+    int                n,
+    cuComplex *        b,
+    cuComplex *        x,
+    csrqrInfo_t        info,
+    void *             pBuffer);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpZcsrqrSolve(
+    cusolverSpHandle_t handle,
+    int                m,
+    int                n,
+    cuDoubleComplex *  b,
+    cuDoubleComplex *  x,
+    csrqrInfo_t        info,
+    void *             pBuffer);
+
+  /*
+   * Low level API for CPU Cholesky
+   *
+   */
+  cusolverStatus_t CUSOLVERAPI
+    cusolverSpCreateCsrcholInfoHost(csrcholInfoHost_t *info);
+
+  cusolverStatus_t CUSOLVERAPI
+    cusolverSpDestroyCsrcholInfoHost(csrcholInfoHost_t info);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpXcsrcholAnalysisHost(
+    cusolverSpHandle_t       handle,
+    int                      n,
+    int                      nnzA,
+    const cusparseMatDescr_t descrA,
+    const int *              csrRowPtrA,
+    const int *              csrColIndA,
+    csrcholInfoHost_t        info);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpScsrcholBufferInfoHost(
+    cusolverSpHandle_t       handle,
+    int                      n,
+    int                      nnzA,
+    const cusparseMatDescr_t descrA,
+    const float *            csrValA,
+    const int *              csrRowPtrA,
+    const int *              csrColIndA,
+    csrcholInfoHost_t        info,
+    size_t *                 internalDataInBytes,
+    size_t *                 workspaceInBytes);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpDcsrcholBufferInfoHost(
+    cusolverSpHandle_t       handle,
+    int                      n,
+    int                      nnzA,
+    const cusparseMatDescr_t descrA,
+    const double *           csrValA,
+    const int *              csrRowPtrA,
+    const int *              csrColIndA,
+    csrcholInfoHost_t        info,
+    size_t *                 internalDataInBytes,
+    size_t *                 workspaceInBytes);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpCcsrcholBufferInfoHost(
+    cusolverSpHandle_t       handle,
+    int                      n,
+    int                      nnzA,
+    const cusparseMatDescr_t descrA,
+    const cuComplex *        csrValA,
+    const int *              csrRowPtrA,
+    const int *              csrColIndA,
+    csrcholInfoHost_t        info,
+    size_t *                 internalDataInBytes,
+    size_t *                 workspaceInBytes);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpZcsrcholBufferInfoHost(
+    cusolverSpHandle_t       handle,
+    int                      n,
+    int                      nnzA,
+    const cusparseMatDescr_t descrA,
+    const cuDoubleComplex *  csrValA,
+    const int *              csrRowPtrA,
+    const int *              csrColIndA,
+    csrcholInfoHost_t        info,
+    size_t *                 internalDataInBytes,
+    size_t *                 workspaceInBytes);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpScsrcholFactorHost(
+    cusolverSpHandle_t       handle,
+    int                      n,
+    int                      nnzA,
+    const cusparseMatDescr_t descrA,
+    const float *            csrValA,
+    const int *              csrRowPtrA,
+    const int *              csrColIndA,
+    csrcholInfoHost_t        info,
+    void *                   pBuffer);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpDcsrcholFactorHost(
+    cusolverSpHandle_t       handle,
+    int                      n,
+    int                      nnzA,
+    const cusparseMatDescr_t descrA,
+    const double *           csrValA,
+    const int *              csrRowPtrA,
+    const int *              csrColIndA,
+    csrcholInfoHost_t        info,
+    void *                   pBuffer);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpCcsrcholFactorHost(
+    cusolverSpHandle_t       handle,
+    int                      n,
+    int                      nnzA,
+    const cusparseMatDescr_t descrA,
+    const cuComplex *        csrValA,
+    const int *              csrRowPtrA,
+    const int *              csrColIndA,
+    csrcholInfoHost_t        info,
+    void *                   pBuffer);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpZcsrcholFactorHost(
+    cusolverSpHandle_t       handle,
+    int                      n,
+    int                      nnzA,
+    const cusparseMatDescr_t descrA,
+    const cuDoubleComplex *  csrValA,
+    const int *              csrRowPtrA,
+    const int *              csrColIndA,
+    csrcholInfoHost_t        info,
+    void *                   pBuffer);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpScsrcholZeroPivotHost(
+    cusolverSpHandle_t handle,
+    csrcholInfoHost_t  info,
+    float              tol,
+    int *              position);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpDcsrcholZeroPivotHost(
+    cusolverSpHandle_t handle,
+    csrcholInfoHost_t  info,
+    double             tol,
+    int *              position);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpCcsrcholZeroPivotHost(
+    cusolverSpHandle_t handle,
+    csrcholInfoHost_t  info,
+    float              tol,
+    int *              position);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpZcsrcholZeroPivotHost(
+    cusolverSpHandle_t handle,
+    csrcholInfoHost_t  info,
+    double             tol,
+    int *              position);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpScsrcholSolveHost(
+    cusolverSpHandle_t handle,
+    int                n,
+    const float *      b,
+    float *            x,
+    csrcholInfoHost_t  info,
+    void *             pBuffer);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpDcsrcholSolveHost(
+    cusolverSpHandle_t handle,
+    int                n,
+    const double *     b,
+    double *           x,
+    csrcholInfoHost_t  info,
+    void *             pBuffer);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpCcsrcholSolveHost(
+    cusolverSpHandle_t handle,
+    int                n,
+    const cuComplex *  b,
+    cuComplex *        x,
+    csrcholInfoHost_t  info,
+    void *             pBuffer);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpZcsrcholSolveHost(
+    cusolverSpHandle_t     handle,
+    int                    n,
+    const cuDoubleComplex *b,
+    cuDoubleComplex *      x,
+    csrcholInfoHost_t      info,
+    void *                 pBuffer);
+
+  /*
+   * Low level API for GPU Cholesky
+   *
+   */
+  cusolverStatus_t CUSOLVERAPI cusolverSpCreateCsrcholInfo(csrcholInfo_t *info);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpDestroyCsrcholInfo(csrcholInfo_t info);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpXcsrcholAnalysis(
+    cusolverSpHandle_t       handle,
+    int                      n,
+    int                      nnzA,
+    const cusparseMatDescr_t descrA,
+    const int *              csrRowPtrA,
+    const int *              csrColIndA,
+    csrcholInfo_t            info);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpScsrcholBufferInfo(
+    cusolverSpHandle_t       handle,
+    int                      n,
+    int                      nnzA,
+    const cusparseMatDescr_t descrA,
+    const float *            csrValA,
+    const int *              csrRowPtrA,
+    const int *              csrColIndA,
+    csrcholInfo_t            info,
+    size_t *                 internalDataInBytes,
+    size_t *                 workspaceInBytes);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpDcsrcholBufferInfo(
+    cusolverSpHandle_t       handle,
+    int                      n,
+    int                      nnzA,
+    const cusparseMatDescr_t descrA,
+    const double *           csrValA,
+    const int *              csrRowPtrA,
+    const int *              csrColIndA,
+    csrcholInfo_t            info,
+    size_t *                 internalDataInBytes,
+    size_t *                 workspaceInBytes);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpCcsrcholBufferInfo(
+    cusolverSpHandle_t       handle,
+    int                      n,
+    int                      nnzA,
+    const cusparseMatDescr_t descrA,
+    const cuComplex *        csrValA,
+    const int *              csrRowPtrA,
+    const int *              csrColIndA,
+    csrcholInfo_t            info,
+    size_t *                 internalDataInBytes,
+    size_t *                 workspaceInBytes);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpZcsrcholBufferInfo(
+    cusolverSpHandle_t       handle,
+    int                      n,
+    int                      nnzA,
+    const cusparseMatDescr_t descrA,
+    const cuDoubleComplex *  csrValA,
+    const int *              csrRowPtrA,
+    const int *              csrColIndA,
+    csrcholInfo_t            info,
+    size_t *                 internalDataInBytes,
+    size_t *                 workspaceInBytes);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpScsrcholFactor(
+    cusolverSpHandle_t       handle,
+    int                      n,
+    int                      nnzA,
+    const cusparseMatDescr_t descrA,
+    const float *            csrValA,
+    const int *              csrRowPtrA,
+    const int *              csrColIndA,
+    csrcholInfo_t            info,
+    void *                   pBuffer);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpDcsrcholFactor(
+    cusolverSpHandle_t       handle,
+    int                      n,
+    int                      nnzA,
+    const cusparseMatDescr_t descrA,
+    const double *           csrValA,
+    const int *              csrRowPtrA,
+    const int *              csrColIndA,
+    csrcholInfo_t            info,
+    void *                   pBuffer);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpCcsrcholFactor(
+    cusolverSpHandle_t       handle,
+    int                      n,
+    int                      nnzA,
+    const cusparseMatDescr_t descrA,
+    const cuComplex *        csrValA,
+    const int *              csrRowPtrA,
+    const int *              csrColIndA,
+    csrcholInfo_t            info,
+    void *                   pBuffer);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpZcsrcholFactor(
+    cusolverSpHandle_t       handle,
+    int                      n,
+    int                      nnzA,
+    const cusparseMatDescr_t descrA,
+    const cuDoubleComplex *  csrValA,
+    const int *              csrRowPtrA,
+    const int *              csrColIndA,
+    csrcholInfo_t            info,
+    void *                   pBuffer);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpScsrcholZeroPivot(
+    cusolverSpHandle_t handle,
+    csrcholInfo_t      info,
+    float              tol,
+    int *              position);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpDcsrcholZeroPivot(
+    cusolverSpHandle_t handle,
+    csrcholInfo_t      info,
+    double             tol,
+    int *              position);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpCcsrcholZeroPivot(
+    cusolverSpHandle_t handle,
+    csrcholInfo_t      info,
+    float              tol,
+    int *              position);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpZcsrcholZeroPivot(
+    cusolverSpHandle_t handle,
+    csrcholInfo_t      info,
+    double             tol,
+    int *              position);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpScsrcholSolve(
+    cusolverSpHandle_t handle,
+    int                n,
+    const float *      b,
+    float *            x,
+    csrcholInfo_t      info,
+    void *             pBuffer);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpDcsrcholSolve(
+    cusolverSpHandle_t handle,
+    int                n,
+    const double *     b,
+    double *           x,
+    csrcholInfo_t      info,
+    void *             pBuffer);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpCcsrcholSolve(
+    cusolverSpHandle_t handle,
+    int                n,
+    const cuComplex *  b,
+    cuComplex *        x,
+    csrcholInfo_t      info,
+    void *             pBuffer);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpZcsrcholSolve(
+    cusolverSpHandle_t     handle,
+    int                    n,
+    const cuDoubleComplex *b,
+    cuDoubleComplex *      x,
+    csrcholInfo_t          info,
+    void *                 pBuffer);
+
+  /*
+   * "diag" is a device array of size N.
+   * cusolverSp<t>csrcholDiag returns diag(L) to "diag" where A(P,P) = L*L**T
+   * "diag" can estimate det(A) because det(A(P,P)) = det(A) = det(L)^2 if A =
+   * L*L**T.
+   *
+   * cusolverSp<t>csrcholDiag must be called after cusolverSp<t>csrcholFactor.
+   * otherwise "diag" is wrong.
+   */
+  cusolverStatus_t CUSOLVERAPI cusolverSpScsrcholDiag(
+    cusolverSpHandle_t handle,
+    csrcholInfo_t      info,
+    float *            diag);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpDcsrcholDiag(
+    cusolverSpHandle_t handle,
+    csrcholInfo_t      info,
+    double *           diag);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpCcsrcholDiag(
+    cusolverSpHandle_t handle,
+    csrcholInfo_t      info,
+    float *            diag);
+
+  cusolverStatus_t CUSOLVERAPI cusolverSpZcsrcholDiag(
+    cusolverSpHandle_t handle,
+    csrcholInfo_t      info,
+    double *           diag);
+
+  #if defined(__cplusplus)
+}
+  #endif /* __cplusplus */
+
+#endif // CUSOLVERSP_LOWLEVEL_PREVIEW_H_

evalkit_tf449/lib/python3.10/site-packages/nvidia/cusolver/include/cusolver_common.h

@@ -0,0 +1,261 @@
+/*
+ * Copyright 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.
+ */
+
+#if !defined(CUSOLVER_COMMON_H_)
+  #define CUSOLVER_COMMON_H_
+
+  #include "library_types.h"
+
+  #ifndef CUSOLVERAPI
+    #ifdef _WIN32
+      #define CUSOLVERAPI __stdcall
+    #else
+      #define CUSOLVERAPI
+    #endif
+  #endif
+
+  #if defined(_MSC_VER)
+typedef __int64 int64_t;
+  #else
+    #include <inttypes.h>
+  #endif
+
+typedef int cusolver_int_t;
+
+  #define CUSOLVER_VER_MAJOR 11
+  #define CUSOLVER_VER_MINOR 6
+  #define CUSOLVER_VER_PATCH 1
+  #define CUSOLVER_VER_BUILD 9
+  #define CUSOLVER_VERSION                                                     \
+    (CUSOLVER_VER_MAJOR * 1000 + CUSOLVER_VER_MINOR * 100 + CUSOLVER_VER_PATCH)
+
+//------------------------------------------------------------------------------
+
+  #if !defined(_MSC_VER)
+    #define CUSOLVER_CPP_VERSION __cplusplus
+  #elif _MSC_FULL_VER >= 190024210 // Visual Studio 2015 Update 3
+    #define CUSOLVER_CPP_VERSION _MSVC_LANG
+  #else
+    #define CUSOLVER_CPP_VERSION 0
+  #endif
+
+//------------------------------------------------------------------------------
+
+  #if !defined(DISABLE_CUSOLVER_DEPRECATED)
+
+    #if CUSOLVER_CPP_VERSION >= 201402L
+
+      #define CUSOLVER_DEPRECATED(new_func)                                    \
+        [[deprecated("please use " #new_func " instead")]]
+
+    #elif defined(_MSC_VER)
+
+      #define CUSOLVER_DEPRECATED(new_func)                                    \
+        __declspec(deprecated("please use " #new_func " instead"))
+
+    #elif defined(__INTEL_COMPILER) || defined(__clang__) ||                   \
+      (defined(__GNUC__) &&                                                    \
+       (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5)))
+
+      #define CUSOLVER_DEPRECATED(new_func)                                    \
+        __attribute__((deprecated("please use " #new_func " instead")))
+
+    #elif defined(__GNUC__) || defined(__xlc__)
+
+      #define CUSOLVER_DEPRECATED(new_func) __attribute__((deprecated))
+
+    #else
+
+      #define CUSOLVER_DEPRECATED(new_func)
+
+    #endif // defined(__cplusplus) && __cplusplus >= 201402L
+  //------------------------------------------------------------------------------
+
+    #if CUSOLVER_CPP_VERSION >= 201703L
+
+      #define CUSOLVER_DEPRECATED_ENUM(new_enum)                               \
+        [[deprecated("please use " #new_enum " instead")]]
+
+    #elif defined(__clang__) ||                                                \
+      (defined(__GNUC__) && __GNUC__ >= 6 && !defined(__PGI))
+
+      #define CUSOLVER_DEPRECATED_ENUM(new_enum)                               \
+        __attribute__((deprecated("please use " #new_enum " instead")))
+
+    #else
+
+      #define CUSOLVER_DEPRECATED_ENUM(new_enum)
+
+    #endif // defined(__cplusplus) && __cplusplus >= 201402L
+
+  #else // defined(DISABLE_CUSOLVER_DEPRECATED)
+
+    #define CUSOLVER_DEPRECATED(new_func)
+    #define CUSOLVER_DEPRECATED_ENUM(new_enum)
+
+  #endif // !defined(DISABLE_CUSOLVER_DEPRECATED)
+
+  #undef CUSOLVER_CPP_VERSION
+
+  #if defined(__cplusplus)
+extern "C" {
+  #endif /* __cplusplus */
+
+  typedef enum {
+    CUSOLVER_STATUS_SUCCESS = 0,
+    CUSOLVER_STATUS_NOT_INITIALIZED = 1,
+    CUSOLVER_STATUS_ALLOC_FAILED = 2,
+    CUSOLVER_STATUS_INVALID_VALUE = 3,
+    CUSOLVER_STATUS_ARCH_MISMATCH = 4,
+    CUSOLVER_STATUS_MAPPING_ERROR = 5,
+    CUSOLVER_STATUS_EXECUTION_FAILED = 6,
+    CUSOLVER_STATUS_INTERNAL_ERROR = 7,
+    CUSOLVER_STATUS_MATRIX_TYPE_NOT_SUPPORTED = 8,
+    CUSOLVER_STATUS_NOT_SUPPORTED = 9,
+    CUSOLVER_STATUS_ZERO_PIVOT = 10,
+    CUSOLVER_STATUS_INVALID_LICENSE = 11,
+    CUSOLVER_STATUS_IRS_PARAMS_NOT_INITIALIZED = 12,
+    CUSOLVER_STATUS_IRS_PARAMS_INVALID = 13,
+    CUSOLVER_STATUS_IRS_PARAMS_INVALID_PREC = 14,
+    CUSOLVER_STATUS_IRS_PARAMS_INVALID_REFINE = 15,
+    CUSOLVER_STATUS_IRS_PARAMS_INVALID_MAXITER = 16,
+    CUSOLVER_STATUS_IRS_INTERNAL_ERROR = 20,
+    CUSOLVER_STATUS_IRS_NOT_SUPPORTED = 21,
+    CUSOLVER_STATUS_IRS_OUT_OF_RANGE = 22,
+    CUSOLVER_STATUS_IRS_NRHS_NOT_SUPPORTED_FOR_REFINE_GMRES = 23,
+    CUSOLVER_STATUS_IRS_INFOS_NOT_INITIALIZED = 25,
+    CUSOLVER_STATUS_IRS_INFOS_NOT_DESTROYED = 26,
+    CUSOLVER_STATUS_IRS_MATRIX_SINGULAR = 30,
+    CUSOLVER_STATUS_INVALID_WORKSPACE = 31
+  } cusolverStatus_t;
+
+  typedef enum {
+    CUSOLVER_EIG_TYPE_1 = 1,
+    CUSOLVER_EIG_TYPE_2 = 2,
+    CUSOLVER_EIG_TYPE_3 = 3
+  } cusolverEigType_t;
+
+  typedef enum {
+    CUSOLVER_EIG_MODE_NOVECTOR = 0,
+    CUSOLVER_EIG_MODE_VECTOR = 1
+  } cusolverEigMode_t;
+
+  typedef enum {
+    CUSOLVER_EIG_RANGE_ALL = 1001,
+    CUSOLVER_EIG_RANGE_I = 1002,
+    CUSOLVER_EIG_RANGE_V = 1003,
+  } cusolverEigRange_t;
+
+  typedef enum {
+    CUSOLVER_INF_NORM = 104,
+    CUSOLVER_MAX_NORM = 105,
+    CUSOLVER_ONE_NORM = 106,
+    CUSOLVER_FRO_NORM = 107,
+  } cusolverNorm_t;
+
+  typedef enum {
+    CUSOLVER_IRS_REFINE_NOT_SET = 1100,
+    CUSOLVER_IRS_REFINE_NONE = 1101,
+    CUSOLVER_IRS_REFINE_CLASSICAL = 1102,
+    CUSOLVER_IRS_REFINE_CLASSICAL_GMRES = 1103,
+    CUSOLVER_IRS_REFINE_GMRES = 1104,
+    CUSOLVER_IRS_REFINE_GMRES_GMRES = 1105,
+    CUSOLVER_IRS_REFINE_GMRES_NOPCOND = 1106,
+
+    CUSOLVER_PREC_DD = 1150,
+    CUSOLVER_PREC_SS = 1151,
+    CUSOLVER_PREC_SHT = 1152,
+
+  } cusolverIRSRefinement_t;
+
+  typedef enum {
+    CUSOLVER_R_8I = 1201,
+    CUSOLVER_R_8U = 1202,
+    CUSOLVER_R_64F = 1203,
+    CUSOLVER_R_32F = 1204,
+    CUSOLVER_R_16F = 1205,
+    CUSOLVER_R_16BF = 1206,
+    CUSOLVER_R_TF32 = 1207,
+    CUSOLVER_R_AP = 1208,
+    CUSOLVER_C_8I = 1211,
+    CUSOLVER_C_8U = 1212,
+    CUSOLVER_C_64F = 1213,
+    CUSOLVER_C_32F = 1214,
+    CUSOLVER_C_16F = 1215,
+    CUSOLVER_C_16BF = 1216,
+    CUSOLVER_C_TF32 = 1217,
+    CUSOLVER_C_AP = 1218,
+  } cusolverPrecType_t;
+
+  typedef enum {
+    CUSOLVER_ALG_0 = 0, /* default algorithm */
+    CUSOLVER_ALG_1 = 1,
+    CUSOLVER_ALG_2 = 2
+  } cusolverAlgMode_t;
+
+  typedef enum {
+    CUBLAS_STOREV_COLUMNWISE = 0,
+    CUBLAS_STOREV_ROWWISE = 1
+  } cusolverStorevMode_t;
+
+  typedef enum {
+    CUBLAS_DIRECT_FORWARD = 0,
+    CUBLAS_DIRECT_BACKWARD = 1
+  } cusolverDirectMode_t;
+
+  cusolverStatus_t CUSOLVERAPI
+    cusolverGetProperty(libraryPropertyType type, int *value);
+
+  cusolverStatus_t CUSOLVERAPI cusolverGetVersion(int *version);
+
+  #if defined(__cplusplus)
+}
+  #endif /* __cplusplus */
+
+#endif // CUSOLVER_COMMON_H_

evalkit_tf449/lib/python3.10/site-packages/nvidia/cusparse/include/cusparse_v2.h

@@ -0,0 +1,54 @@
+/*
+ * Copyright 1993-2019 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.
+ */
+#if !defined(CUSPARSE_V2_H_)
+#define CUSPARSE_V2_H_
+
+#include "cusparse.h"
+
+#endif

evalkit_tf449/lib/python3.10/site-packages/pandas/__init__.py

@@ -0,0 +1,367 @@
+from __future__ import annotations
+
+import os
+import warnings
+
+__docformat__ = "restructuredtext"
+
+# Let users know if they're missing any of our hard dependencies
+_hard_dependencies = ("numpy", "pytz", "dateutil")
+_missing_dependencies = []
+
+for _dependency in _hard_dependencies:
+    try:
+        __import__(_dependency)
+    except ImportError as _e:  # pragma: no cover
+        _missing_dependencies.append(f"{_dependency}: {_e}")
+
+if _missing_dependencies:  # pragma: no cover
+    raise ImportError(
+        "Unable to import required dependencies:\n" + "\n".join(_missing_dependencies)
+    )
+del _hard_dependencies, _dependency, _missing_dependencies
+
+try:
+    # numpy compat
+    from pandas.compat import (
+        is_numpy_dev as _is_numpy_dev,  # pyright: ignore[reportUnusedImport] # noqa: F401
+    )
+except ImportError as _err:  # pragma: no cover
+    _module = _err.name
+    raise ImportError(
+        f"C extension: {_module} not built. If you want to import "
+        "pandas from the source directory, you may need to run "
+        "'python setup.py build_ext' to build the C extensions first."
+    ) from _err
+
+from pandas._config import (
+    get_option,
+    set_option,
+    reset_option,
+    describe_option,
+    option_context,
+    options,
+)
+
+# let init-time option registration happen
+import pandas.core.config_init  # pyright: ignore[reportUnusedImport] # noqa: F401
+
+from pandas.core.api import (
+    # dtype
+    ArrowDtype,
+    Int8Dtype,
+    Int16Dtype,
+    Int32Dtype,
+    Int64Dtype,
+    UInt8Dtype,
+    UInt16Dtype,
+    UInt32Dtype,
+    UInt64Dtype,
+    Float32Dtype,
+    Float64Dtype,
+    CategoricalDtype,
+    PeriodDtype,
+    IntervalDtype,
+    DatetimeTZDtype,
+    StringDtype,
+    BooleanDtype,
+    # missing
+    NA,
+    isna,
+    isnull,
+    notna,
+    notnull,
+    # indexes
+    Index,
+    CategoricalIndex,
+    RangeIndex,
+    MultiIndex,
+    IntervalIndex,
+    TimedeltaIndex,
+    DatetimeIndex,
+    PeriodIndex,
+    IndexSlice,
+    # tseries
+    NaT,
+    Period,
+    period_range,
+    Timedelta,
+    timedelta_range,
+    Timestamp,
+    date_range,
+    bdate_range,
+    Interval,
+    interval_range,
+    DateOffset,
+    # conversion
+    to_numeric,
+    to_datetime,
+    to_timedelta,
+    # misc
+    Flags,
+    Grouper,
+    factorize,
+    unique,
+    value_counts,
+    NamedAgg,
+    array,
+    Categorical,
+    set_eng_float_format,
+    Series,
+    DataFrame,
+)
+
+from pandas.core.dtypes.dtypes import SparseDtype
+
+from pandas.tseries.api import infer_freq
+from pandas.tseries import offsets
+
+from pandas.core.computation.api import eval
+
+from pandas.core.reshape.api import (
+    concat,
+    lreshape,
+    melt,
+    wide_to_long,
+    merge,
+    merge_asof,
+    merge_ordered,
+    crosstab,
+    pivot,
+    pivot_table,
+    get_dummies,
+    from_dummies,
+    cut,
+    qcut,
+)
+
+from pandas import api, arrays, errors, io, plotting, tseries
+from pandas import testing
+from pandas.util._print_versions import show_versions
+
+from pandas.io.api import (
+    # excel
+    ExcelFile,
+    ExcelWriter,
+    read_excel,
+    # parsers
+    read_csv,
+    read_fwf,
+    read_table,
+    # pickle
+    read_pickle,
+    to_pickle,
+    # pytables
+    HDFStore,
+    read_hdf,
+    # sql
+    read_sql,
+    read_sql_query,
+    read_sql_table,
+    # misc
+    read_clipboard,
+    read_parquet,
+    read_orc,
+    read_feather,
+    read_gbq,
+    read_html,
+    read_xml,
+    read_json,
+    read_stata,
+    read_sas,
+    read_spss,
+)
+
+from pandas.io.json._normalize import json_normalize
+
+from pandas.util._tester import test
+
+# use the closest tagged version if possible
+_built_with_meson = False
+try:
+    from pandas._version_meson import (  # pyright: ignore [reportMissingImports]
+        __version__,
+        __git_version__,
+    )
+
+    _built_with_meson = True
+except ImportError:
+    from pandas._version import get_versions
+
+    v = get_versions()
+    __version__ = v.get("closest-tag", v["version"])
+    __git_version__ = v.get("full-revisionid")
+    del get_versions, v
+
+# GH#55043 - deprecation of the data_manager option
+if "PANDAS_DATA_MANAGER" in os.environ:
+    warnings.warn(
+        "The env variable PANDAS_DATA_MANAGER is set. The data_manager option is "
+        "deprecated and will be removed in a future version. Only the BlockManager "
+        "will be available. Unset this environment variable to silence this warning.",
+        FutureWarning,
+        stacklevel=2,
+    )
+
+del warnings, os
+
+# module level doc-string
+__doc__ = """
+pandas - a powerful data analysis and manipulation library for Python
+=====================================================================
+
+**pandas** is a Python package providing fast, flexible, and expressive data
+structures designed to make working with "relational" or "labeled" data both
+easy and intuitive. It aims to be the fundamental high-level building block for
+doing practical, **real world** data analysis in Python. Additionally, it has
+the broader goal of becoming **the most powerful and flexible open source data
+analysis / manipulation tool available in any language**. It is already well on
+its way toward this goal.
+
+Main Features
+-------------
+Here are just a few of the things that pandas does well:
+
+  - Easy handling of missing data in floating point as well as non-floating
+    point data.
+  - Size mutability: columns can be inserted and deleted from DataFrame and
+    higher dimensional objects
+  - Automatic and explicit data alignment: objects can be explicitly aligned
+    to a set of labels, or the user can simply ignore the labels and let
+    `Series`, `DataFrame`, etc. automatically align the data for you in
+    computations.
+  - Powerful, flexible group by functionality to perform split-apply-combine
+    operations on data sets, for both aggregating and transforming data.
+  - Make it easy to convert ragged, differently-indexed data in other Python
+    and NumPy data structures into DataFrame objects.
+  - Intelligent label-based slicing, fancy indexing, and subsetting of large
+    data sets.
+  - Intuitive merging and joining data sets.
+  - Flexible reshaping and pivoting of data sets.
+  - Hierarchical labeling of axes (possible to have multiple labels per tick).
+  - Robust IO tools for loading data from flat files (CSV and delimited),
+    Excel files, databases, and saving/loading data from the ultrafast HDF5
+    format.
+  - Time series-specific functionality: date range generation and frequency
+    conversion, moving window statistics, date shifting and lagging.
+"""
+
+# Use __all__ to let type checkers know what is part of the public API.
+# Pandas is not (yet) a py.typed library: the public API is determined
+# based on the documentation.
+__all__ = [
+    "ArrowDtype",
+    "BooleanDtype",
+    "Categorical",
+    "CategoricalDtype",
+    "CategoricalIndex",
+    "DataFrame",
+    "DateOffset",
+    "DatetimeIndex",
+    "DatetimeTZDtype",
+    "ExcelFile",
+    "ExcelWriter",
+    "Flags",
+    "Float32Dtype",
+    "Float64Dtype",
+    "Grouper",
+    "HDFStore",
+    "Index",
+    "IndexSlice",
+    "Int16Dtype",
+    "Int32Dtype",
+    "Int64Dtype",
+    "Int8Dtype",
+    "Interval",
+    "IntervalDtype",
+    "IntervalIndex",
+    "MultiIndex",
+    "NA",
+    "NaT",
+    "NamedAgg",
+    "Period",
+    "PeriodDtype",
+    "PeriodIndex",
+    "RangeIndex",
+    "Series",
+    "SparseDtype",
+    "StringDtype",
+    "Timedelta",
+    "TimedeltaIndex",
+    "Timestamp",
+    "UInt16Dtype",
+    "UInt32Dtype",
+    "UInt64Dtype",
+    "UInt8Dtype",
+    "api",
+    "array",
+    "arrays",
+    "bdate_range",
+    "concat",
+    "crosstab",
+    "cut",
+    "date_range",
+    "describe_option",
+    "errors",
+    "eval",
+    "factorize",
+    "get_dummies",
+    "from_dummies",
+    "get_option",
+    "infer_freq",
+    "interval_range",
+    "io",
+    "isna",
+    "isnull",
+    "json_normalize",
+    "lreshape",
+    "melt",
+    "merge",
+    "merge_asof",
+    "merge_ordered",
+    "notna",
+    "notnull",
+    "offsets",
+    "option_context",
+    "options",
+    "period_range",
+    "pivot",
+    "pivot_table",
+    "plotting",
+    "qcut",
+    "read_clipboard",
+    "read_csv",
+    "read_excel",
+    "read_feather",
+    "read_fwf",
+    "read_gbq",
+    "read_hdf",
+    "read_html",
+    "read_json",
+    "read_orc",
+    "read_parquet",
+    "read_pickle",
+    "read_sas",
+    "read_spss",
+    "read_sql",
+    "read_sql_query",
+    "read_sql_table",
+    "read_stata",
+    "read_table",
+    "read_xml",
+    "reset_option",
+    "set_eng_float_format",
+    "set_option",
+    "show_versions",
+    "test",
+    "testing",
+    "timedelta_range",
+    "to_datetime",
+    "to_numeric",
+    "to_pickle",
+    "to_timedelta",
+    "tseries",
+    "unique",
+    "value_counts",
+    "wide_to_long",
+]

evalkit_tf449/lib/python3.10/site-packages/pandas/_libs/__init__.py

@@ -0,0 +1,27 @@
+__all__ = [
+    "NaT",
+    "NaTType",
+    "OutOfBoundsDatetime",
+    "Period",
+    "Timedelta",
+    "Timestamp",
+    "iNaT",
+    "Interval",
+]
+
+
+# Below imports needs to happen first to ensure pandas top level
+# module gets monkeypatched with the pandas_datetime_CAPI
+# see pandas_datetime_exec in pd_datetime.c
+import pandas._libs.pandas_parser  # isort: skip # type: ignore[reportUnusedImport]
+import pandas._libs.pandas_datetime  # noqa: F401 # isort: skip # type: ignore[reportUnusedImport]
+from pandas._libs.interval import Interval
+from pandas._libs.tslibs import (
+    NaT,
+    NaTType,
+    OutOfBoundsDatetime,
+    Period,
+    Timedelta,
+    Timestamp,
+    iNaT,
+)