VSLRandomStream

class numpy::VSLRandomStream

numpy C++ class.

Example

#include <numpy/np_ndarray.h>
using namespace numpy;

// Create random generator
Generator gen(12345);  // seed

// Generate random values
auto uniform = gen.random({3, 3});
auto normal = gen.standard_normal({10});
auto integers = gen.integers(0, 100, {5});

Constructors

Signature	Location	Example
VSLRandomStream(uint32_tseed = 0)	NP_VSL_RANDOM.H:190
VSLRandomStream(const VSLRandomStream &)	NP_VSL_RANDOM.H:213
noexcept VSLRandomStream(VSLRandomStream &&other)	NP_VSL_RANDOM.H:216
VSLRandomStream(uint32_tseed = 0)	NP_VSL_RANDOM.H:2026
VSLRandomStream(const VSLRandomStream &)	NP_VSL_RANDOM.H:2033
VSLRandomStream(VSLRandomStream &&)	NP_VSL_RANDOM.H:2035

Operators

Signature	Return Type	Location	Example
VSLRandomStream & operator=(const VSLRandomStream &)	VSLRandomStream &	NP_VSL_RANDOM.H:214
VSLRandomStream & noexcept operator=(VSLRandomStream &&other)	VSLRandomStream & noexcept	NP_VSL_RANDOM.H:220
VSLRandomStream & operator=(const VSLRandomStream &)	VSLRandomStream &	NP_VSL_RANDOM.H:2034
VSLRandomStream & operator=(VSLRandomStream &&)	VSLRandomStream &	NP_VSL_RANDOM.H:2036

Array Creation

Signature	Return Type	Location	Example
void triangular(T \*buffer, size_tn, Tleft, Tmode, Tright)	void	NP_VSL_RANDOM.H:2231	View

Indexing / Selection

Signature	Return Type	Location	Example
VSLStreamStatePtr get_stream()	VSLStreamStatePtr	NP_VSL_RANDOM.H:1085

Math Operations

Signature	Return Type	Location	Example
void exponential(T \*buffer, size_tn, Tscale)	void	NP_VSL_RANDOM.H:621	View
void exponential(T \*buffer, size_tn, Tscale)	void	NP_VSL_RANDOM.H:2146	View
void exponential_f32(float \*buffer, size_tn, floatbeta)	void	NP_VSL_RANDOM.H:347
void exponential_f32(float \*buffer, size_tn, floatbeta)	void	NP_VSL_RANDOM.H:2068
void exponential_f64(double \*buffer, size_tn, doublebeta)	void	NP_VSL_RANDOM.H:361
void exponential_f64(double \*buffer, size_tn, doublebeta)	void	NP_VSL_RANDOM.H:2072
void lognormal(T \*buffer, size_tn, Tmean, Tsigma)	void	NP_VSL_RANDOM.H:709	View
void lognormal(T \*buffer, size_tn, Tmean, Tsigma)	void	NP_VSL_RANDOM.H:2186	View
void lognormal_f32(float \*buffer, size_tn, floatmean, floatsigma)	void	NP_VSL_RANDOM.H:584
void lognormal_f32(float \*buffer, size_tn, floatmean, floatsigma)	void	NP_VSL_RANDOM.H:2132
void lognormal_f64(double \*buffer, size_tn, doublemean, doublesigma)	void	NP_VSL_RANDOM.H:599
void lognormal_f64(double \*buffer, size_tn, doublemean, doublesigma)	void	NP_VSL_RANDOM.H:2136
void negative_binomial(T \*buffer, size_tn, doublea, doublep)	void	NP_VSL_RANDOM.H:885	View
void negative_binomial(T \*buffer, size_tn, doublea, doublep)	void	NP_VSL_RANDOM.H:2206	View
void negative_binomial_i32(int \*buffer, size_tn, doublea, doublep)	void	NP_VSL_RANDOM.H:862

Linear Algebra

Signature	Return Type	Location	Example
void normal(T \*buffer, size_tn, Tloc, Tscale)	void	NP_VSL_RANDOM.H:610	View
void normal(T \*buffer, size_tn, Tloc, Tscale)	void	NP_VSL_RANDOM.H:2141	View
void normal_f32(float \*buffer, size_tn, floatloc, floatscale)	void	NP_VSL_RANDOM.H:318
void normal_f32(float \*buffer, size_tn, floatloc, floatscale)	void	NP_VSL_RANDOM.H:2060
void normal_f64(double \*buffer, size_tn, doubleloc, doublescale)	void	NP_VSL_RANDOM.H:333
void normal_f64(double \*buffer, size_tn, doubleloc, doublescale)	void	NP_VSL_RANDOM.H:2064

Random

Signature	Return Type	Location	Example
void beta(T \*buffer, size_tn, Talpha, Tbeta_param)	void	NP_VSL_RANDOM.H:643	View
void beta(T \*buffer, size_tn, Talpha, Tbeta_param)	void	NP_VSL_RANDOM.H:2156	View
void beta_f32(float \*buffer, size_tn, floatalpha, floatbeta)	void	NP_VSL_RANDOM.H:406
void beta_f32(float \*buffer, size_tn, floatalpha, floatbeta)	void	NP_VSL_RANDOM.H:2084
void beta_f64(double \*buffer, size_tn, doublealpha, doublebeta)	void	NP_VSL_RANDOM.H:421
void beta_f64(double \*buffer, size_tn, doublealpha, doublebeta)	void	NP_VSL_RANDOM.H:2088
void binomial(T \*buffer, size_tn, intntrial, doublep)	void	NP_VSL_RANDOM.H:750	View
void binomial(T \*buffer, size_tn, intntrial, doublep)	void	NP_VSL_RANDOM.H:2191	View
void binomial_i32(int \*buffer, size_tn, intntrial, doublep)	void	NP_VSL_RANDOM.H:727
void chisquare(T \*buffer, size_tn, doubledf)	void	NP_VSL_RANDOM.H:993	View
void chisquare(T \*buffer, size_tn, doubledf)	void	NP_VSL_RANDOM.H:2216	View
void chisquare_f32(float \*buffer, size_tn, floatdf)	void	NP_VSL_RANDOM.H:955
void chisquare_f64(double \*buffer, size_tn, doubledf)	void	NP_VSL_RANDOM.H:974
void gamma(T \*buffer, size_tn, Talpha, Tbeta)	void	NP_VSL_RANDOM.H:632	View
void gamma(T \*buffer, size_tn, Talpha, Tbeta)	void	NP_VSL_RANDOM.H:2151	View
void gamma_f32(float \*buffer, size_tn, floatalpha, floatbeta)	void	NP_VSL_RANDOM.H:376
void gamma_f32(float \*buffer, size_tn, floatalpha, floatbeta)	void	NP_VSL_RANDOM.H:2076
void gamma_f64(double \*buffer, size_tn, doublealpha, doublebeta)	void	NP_VSL_RANDOM.H:391
void gamma_f64(double \*buffer, size_tn, doublealpha, doublebeta)	void	NP_VSL_RANDOM.H:2080
void poisson(T \*buffer, size_tn, doublelambda)	void	NP_VSL_RANDOM.H:791	View
void poisson(T \*buffer, size_tn, doublelambda)	void	NP_VSL_RANDOM.H:2196	View
void poisson_i32(int \*buffer, size_tn, doublelambda)	void	NP_VSL_RANDOM.H:772
void seed(uint32_tseed)	void	NP_VSL_RANDOM.H:235	View
void seed(uint32_tseed)	void	NP_VSL_RANDOM.H:2038	View
void uniform(T \*buffer, size_tn, Tlow, Thigh)	void	NP_VSL_RANDOM.H:298	View
void uniform(T \*buffer, size_tn, Tlow, Thigh)	void	NP_VSL_RANDOM.H:2054	View
int uniform_bits32(uint32_t \*buffer, MKL_INTn)	int	NP_VSL_RANDOM.H:1065
int uniform_bits64(uint64_t \*buffer, MKL_INTn)	int	NP_VSL_RANDOM.H:1076
void uniform_f32(float \*buffer, size_tn, floatlow, floathigh)	void	NP_VSL_RANDOM.H:253
void uniform_f32(float \*buffer, size_tn, floatlow, floathigh)	void	NP_VSL_RANDOM.H:2042
void uniform_f64(double \*buffer, size_tn, doublelow, doublehigh)	void	NP_VSL_RANDOM.H:268	View
void uniform_f64(double \*buffer, size_tn, doublelow, doublehigh)	void	NP_VSL_RANDOM.H:2046	View
void uniform_i32(int \*buffer, size_tn, intlow, inthigh)	void	NP_VSL_RANDOM.H:283
void uniform_i32(int \*buffer, size_tn, intlow, inthigh)	void	NP_VSL_RANDOM.H:2050

Other Methods

Signature	Return Type	Location	Example
void cauchy(T \*buffer, size_tn, Tloc, Tscale)	void	NP_VSL_RANDOM.H:687	View
void cauchy(T \*buffer, size_tn, Tloc, Tscale)	void	NP_VSL_RANDOM.H:2176	View
void cauchy_f32(float \*buffer, size_tn, floatloc, floatscale)	void	NP_VSL_RANDOM.H:524
void cauchy_f32(float \*buffer, size_tn, floatloc, floatscale)	void	NP_VSL_RANDOM.H:2116
void cauchy_f64(double \*buffer, size_tn, doubleloc, doublescale)	void	NP_VSL_RANDOM.H:539
void cauchy_f64(double \*buffer, size_tn, doubleloc, doublescale)	void	NP_VSL_RANDOM.H:2120
void f_dist(T \*buffer, size_tn, doubledfnum, doubledfden)	void	NP_VSL_RANDOM.H:2226
void geometric(T \*buffer, size_tn, doublep)	void	NP_VSL_RANDOM.H:839	View
void geometric(T \*buffer, size_tn, doublep)	void	NP_VSL_RANDOM.H:2201	View
void geometric_i32(int \*buffer, size_tn, doublep)	void	NP_VSL_RANDOM.H:813
void gumbel(T \*buffer, size_tn, Tloc, Tscale)	void	NP_VSL_RANDOM.H:698	View
void gumbel(T \*buffer, size_tn, Tloc, Tscale)	void	NP_VSL_RANDOM.H:2181	View
void gumbel_f32(float \*buffer, size_tn, floatloc, floatscale)	void	NP_VSL_RANDOM.H:554
void gumbel_f32(float \*buffer, size_tn, floatloc, floatscale)	void	NP_VSL_RANDOM.H:2124
void gumbel_f64(double \*buffer, size_tn, doubleloc, doublescale)	void	NP_VSL_RANDOM.H:569
void gumbel_f64(double \*buffer, size_tn, doubleloc, doublescale)	void	NP_VSL_RANDOM.H:2128
void hypergeometric(T \*buffer, size_tn, intl, ints, intm)	void	NP_VSL_RANDOM.H:933	View
void hypergeometric(T \*buffer, size_tn, intl, ints, intm)	void	NP_VSL_RANDOM.H:2211	View
void hypergeometric_i32(int \*buffer, size_tn, intl, ints, intm)	void	NP_VSL_RANDOM.H:909
void laplace(T \*buffer, size_tn, Tloc, Tscale)	void	NP_VSL_RANDOM.H:654	View
void laplace(T \*buffer, size_tn, Tloc, Tscale)	void	NP_VSL_RANDOM.H:2161	View
void laplace_f32(float \*buffer, size_tn, floatloc, floatscale)	void	NP_VSL_RANDOM.H:436
void laplace_f32(float \*buffer, size_tn, floatloc, floatscale)	void	NP_VSL_RANDOM.H:2092
void laplace_f64(double \*buffer, size_tn, doubleloc, doublescale)	void	NP_VSL_RANDOM.H:451
void laplace_f64(double \*buffer, size_tn, doubleloc, doublescale)	void	NP_VSL_RANDOM.H:2096
int multinomial(int \*buffer, MKL_INTn, intntrial, intk, const double \*p)	int	NP_VSL_RANDOM.H:1019	View
int multivariate_normal(float \*buffer, MKL_INTn, intdimen, const float \*mean, const float \*chol_factor)	int	NP_VSL_RANDOM.H:1034	View
int multivariate_normal(double \*buffer, MKL_INTn, intdimen, const double \*mean, const double \*chol_factor)	int	NP_VSL_RANDOM.H:1051	View
void rayleigh(T \*buffer, size_tn, Tsigma)	void	NP_VSL_RANDOM.H:665	View
void rayleigh(T \*buffer, size_tn, Tsigma)	void	NP_VSL_RANDOM.H:2166	View
void rayleigh_f32(float \*buffer, size_tn, floatsigma)	void	NP_VSL_RANDOM.H:465
void rayleigh_f32(float \*buffer, size_tn, floatsigma)	void	NP_VSL_RANDOM.H:2100
void rayleigh_f64(double \*buffer, size_tn, doublesigma)	void	NP_VSL_RANDOM.H:479
void rayleigh_f64(double \*buffer, size_tn, doublesigma)	void	NP_VSL_RANDOM.H:2104
void student_t(T \*buffer, size_tn, doubledf)	void	NP_VSL_RANDOM.H:2221
void weibull(T \*buffer, size_tn, Talpha, Tbeta)	void	NP_VSL_RANDOM.H:676	View
void weibull(T \*buffer, size_tn, Talpha, Tbeta)	void	NP_VSL_RANDOM.H:2171	View
void weibull_f32(float \*buffer, size_tn, floatalpha, floatbeta)	void	NP_VSL_RANDOM.H:494
void weibull_f32(float \*buffer, size_tn, floatalpha, floatbeta)	void	NP_VSL_RANDOM.H:2108
void weibull_f64(double \*buffer, size_tn, doublealpha, doublebeta)	void	NP_VSL_RANDOM.H:509
void weibull_f64(double \*buffer, size_tn, doublealpha, doublebeta)	void	NP_VSL_RANDOM.H:2112

Code Examples

The following examples are extracted from the test suite.

triangular (np_test_1_all.cpp:22034)

    for (size_t i = 0; i < 3; ++i) {
      if (!(lognormal_arr.getElementAt({ i }) > 0.0)) {
          std::string description = std::string("testContinuousDistributions():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(lognormal_arr.getElementAt({ i }) > 0.0)";
          std::cout << std::string("[FAIL] ") + description << std::endl;
          throw std::runtime_error(description);
      }
    }
    // std::cout << "[OK] Log-normal distribution\n";

    // Test triangular distribution
    auto triangular_arr = triangular<double>(0.0, 0.5, 1.0, { {3} });
    for (size_t i = 0; i < 3; ++i) {
      double val = triangular_arr.getElementAt({ i });
      if (!(val >= 0.0 && val <= 1.0)) {
          std::string description = std::string("testContinuousDistributions():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(val >= 0.0 && val <= 1.0)";
          std::cout << std::string("[FAIL] ") + description << std::endl;
          throw std::runtime_error(description);
      }
    }
    // std::cout << "[OK] Triangular distribution\n";

exponential (np_test_1_all.cpp:8006)

void testComplex256PrecisionComplex256() {
    std::cout << "========= testComplex256PrecisionComplex256 =======================";

    // Test high precision calculations
    complex256 high_precision(1.234567890123456789012345L, 9.876543210987654321098765L);

    // std::cout << std::setprecision(20);
    // std::cout << "High precision complex: " << high_precision << std::endl;

    // Test complex exponential (Euler's formula: e^(ix) = cos(x) + i*sin(x))
    complex256 i_pi(0.0L, 3.141592653589793238462643383279502884197L);  // i*π
    auto euler = std::exp(i_pi);
    // std::cout << "e^(iπ) = " << euler << " (should be approximately -1)" << std::endl;

    // Test complex roots
    complex256 unity_root = std::exp(complex256(0.0L, 2.0L * 3.141592653589793238462643383279502884197L / 3.0L));
    // std::cout << "Cube root of unity: " << unity_root << std::endl;
    // std::cout << "Cubed: " << unity_root * unity_root * unity_root << " (should be ≈ 1)" << std::endl;

    // std::cout << std::setprecision(6);  // Reset precision

exponential (np_test_1_all.cpp:8006)

void testComplex256PrecisionComplex256() {
    std::cout << "========= testComplex256PrecisionComplex256 =======================";

    // Test high precision calculations
    complex256 high_precision(1.234567890123456789012345L, 9.876543210987654321098765L);

    // std::cout << std::setprecision(20);
    // std::cout << "High precision complex: " << high_precision << std::endl;

    // Test complex exponential (Euler's formula: e^(ix) = cos(x) + i*sin(x))
    complex256 i_pi(0.0L, 3.141592653589793238462643383279502884197L);  // i*π
    auto euler = std::exp(i_pi);
    // std::cout << "e^(iπ) = " << euler << " (should be approximately -1)" << std::endl;

    // Test complex roots
    complex256 unity_root = std::exp(complex256(0.0L, 2.0L * 3.141592653589793238462643383279502884197L / 3.0L));
    // std::cout << "Cube root of unity: " << unity_root << std::endl;
    // std::cout << "Cubed: " << unity_root * unity_root * unity_root << " (should be ≈ 1)" << std::endl;

    // std::cout << std::setprecision(6);  // Reset precision

lognormal (np_test_1_all.cpp:14134)

    }
    // std::cout << "[OK] Beta distribution float precision\n";

    std::cout << " -> tests passed\n";
  }

  void test_vsl_additional_distributions() {
    std::cout << "========= test_vsl_additional_distributions ====";

    // Test lognormal distribution
    auto lognorm_arr = lognormal<double>(0.0, 1.0, { {100} });
    for (size_t i = 0; i < 100; ++i) {
      double val = lognorm_arr.getElementAt({ i });
      if (!(val > 0.0)) {
          std::string description = std::string("test_vsl_additional_distributions():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(val > 0.0)";
          std::cout << std::string("[FAIL] ") + description << std::endl;
          throw std::runtime_error(description);
      }
      if (!(val < 100.0)) {
          std::string description = std::string("test_vsl_additional_distributions():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(val < 100.0)";
          std::cout << std::string("[FAIL] ") + description << std::endl;

lognormal (np_test_1_all.cpp:14134)

    }
    // std::cout << "[OK] Beta distribution float precision\n";

    std::cout << " -> tests passed\n";
  }

  void test_vsl_additional_distributions() {
    std::cout << "========= test_vsl_additional_distributions ====";

    // Test lognormal distribution
    auto lognorm_arr = lognormal<double>(0.0, 1.0, { {100} });
    for (size_t i = 0; i < 100; ++i) {
      double val = lognorm_arr.getElementAt({ i });
      if (!(val > 0.0)) {
          std::string description = std::string("test_vsl_additional_distributions():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(val > 0.0)";
          std::cout << std::string("[FAIL] ") + description << std::endl;
          throw std::runtime_error(description);
      }
      if (!(val < 100.0)) {
          std::string description = std::string("test_vsl_additional_distributions():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(val < 100.0)";
          std::cout << std::string("[FAIL] ") + description << std::endl;

negative_binomial (np_test_1_all.cpp:22127)

      int val = binom_arr.getElementAt({ i });
      if (!(val >= 0 && val <= 20)) {
          std::string description = std::string("testDiscreteDistributions():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(val >= 0 && val <= 20)";
          std::cout << std::string("[FAIL] ") + description << std::endl;
          throw std::runtime_error(description);
      }
    }
    // std::cout << "[OK] Binomial distribution\n";

    // Test negative binomial distribution
    auto negbinom_arr = negative_binomial<int>(10, 0.3, { {3} });
    if (!(negbinom_arr.getShape()[0] == 3)) {
        std::string description = std::string("testDiscreteDistributions():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(negbinom_arr.getShape()[0] == 3)";
        std::cout << std::string("[FAIL] ") + description << std::endl;
        throw std::runtime_error(description);
    }
    for (size_t i = 0; i < 3; ++i) {
      if (!(negbinom_arr.getElementAt({ i }) >= 0)) {
          std::string description = std::string("testDiscreteDistributions():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(negbinom_arr.getElementAt({ i }) >= 0)";
          std::cout << std::string("[FAIL] ") + description << std::endl;
          throw std::runtime_error(description);

negative_binomial (np_test_1_all.cpp:22127)

      int val = binom_arr.getElementAt({ i });
      if (!(val >= 0 && val <= 20)) {
          std::string description = std::string("testDiscreteDistributions():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(val >= 0 && val <= 20)";
          std::cout << std::string("[FAIL] ") + description << std::endl;
          throw std::runtime_error(description);
      }
    }
    // std::cout << "[OK] Binomial distribution\n";

    // Test negative binomial distribution
    auto negbinom_arr = negative_binomial<int>(10, 0.3, { {3} });
    if (!(negbinom_arr.getShape()[0] == 3)) {
        std::string description = std::string("testDiscreteDistributions():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(negbinom_arr.getShape()[0] == 3)";
        std::cout << std::string("[FAIL] ") + description << std::endl;
        throw std::runtime_error(description);
    }
    for (size_t i = 0; i < 3; ++i) {
      if (!(negbinom_arr.getElementAt({ i }) >= 0)) {
          std::string description = std::string("testDiscreteDistributions():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(negbinom_arr.getElementAt({ i }) >= 0)";
          std::cout << std::string("[FAIL] ") + description << std::endl;
          throw std::runtime_error(description);

normal (np_test_1_all.cpp:13866)

#include "../numpy/np_random.h"

namespace numpy_tests {

  using namespace numpy::random;

  void test_vsl_normal_distribution() {
    std::cout << "========= test_vsl_normal_distribution ====";

    // Test basic normal distribution
    auto norm_arr = normal<double>(0.0, 1.0, { {100} });
    if (!(norm_arr.getShape()[0] == 100)) {
        std::string description = std::string("test_vsl_normal_distribution():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(norm_arr.getShape()[0] == 100)";
        std::cout << std::string("[FAIL] ") + description << std::endl;
        throw std::runtime_error(description);
    }

    // Check that values are reasonable for standard normal
    double sum = 0.0, sum_sq = 0.0;
    for (size_t i = 0; i < 100; ++i) {
      double val = norm_arr.getElementAt({ i });

normal (np_test_1_all.cpp:13866)

#include "../numpy/np_random.h"

namespace numpy_tests {

  using namespace numpy::random;

  void test_vsl_normal_distribution() {
    std::cout << "========= test_vsl_normal_distribution ====";

    // Test basic normal distribution
    auto norm_arr = normal<double>(0.0, 1.0, { {100} });
    if (!(norm_arr.getShape()[0] == 100)) {
        std::string description = std::string("test_vsl_normal_distribution():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(norm_arr.getShape()[0] == 100)";
        std::cout << std::string("[FAIL] ") + description << std::endl;
        throw std::runtime_error(description);
    }

    // Check that values are reasonable for standard normal
    double sum = 0.0, sum_sq = 0.0;
    for (size_t i = 0; i < 100; ++i) {
      double val = norm_arr.getElementAt({ i });

beta (np_test_1_all.cpp:10394)

    NDArray<double> beta_a({ 4 });
    NDArray<double> beta_b({ 4 });
    beta_a.setElementAt({ 0 }, 1.0);
    beta_a.setElementAt({ 1 }, 2.0);
    beta_a.setElementAt({ 2 }, 1.0);
    beta_a.setElementAt({ 3 }, 2.0);
    beta_b.setElementAt({ 0 }, 1.0);
    beta_b.setElementAt({ 1 }, 1.0);
    beta_b.setElementAt({ 2 }, 2.0);
    beta_b.setElementAt({ 3 }, 2.0);
    auto beta_result = special::beta(beta_a, beta_b, MathBackend::MKL);

    if (!(isApproxEqual(beta_result.getElementAt({ 0 }), 1.0, 1e-10))) {
        std::string description = std::string("testGammaFunctions():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(isApproxEqual(beta_result.getElementAt({ 0 }), 1.0, 1e-10))";
        std::cout << std::string("[FAIL] ") + description << std::endl;
        throw std::runtime_error(description);
    }
    if (!(isApproxEqual(beta_result.getElementAt({ 1 }), 0.5, 1e-10))) {
        std::string description = std::string("testGammaFunctions():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(isApproxEqual(beta_result.getElementAt({ 1 }), 0.5, 1e-10))";
        std::cout << std::string("[FAIL] ") + description << std::endl;
        throw std::runtime_error(description);

beta (np_test_1_all.cpp:10394)

    NDArray<double> beta_a({ 4 });
    NDArray<double> beta_b({ 4 });
    beta_a.setElementAt({ 0 }, 1.0);
    beta_a.setElementAt({ 1 }, 2.0);
    beta_a.setElementAt({ 2 }, 1.0);
    beta_a.setElementAt({ 3 }, 2.0);
    beta_b.setElementAt({ 0 }, 1.0);
    beta_b.setElementAt({ 1 }, 1.0);
    beta_b.setElementAt({ 2 }, 2.0);
    beta_b.setElementAt({ 3 }, 2.0);
    auto beta_result = special::beta(beta_a, beta_b, MathBackend::MKL);

    if (!(isApproxEqual(beta_result.getElementAt({ 0 }), 1.0, 1e-10))) {
        std::string description = std::string("testGammaFunctions():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(isApproxEqual(beta_result.getElementAt({ 0 }), 1.0, 1e-10))";
        std::cout << std::string("[FAIL] ") + description << std::endl;
        throw std::runtime_error(description);
    }
    if (!(isApproxEqual(beta_result.getElementAt({ 1 }), 0.5, 1e-10))) {
        std::string description = std::string("testGammaFunctions():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(isApproxEqual(beta_result.getElementAt({ 1 }), 0.5, 1e-10))";
        std::cout << std::string("[FAIL] ") + description << std::endl;
        throw std::runtime_error(description);

binomial (np_test_1_all.cpp:22110)

    for (size_t i = 0; i < 4; ++i) {
      if (!(geom_arr.getElementAt({ i }) >= 1)) {
          std::string description = std::string("testDiscreteDistributions():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(geom_arr.getElementAt({ i }) >= 1)";
          std::cout << std::string("[FAIL] ") + description << std::endl;
          throw std::runtime_error(description);
      }
    }
    // std::cout << "[OK] Geometric distribution\n";

    // Test binomial distribution
    auto binom_arr = binomial<int>(20, 0.3, { {5} });
    if (!(binom_arr.getShape()[0] == 5)) {
        std::string description = std::string("testDiscreteDistributions():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(binom_arr.getShape()[0] == 5)";
        std::cout << std::string("[FAIL] ") + description << std::endl;
        throw std::runtime_error(description);
    }
    for (size_t i = 0; i < 5; ++i) {
      int val = binom_arr.getElementAt({ i });
      if (!(val >= 0 && val <= 20)) {
          std::string description = std::string("testDiscreteDistributions():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(val >= 0 && val <= 20)";
          std::cout << std::string("[FAIL] ") + description << std::endl;

binomial (np_test_1_all.cpp:22110)

    for (size_t i = 0; i < 4; ++i) {
      if (!(geom_arr.getElementAt({ i }) >= 1)) {
          std::string description = std::string("testDiscreteDistributions():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(geom_arr.getElementAt({ i }) >= 1)";
          std::cout << std::string("[FAIL] ") + description << std::endl;
          throw std::runtime_error(description);
      }
    }
    // std::cout << "[OK] Geometric distribution\n";

    // Test binomial distribution
    auto binom_arr = binomial<int>(20, 0.3, { {5} });
    if (!(binom_arr.getShape()[0] == 5)) {
        std::string description = std::string("testDiscreteDistributions():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(binom_arr.getShape()[0] == 5)";
        std::cout << std::string("[FAIL] ") + description << std::endl;
        throw std::runtime_error(description);
    }
    for (size_t i = 0; i < 5; ++i) {
      int val = binom_arr.getElementAt({ i });
      if (!(val >= 0 && val <= 20)) {
          std::string description = std::string("testDiscreteDistributions():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(val >= 0 && val <= 20)";
          std::cout << std::string("[FAIL] ") + description << std::endl;

chisquare (np_test_1_all.cpp:21974)

#include <algorithm>
#include "../numpy/np_random.h"
namespace numpy_tests {

  using namespace numpy::random;

  void testContinuousDistributions() {
    std::cout << "========= testContinuousDistributions ====";

    // Test chi-square distribution
    auto chi2_arr = chisquare<double>(3.0, { {2, 3} });
    if (!(chi2_arr.getShape()[0] == 2)) {
        std::string description = std::string("testContinuousDistributions():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(chi2_arr.getShape()[0] == 2)";
        std::cout << std::string("[FAIL] ") + description << std::endl;
        throw std::runtime_error(description);
    }
    if (!(chi2_arr.getShape()[1] == 3)) {
        std::string description = std::string("testContinuousDistributions():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(chi2_arr.getShape()[1] == 3)";
        std::cout << std::string("[FAIL] ") + description << std::endl;
        throw std::runtime_error(description);
    }

chisquare (np_test_1_all.cpp:21974)

#include <algorithm>
#include "../numpy/np_random.h"
namespace numpy_tests {

  using namespace numpy::random;

  void testContinuousDistributions() {
    std::cout << "========= testContinuousDistributions ====";

    // Test chi-square distribution
    auto chi2_arr = chisquare<double>(3.0, { {2, 3} });
    if (!(chi2_arr.getShape()[0] == 2)) {
        std::string description = std::string("testContinuousDistributions():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(chi2_arr.getShape()[0] == 2)";
        std::cout << std::string("[FAIL] ") + description << std::endl;
        throw std::runtime_error(description);
    }
    if (!(chi2_arr.getShape()[1] == 3)) {
        std::string description = std::string("testContinuousDistributions():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(chi2_arr.getShape()[1] == 3)";
        std::cout << std::string("[FAIL] ") + description << std::endl;
        throw std::runtime_error(description);
    }

gamma (np_test_1_all.cpp:10297)

    std::cout << "========= testGammaFunctions ====";

    // Test gamma function for known values using NDArray with MKL backend
    NDArray<double> gamma_test({ 6 });
    gamma_test.setElementAt({ 0 }, 1.0);
    gamma_test.setElementAt({ 1 }, 2.0);
    gamma_test.setElementAt({ 2 }, 3.0);
    gamma_test.setElementAt({ 3 }, 4.0);
    gamma_test.setElementAt({ 4 }, 5.0);
    gamma_test.setElementAt({ 5 }, 0.5);
    auto gamma_result = special::gamma(gamma_test, MathBackend::MKL);

    if (!(isApproxEqual(gamma_result.getElementAt({ 0 }), 1.0, 1e-10))) {
        std::string description = std::string("testGammaFunctions():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(isApproxEqual(gamma_result.getElementAt({ 0 }), 1.0, 1e-10))";
        std::cout << std::string("[FAIL] ") + description << std::endl;
        throw std::runtime_error(description);
    }
    if (!(isApproxEqual(gamma_result.getElementAt({ 1 }), 1.0, 1e-10))) {
        std::string description = std::string("testGammaFunctions():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(isApproxEqual(gamma_result.getElementAt({ 1 }), 1.0, 1e-10))";
        std::cout << std::string("[FAIL] ") + description << std::endl;
        throw std::runtime_error(description);

gamma (np_test_1_all.cpp:10297)

    std::cout << "========= testGammaFunctions ====";

    // Test gamma function for known values using NDArray with MKL backend
    NDArray<double> gamma_test({ 6 });
    gamma_test.setElementAt({ 0 }, 1.0);
    gamma_test.setElementAt({ 1 }, 2.0);
    gamma_test.setElementAt({ 2 }, 3.0);
    gamma_test.setElementAt({ 3 }, 4.0);
    gamma_test.setElementAt({ 4 }, 5.0);
    gamma_test.setElementAt({ 5 }, 0.5);
    auto gamma_result = special::gamma(gamma_test, MathBackend::MKL);

    if (!(isApproxEqual(gamma_result.getElementAt({ 0 }), 1.0, 1e-10))) {
        std::string description = std::string("testGammaFunctions():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(isApproxEqual(gamma_result.getElementAt({ 0 }), 1.0, 1e-10))";
        std::cout << std::string("[FAIL] ") + description << std::endl;
        throw std::runtime_error(description);
    }
    if (!(isApproxEqual(gamma_result.getElementAt({ 1 }), 1.0, 1e-10))) {
        std::string description = std::string("testGammaFunctions():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(isApproxEqual(gamma_result.getElementAt({ 1 }), 1.0, 1e-10))";
        std::cout << std::string("[FAIL] ") + description << std::endl;
        throw std::runtime_error(description);

poisson (np_test_1_all.cpp:23404)

#include "../numpy/np_random.h"

namespace numpy_tests {

  using namespace numpy::random;

  void np_test_poisson_basic_generation() {
    std::cout << "========= np_test_poisson_basic_generation =======================";

    // Test poisson with default parameters (lambda=1.0, size=1)
    auto poisson_default = poisson<int>(1.0);
    if (poisson_default.getSize() != 1) {
      throw std::runtime_error("Poisson default generation failed");
    }

    // Test poisson with custom parameters
    auto poisson_custom = poisson<int>(5.0, { {3, 2} });
    if (poisson_custom.getShape() != std::vector<size_t>({ 3, 2 })) {
      throw std::runtime_error("Poisson custom generation failed");
    }

poisson (np_test_1_all.cpp:23404)

#include "../numpy/np_random.h"

namespace numpy_tests {

  using namespace numpy::random;

  void np_test_poisson_basic_generation() {
    std::cout << "========= np_test_poisson_basic_generation =======================";

    // Test poisson with default parameters (lambda=1.0, size=1)
    auto poisson_default = poisson<int>(1.0);
    if (poisson_default.getSize() != 1) {
      throw std::runtime_error("Poisson default generation failed");
    }

    // Test poisson with custom parameters
    auto poisson_custom = poisson<int>(5.0, { {3, 2} });
    if (poisson_custom.getShape() != std::vector<size_t>({ 3, 2 })) {
      throw std::runtime_error("Poisson custom generation failed");
    }

seed (np_test_1_all.cpp:14339)

    }
    // std::cout << "[OK] Generator integers method\n";

    std::cout << " -> tests passed\n";
  }

  void test_vsl_reproducibility() {
    std::cout << "========= test_vsl_reproducibility ====";

    // Test seed reproducibility
    seed(42);
    auto arr1 = normal<double>(0.0, 1.0, { {10} });

    seed(42);
    auto arr2 = normal<double>(0.0, 1.0, { {10} });



    for (size_t i = 0; i < 10; ++i) {
      double val1 = arr1.getElementAt({ i });
      double val2 = arr2.getElementAt({ i });

seed (np_test_1_all.cpp:14339)

    }
    // std::cout << "[OK] Generator integers method\n";

    std::cout << " -> tests passed\n";
  }

  void test_vsl_reproducibility() {
    std::cout << "========= test_vsl_reproducibility ====";

    // Test seed reproducibility
    seed(42);
    auto arr1 = normal<double>(0.0, 1.0, { {10} });

    seed(42);
    auto arr2 = normal<double>(0.0, 1.0, { {10} });



    for (size_t i = 0; i < 10; ++i) {
      double val1 = arr1.getElementAt({ i });
      double val2 = arr2.getElementAt({ i });

uniform (np_test_1_all.cpp:14301)

      double val = beta_gen.getElementAt({ i });
      if (!(val >= 0.0 && val <= 1.0)) {
          std::string description = std::string("test_vsl_generator_class():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(val >= 0.0 && val <= 1.0)";
          std::cout << std::string("[FAIL] ") + description << std::endl;
          throw std::runtime_error(description);
      }
    }
    // std::cout << "[OK] Generator beta method\n";

    // Test uniform and random methods
    auto unif_gen = gen.uniform<double>(0.0, 10.0, { {50} });
    auto rand_gen = gen.random<double>({ {50} });

    for (size_t i = 0; i < 50; ++i) {
      double unif_val = unif_gen.getElementAt({ i });
      double rand_val = rand_gen.getElementAt({ i });
      if (!(unif_val >= 0.0 && unif_val < 10.0)) {
          std::string description = std::string("test_vsl_generator_class():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(unif_val >= 0.0 && unif_val < 10.0)";
          std::cout << std::string("[FAIL] ") + description << std::endl;
          throw std::runtime_error(description);
      }

uniform (np_test_1_all.cpp:14301)

      double val = beta_gen.getElementAt({ i });
      if (!(val >= 0.0 && val <= 1.0)) {
          std::string description = std::string("test_vsl_generator_class():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(val >= 0.0 && val <= 1.0)";
          std::cout << std::string("[FAIL] ") + description << std::endl;
          throw std::runtime_error(description);
      }
    }
    // std::cout << "[OK] Generator beta method\n";

    // Test uniform and random methods
    auto unif_gen = gen.uniform<double>(0.0, 10.0, { {50} });
    auto rand_gen = gen.random<double>({ {50} });

    for (size_t i = 0; i < 50; ++i) {
      double unif_val = unif_gen.getElementAt({ i });
      double rand_val = rand_gen.getElementAt({ i });
      if (!(unif_val >= 0.0 && unif_val < 10.0)) {
          std::string description = std::string("test_vsl_generator_class():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(unif_val >= 0.0 && unif_val < 10.0)";
          std::cout << std::string("[FAIL] ") + description << std::endl;
          throw std::runtime_error(description);
      }

uniform_f64 (np_test_1_all.cpp:14610)

  void test_vsl_uniform_reproducibility() {
    std::cout << "========= test_vsl_uniform_reproducibility ====";

#ifdef NUMPY_USE_MKL
    if (numpy::vsl::is_vsl_available()) {
      // Test seed reproducibility with VSL streams
      numpy::vsl::VSLRandomStream stream1(12345);
      numpy::vsl::VSLRandomStream stream2(12345);

      std::vector<double> buf1(100), buf2(100);
      stream1.uniform_f64(buf1.data(), 100, 0.0, 1.0);
      stream2.uniform_f64(buf2.data(), 100, 0.0, 1.0);

      for (size_t i = 0; i < 100; ++i) {
        if (!(std::abs(buf1[i] - buf2[i]) < 1e-15)) {
            std::string description = std::string("test_vsl_uniform_reproducibility():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(std::abs(buf1[i] - buf2[i]) < 1e-15)";
            std::cout << std::string("[FAIL] ") + description << std::endl;
            throw std::runtime_error(description);
        }
      }
      // std::cout << "[OK] VSL stream reproducibility\n";

uniform_f64 (np_test_1_all.cpp:14610)

  void test_vsl_uniform_reproducibility() {
    std::cout << "========= test_vsl_uniform_reproducibility ====";

#ifdef NUMPY_USE_MKL
    if (numpy::vsl::is_vsl_available()) {
      // Test seed reproducibility with VSL streams
      numpy::vsl::VSLRandomStream stream1(12345);
      numpy::vsl::VSLRandomStream stream2(12345);

      std::vector<double> buf1(100), buf2(100);
      stream1.uniform_f64(buf1.data(), 100, 0.0, 1.0);
      stream2.uniform_f64(buf2.data(), 100, 0.0, 1.0);

      for (size_t i = 0; i < 100; ++i) {
        if (!(std::abs(buf1[i] - buf2[i]) < 1e-15)) {
            std::string description = std::string("test_vsl_uniform_reproducibility():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(std::abs(buf1[i] - buf2[i]) < 1e-15)";
            std::cout << std::string("[FAIL] ") + description << std::endl;
            throw std::runtime_error(description);
        }
      }
      // std::cout << "[OK] VSL stream reproducibility\n";

cauchy (np_test_3_all.cpp:5774)

namespace numpy_tests {

  using namespace numpy::random;

  namespace test_cauchy_gumbel {

    void np_test_cauchy_gumbel_basic_generation() {
      std::cout << "========= np_test_cauchy_gumbel_basic_generation =======================";

      // Test cauchy with default parameters
      auto cauchy_default = cauchy<double>();
      if (cauchy_default.getSize() != 1) {
        throw std::runtime_error("Cauchy default generation failed");
      }

      // Test cauchy with custom parameters
      auto cauchy_custom = cauchy<double>(2.0, 0.5, { {3, 2} });
      if (cauchy_custom.getShape() != std::vector<size_t>({ 3, 2 })) {
        throw std::runtime_error("Cauchy custom generation failed");
      }

cauchy (np_test_3_all.cpp:5774)

namespace numpy_tests {

  using namespace numpy::random;

  namespace test_cauchy_gumbel {

    void np_test_cauchy_gumbel_basic_generation() {
      std::cout << "========= np_test_cauchy_gumbel_basic_generation =======================";

      // Test cauchy with default parameters
      auto cauchy_default = cauchy<double>();
      if (cauchy_default.getSize() != 1) {
        throw std::runtime_error("Cauchy default generation failed");
      }

      // Test cauchy with custom parameters
      auto cauchy_custom = cauchy<double>(2.0, 0.5, { {3, 2} });
      if (cauchy_custom.getShape() != std::vector<size_t>({ 3, 2 })) {
        throw std::runtime_error("Cauchy custom generation failed");
      }

geometric (np_test_1_all.cpp:22094)

    }
    // std::cout << "[OK] Student's t-distribution\n";

    std::cout << " -> tests passed\n";
  }

  void testDiscreteDistributions() {
    std::cout << "========= testDiscreteDistributions ====";

    // Test geometric distribution
    auto geom_arr = geometric<int>(0.3, { {4} });
    if (!(geom_arr.getShape()[0] == 4)) {
        std::string description = std::string("testDiscreteDistributions():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(geom_arr.getShape()[0] == 4)";
        std::cout << std::string("[FAIL] ") + description << std::endl;
        throw std::runtime_error(description);
    }
    for (size_t i = 0; i < 4; ++i) {
      if (!(geom_arr.getElementAt({ i }) >= 1)) {
          std::string description = std::string("testDiscreteDistributions():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(geom_arr.getElementAt({ i }) >= 1)";
          std::cout << std::string("[FAIL] ") + description << std::endl;
          throw std::runtime_error(description);

geometric (np_test_1_all.cpp:22094)

    }
    // std::cout << "[OK] Student's t-distribution\n";

    std::cout << " -> tests passed\n";
  }

  void testDiscreteDistributions() {
    std::cout << "========= testDiscreteDistributions ====";

    // Test geometric distribution
    auto geom_arr = geometric<int>(0.3, { {4} });
    if (!(geom_arr.getShape()[0] == 4)) {
        std::string description = std::string("testDiscreteDistributions():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(geom_arr.getShape()[0] == 4)";
        std::cout << std::string("[FAIL] ") + description << std::endl;
        throw std::runtime_error(description);
    }
    for (size_t i = 0; i < 4; ++i) {
      if (!(geom_arr.getElementAt({ i }) >= 1)) {
          std::string description = std::string("testDiscreteDistributions():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(geom_arr.getElementAt({ i }) >= 1)";
          std::cout << std::string("[FAIL] ") + description << std::endl;
          throw std::runtime_error(description);

gumbel (np_test_3_all.cpp:5786)

        throw std::runtime_error("Cauchy default generation failed");
      }

      // Test cauchy with custom parameters
      auto cauchy_custom = cauchy<double>(2.0, 0.5, { {3, 2} });
      if (cauchy_custom.getShape() != std::vector<size_t>({ 3, 2 })) {
        throw std::runtime_error("Cauchy custom generation failed");
      }

      // Test gumbel with default parameters
      auto gumbel_default = gumbel<double>();
      if (gumbel_default.getSize() != 1) {
        throw std::runtime_error("Gumbel default generation failed");
      }

      // Test gumbel with custom parameters
      auto gumbel_custom = gumbel<double>(1.0, 2.0, { {2, 3} });
      if (gumbel_custom.getShape() != std::vector<size_t>({ 2, 3 })) {
        throw std::runtime_error("Gumbel custom generation failed");
      }

gumbel (np_test_3_all.cpp:5786)

        throw std::runtime_error("Cauchy default generation failed");
      }

      // Test cauchy with custom parameters
      auto cauchy_custom = cauchy<double>(2.0, 0.5, { {3, 2} });
      if (cauchy_custom.getShape() != std::vector<size_t>({ 3, 2 })) {
        throw std::runtime_error("Cauchy custom generation failed");
      }

      // Test gumbel with default parameters
      auto gumbel_default = gumbel<double>();
      if (gumbel_default.getSize() != 1) {
        throw std::runtime_error("Gumbel default generation failed");
      }

      // Test gumbel with custom parameters
      auto gumbel_custom = gumbel<double>(1.0, 2.0, { {2, 3} });
      if (gumbel_custom.getShape() != std::vector<size_t>({ 2, 3 })) {
        throw std::runtime_error("Gumbel custom generation failed");
      }

hypergeometric (np_test_1_all.cpp:22143)

    for (size_t i = 0; i < 3; ++i) {
      if (!(negbinom_arr.getElementAt({ i }) >= 0)) {
          std::string description = std::string("testDiscreteDistributions():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(negbinom_arr.getElementAt({ i }) >= 0)";
          std::cout << std::string("[FAIL] ") + description << std::endl;
          throw std::runtime_error(description);
      }
    }
    // std::cout << "[OK] Negative binomial distribution\n";

    // Test hypergeometric distribution
    auto hypergeo_arr = hypergeometric<int>(20, 30, 10, { {3} });
    if (!(hypergeo_arr.getShape()[0] == 3)) {
        std::string description = std::string("testDiscreteDistributions():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(hypergeo_arr.getShape()[0] == 3)";
        std::cout << std::string("[FAIL] ") + description << std::endl;
        throw std::runtime_error(description);
    }
    for (size_t i = 0; i < 3; ++i) {
      int val = hypergeo_arr.getElementAt({ i });
      if (!(val >= 0 && val <= 10)) {
          std::string description = std::string("testDiscreteDistributions():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(val >= 0 && val <= 10)";
          std::cout << std::string("[FAIL] ") + description << std::endl;

hypergeometric (np_test_1_all.cpp:22143)

    for (size_t i = 0; i < 3; ++i) {
      if (!(negbinom_arr.getElementAt({ i }) >= 0)) {
          std::string description = std::string("testDiscreteDistributions():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(negbinom_arr.getElementAt({ i }) >= 0)";
          std::cout << std::string("[FAIL] ") + description << std::endl;
          throw std::runtime_error(description);
      }
    }
    // std::cout << "[OK] Negative binomial distribution\n";

    // Test hypergeometric distribution
    auto hypergeo_arr = hypergeometric<int>(20, 30, 10, { {3} });
    if (!(hypergeo_arr.getShape()[0] == 3)) {
        std::string description = std::string("testDiscreteDistributions():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(hypergeo_arr.getShape()[0] == 3)";
        std::cout << std::string("[FAIL] ") + description << std::endl;
        throw std::runtime_error(description);
    }
    for (size_t i = 0; i < 3; ++i) {
      int val = hypergeo_arr.getElementAt({ i });
      if (!(val >= 0 && val <= 10)) {
          std::string description = std::string("testDiscreteDistributions():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(val >= 0 && val <= 10)";
          std::cout << std::string("[FAIL] ") + description << std::endl;

laplace (np_test_1_all.cpp:14151)

      }
      if (!(val < 100.0)) {
          std::string description = std::string("test_vsl_additional_distributions():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(val < 100.0)";
          std::cout << std::string("[FAIL] ") + description << std::endl;
          throw std::runtime_error(description);
      }
    }
    // std::cout << "[OK] Lognormal distribution test\n";

    // Test Laplace distribution
    auto laplace_arr = laplace<double>(0.0, 1.0, { {100} });
    for (size_t i = 0; i < 100; ++i) {
      double val = laplace_arr.getElementAt({ i });
      if (!(std::abs(val) < 10.0)) {
          std::string description = std::string("test_vsl_additional_distributions():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(std::abs(val) < 10.0)";
          std::cout << std::string("[FAIL] ") + description << std::endl;
          throw std::runtime_error(description);
      }
    }
    // std::cout << "[OK] Laplace distribution test\n";

laplace (np_test_1_all.cpp:14151)

      }
      if (!(val < 100.0)) {
          std::string description = std::string("test_vsl_additional_distributions():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(val < 100.0)";
          std::cout << std::string("[FAIL] ") + description << std::endl;
          throw std::runtime_error(description);
      }
    }
    // std::cout << "[OK] Lognormal distribution test\n";

    // Test Laplace distribution
    auto laplace_arr = laplace<double>(0.0, 1.0, { {100} });
    for (size_t i = 0; i < 100; ++i) {
      double val = laplace_arr.getElementAt({ i });
      if (!(std::abs(val) < 10.0)) {
          std::string description = std::string("test_vsl_additional_distributions():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(std::abs(val) < 10.0)";
          std::cout << std::string("[FAIL] ") + description << std::endl;
          throw std::runtime_error(description);
      }
    }
    // std::cout << "[OK] Laplace distribution test\n";

multinomial (np_test_1_all.cpp:22161)

      if (!(val >= 0 && val <= 10)) {
          std::string description = std::string("testDiscreteDistributions():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(val >= 0 && val <= 10)";
          std::cout << std::string("[FAIL] ") + description << std::endl;
          throw std::runtime_error(description);
      }
    }
    // std::cout << "[OK] Hypergeometric distribution\n";

    // Test multinomial distribution
    std::vector<double> pvals = { 0.2, 0.3, 0.5 };
    auto multi_arr = multinomial<int>(100, pvals, { {2} });
    if (!(multi_arr.getShape()[0] == 2)) {
        std::string description = std::string("testDiscreteDistributions():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(multi_arr.getShape()[0] == 2)";
        std::cout << std::string("[FAIL] ") + description << std::endl;
        throw std::runtime_error(description);
    }
    if (!(multi_arr.getShape()[1] == 3)) {
        std::string description = std::string("testDiscreteDistributions():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(multi_arr.getShape()[1] == 3)";
        std::cout << std::string("[FAIL] ") + description << std::endl;
        throw std::runtime_error(description);
    }

multivariate_normal (np_test_1_all.cpp:22212)

    std::cout << " -> tests passed\n";
  }

  void testMultivariateDistributions() {
    std::cout << "========= testMultivariateDistributions ====";

    // Test multivariate normal distribution
    std::vector<double> mean = { 0.0, 1.0 };
    std::vector<std::vector<double>> cov = { {1.0, 0.5}, {0.5, 2.0} };
    auto mvn_arr = multivariate_normal<double>(mean, cov, { {3} });

    if (!(mvn_arr.getShape()[0] == 3)) {
        std::string description = std::string("testMultivariateDistributions():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(mvn_arr.getShape()[0] == 3)";
        std::cout << std::string("[FAIL] ") + description << std::endl;
        throw std::runtime_error(description);
    }
    if (!(mvn_arr.getShape()[1] == 2)) {
        std::string description = std::string("testMultivariateDistributions():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(mvn_arr.getShape()[1] == 2)";
        std::cout << std::string("[FAIL] ") + description << std::endl;
        throw std::runtime_error(description);

multivariate_normal (np_test_1_all.cpp:22212)

    std::cout << " -> tests passed\n";
  }

  void testMultivariateDistributions() {
    std::cout << "========= testMultivariateDistributions ====";

    // Test multivariate normal distribution
    std::vector<double> mean = { 0.0, 1.0 };
    std::vector<std::vector<double>> cov = { {1.0, 0.5}, {0.5, 2.0} };
    auto mvn_arr = multivariate_normal<double>(mean, cov, { {3} });

    if (!(mvn_arr.getShape()[0] == 3)) {
        std::string description = std::string("testMultivariateDistributions():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(mvn_arr.getShape()[0] == 3)";
        std::cout << std::string("[FAIL] ") + description << std::endl;
        throw std::runtime_error(description);
    }
    if (!(mvn_arr.getShape()[1] == 2)) {
        std::string description = std::string("testMultivariateDistributions():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(mvn_arr.getShape()[1] == 2)";
        std::cout << std::string("[FAIL] ") + description << std::endl;
        throw std::runtime_error(description);

rayleigh (np_test_1_all.cpp:14163)

      double val = laplace_arr.getElementAt({ i });
      if (!(std::abs(val) < 10.0)) {
          std::string description = std::string("test_vsl_additional_distributions():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(std::abs(val) < 10.0)";
          std::cout << std::string("[FAIL] ") + description << std::endl;
          throw std::runtime_error(description);
      }
    }
    // std::cout << "[OK] Laplace distribution test\n";

    // Test Rayleigh distribution
    auto rayleigh_arr = rayleigh<double>(1.0, { {100} });
    for (size_t i = 0; i < 100; ++i) {
      double val = rayleigh_arr.getElementAt({ i });
      if (!(val >= 0.0)) {
          std::string description = std::string("test_vsl_additional_distributions():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(val >= 0.0)";
          std::cout << std::string("[FAIL] ") + description << std::endl;
          throw std::runtime_error(description);
      }
      if (!(val < 10.0)) {
          std::string description = std::string("test_vsl_additional_distributions():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(val < 10.0)";
          std::cout << std::string("[FAIL] ") + description << std::endl;

rayleigh (np_test_1_all.cpp:14163)

      double val = laplace_arr.getElementAt({ i });
      if (!(std::abs(val) < 10.0)) {
          std::string description = std::string("test_vsl_additional_distributions():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(std::abs(val) < 10.0)";
          std::cout << std::string("[FAIL] ") + description << std::endl;
          throw std::runtime_error(description);
      }
    }
    // std::cout << "[OK] Laplace distribution test\n";

    // Test Rayleigh distribution
    auto rayleigh_arr = rayleigh<double>(1.0, { {100} });
    for (size_t i = 0; i < 100; ++i) {
      double val = rayleigh_arr.getElementAt({ i });
      if (!(val >= 0.0)) {
          std::string description = std::string("test_vsl_additional_distributions():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(val >= 0.0)";
          std::cout << std::string("[FAIL] ") + description << std::endl;
          throw std::runtime_error(description);
      }
      if (!(val < 10.0)) {
          std::string description = std::string("test_vsl_additional_distributions():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(val < 10.0)";
          std::cout << std::string("[FAIL] ") + description << std::endl;

weibull (np_test_1_all.cpp:14180)

      }
      if (!(val < 10.0)) {
          std::string description = std::string("test_vsl_additional_distributions():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(val < 10.0)";
          std::cout << std::string("[FAIL] ") + description << std::endl;
          throw std::runtime_error(description);
      }
    }
    // std::cout << "[OK] Rayleigh distribution test\n";

    // Test Weibull distribution
    auto weibull_arr = weibull<double>(2.0, { {100} });
    for (size_t i = 0; i < 100; ++i) {
      double val = weibull_arr.getElementAt({ i });
      if (!(val >= 0.0)) {
          std::string description = std::string("test_vsl_additional_distributions():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(val >= 0.0)";
          std::cout << std::string("[FAIL] ") + description << std::endl;
          throw std::runtime_error(description);
      }
      if (!(val < 10.0)) {
          std::string description = std::string("test_vsl_additional_distributions():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(val < 10.0)";
          std::cout << std::string("[FAIL] ") + description << std::endl;

weibull (np_test_1_all.cpp:14180)

      }
      if (!(val < 10.0)) {
          std::string description = std::string("test_vsl_additional_distributions():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(val < 10.0)";
          std::cout << std::string("[FAIL] ") + description << std::endl;
          throw std::runtime_error(description);
      }
    }
    // std::cout << "[OK] Rayleigh distribution test\n";

    // Test Weibull distribution
    auto weibull_arr = weibull<double>(2.0, { {100} });
    for (size_t i = 0; i < 100; ++i) {
      double val = weibull_arr.getElementAt({ i });
      if (!(val >= 0.0)) {
          std::string description = std::string("test_vsl_additional_distributions():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(val >= 0.0)";
          std::cout << std::string("[FAIL] ") + description << std::endl;
          throw std::runtime_error(description);
      }
      if (!(val < 10.0)) {
          std::string description = std::string("test_vsl_additional_distributions():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(val < 10.0)";
          std::cout << std::string("[FAIL] ") + description << std::endl;