alglib4 0.0.0 → 0.0.1

data/ext/alglib/alglib_alglibmisc.cpp

@@ -0,0 +1,22 @@
+#include "alglib_alglibmisc.h"
+
+double rb_hqrndnormal()
+{
+    alglib::hqrndstate state;
+    alglib::hqrndrandomize(state);
+    return alglib::hqrndnormal(state);
+}
+
+Array rb_hqrndnormalv(alglib::ae_int_t n)
+{
+    Array result = Array(rb_ary_new2(n));
+    alglib::hqrndstate state;
+    alglib::hqrndrandomize(state);
+    alglib::real_1d_array x;
+    alglib::hqrndnormalv(state, n, x);
+    for (alglib::ae_int_t i = 0; i < n; i++)
+    {
+        result.push(x[i]);
+    }
+    return result;
+}

data/ext/alglib/alglib_alglibmisc.h

@@ -0,0 +1,8 @@
+#include <rice/rice.hpp>
+#include <rice/stl.hpp>
+#include "alglibmisc.h"
+#include "alglib_converters.h"
+#include "alglib_utils.h"
+
+double rb_hqrndnormal();
+Array rb_hqrndnormalv(alglib::ae_int_t n);

data/ext/alglib/alglib_converters.cpp

@@ -0,0 +1,193 @@
+#include "alglib_converters.h"
+
+alglib::real_1d_array ruby_array_to_real_1d_array(Array ruby_array)
+{
+    // Call the template function for real_1d_array and double
+    return ruby_array_to_alglib_1d_array<alglib::real_1d_array, double>(ruby_array);
+}
+
+alglib::integer_1d_array ruby_array_to_integer_1d_array(Array ruby_array)
+{
+    // Call the template function for integer_1d_array and int
+    return ruby_array_to_alglib_1d_array<alglib::integer_1d_array, int>(ruby_array);
+}
+
+Array real_1d_array_to_ruby_array(const alglib::real_1d_array &arr)
+{
+    // Call the template function for real_1d_array
+    return alglib_1d_array_to_ruby_array<alglib::real_1d_array>(arr);
+}
+
+Array integer_1d_array_to_ruby_array(const alglib::integer_1d_array &arr)
+{
+    // Call the template function for integer_1d_array
+    return alglib_1d_array_to_ruby_array<alglib::integer_1d_array>(arr);
+}
+
+alglib::real_2d_array ruby_array_to_real_2d_array(Array ruby_array)
+{
+    // Call the template function for real_2d_array and double
+    return ruby_array_to_alglib_2d_array<alglib::real_2d_array, double>(ruby_array);
+}
+
+alglib::integer_2d_array ruby_array_to_integer_2d_array(Array ruby_array)
+{
+    // Call the template function for integer_2d_array and int
+    return ruby_array_to_alglib_2d_array<alglib::integer_2d_array, int>(ruby_array);
+}
+
+Array real_2d_array_to_ruby_array(const alglib::real_2d_array &real_array)
+{
+    // Call the template function for real_2d_array
+    return alglib_2d_array_to_ruby_array<alglib::real_2d_array>(real_array);
+}
+
+Array integer_2d_array_to_ruby_array(const alglib::integer_2d_array &arr)
+{
+    // Call the template function for integer_2d_array
+    return alglib_2d_array_to_ruby_array<alglib::integer_2d_array>(arr);
+}
+
+/**
+ * @brief Template implementation: Convert a Ruby Array to an ALGLIB 1D array.
+ */
+template <typename AlglibArray, typename CType>
+AlglibArray ruby_array_to_alglib_1d_array(Array ruby_array)
+{
+    AlglibArray result;
+    result.setlength(ruby_array.size());
+    for (size_t i = 0; i < ruby_array.size(); ++i)
+    {
+        try
+        {
+            result[i] = Rice::detail::From_Ruby<CType>().convert(ruby_array[i].value());
+        }
+        catch (const std::exception &e)
+        {
+            throw std::invalid_argument(
+                "ruby_array_to_alglib_1d_array: Element " + std::to_string(i) +
+                " conversion failed: " + e.what());
+        }
+    }
+    return result;
+}
+
+/**
+ * @brief Template implementation: Convert an ALGLIB 1D array to a Ruby Array.
+ */
+template <typename AlglibArray>
+Array alglib_1d_array_to_ruby_array(const AlglibArray &arr)
+{
+    Array ruby_array;
+    for (int i = 0; i < arr.length(); ++i)
+    {
+        ruby_array.push(arr[i]);
+    }
+    return ruby_array;
+}
+
+/**
+ * @brief Template implementation: Convert a Ruby 2D Array (Array of Arrays) to an ALGLIB 2D array.
+ */
+template <typename Alglib2DArray, typename CType>
+Alglib2DArray ruby_array_to_alglib_2d_array(Array ruby_array)
+{
+    if (ruby_array.size() == 0)
+    {
+        // Return an empty ALGLIB 2D array (0x0)
+        Alglib2DArray result;
+        result.setlength(0, 0);
+        return result;
+    }
+    int rows = ruby_array.size();
+    Array first_row;
+    try
+    {
+        first_row = Rice::detail::From_Ruby<Array>().convert(ruby_array.call("first"));
+    }
+    catch (const std::exception &e)
+    {
+        throw std::invalid_argument("ruby_array_to_alglib_2d_array: First row is not an Array: " + std::string(e.what()));
+    }
+    int cols = first_row.size();
+
+    Alglib2DArray result;
+    result.setlength(rows, cols);
+
+    for (int i = 0; i < rows; ++i)
+    {
+        Array row;
+        try
+        {
+            row = Rice::detail::From_Ruby<Array>().convert(ruby_array[i].value());
+        }
+        catch (const std::exception &e)
+        {
+            throw std::invalid_argument(
+                "ruby_array_to_alglib_2d_array: Row " + std::to_string(i) +
+                " is not an Array: " + e.what());
+        }
+        if (row.size() != cols)
+        {
+            throw std::invalid_argument(
+                "ruby_array_to_alglib_2d_array: Row " + std::to_string(i) +
+                " size mismatch: expected " + std::to_string(cols) +
+                ", got " + std::to_string(row.size()));
+        }
+        for (int j = 0; j < cols; ++j)
+        {
+            try
+            {
+                result[i][j] = Rice::detail::From_Ruby<CType>().convert(row[j].value());
+            }
+            catch (const std::exception &e)
+            {
+                throw std::invalid_argument(
+                    "ruby_array_to_alglib_2d_array: Element (" +
+                    std::to_string(i) + "," + std::to_string(j) +
+                    ") conversion failed: " + e.what());
+            }
+        }
+    }
+    return result;
+}
+
+/**
+ * @brief Template implementation: Convert an ALGLIB 2D array to a Ruby 2D Array (Array of Arrays).
+ */
+template <typename Alglib2DArray>
+Array alglib_2d_array_to_ruby_array(const Alglib2DArray &arr)
+{
+    Array result;
+    for (int i = 0; i < arr.rows(); i++)
+    {
+        Array row;
+        for (int j = 0; j < arr.cols(); j++)
+        {
+            row.push(arr[i][j]);
+        }
+        result.push(row);
+    }
+    return result;
+}
+
+/**
+ * @brief Explicit template instantiations for 1D/2D real/integer ALGLIB arrays.
+ * This ensures symmetric conversion support for both real and integer types.
+ */
+
+// 1D real
+template alglib::real_1d_array ruby_array_to_alglib_1d_array<alglib::real_1d_array, double>(Array);
+template Array alglib_1d_array_to_ruby_array<alglib::real_1d_array>(const alglib::real_1d_array &);
+
+// 1D integer
+template alglib::integer_1d_array ruby_array_to_alglib_1d_array<alglib::integer_1d_array, int>(Array);
+template Array alglib_1d_array_to_ruby_array<alglib::integer_1d_array>(const alglib::integer_1d_array &);
+
+// 2D real
+template alglib::real_2d_array ruby_array_to_alglib_2d_array<alglib::real_2d_array, double>(Array);
+template Array alglib_2d_array_to_ruby_array<alglib::real_2d_array>(const alglib::real_2d_array &);
+
+// 2D integer
+template alglib::integer_2d_array ruby_array_to_alglib_2d_array<alglib::integer_2d_array, int>(Array);
+template Array alglib_2d_array_to_ruby_array<alglib::integer_2d_array>(const alglib::integer_2d_array &);

data/ext/alglib/alglib_converters.h

@@ -0,0 +1,56 @@
+#pragma once
+#include <rice/rice.hpp>
+#include <rice/stl.hpp>
+#include "ap.h"
+
+using namespace Rice;
+
+/**
+ * @brief Convert a Ruby Array to an ALGLIB 1D array (e.g., real_1d_array, integer_1d_array).
+ * @tparam AlglibArray ALGLIB array type (e.g., alglib::real_1d_array)
+ * @tparam CType C++ element type (e.g., double, int)
+ * @param ruby_array Ruby Array object
+ * @return Converted ALGLIB array
+ * @throw std::invalid_argument if conversion fails
+ */
+template <typename AlglibArray, typename CType>
+AlglibArray ruby_array_to_alglib_1d_array(Array ruby_array);
+
+/**
+ * @brief Convert an ALGLIB 1D array to a Ruby Array.
+ * @tparam AlglibArray ALGLIB array type (e.g., alglib::real_1d_array)
+ * @param arr ALGLIB array
+ * @return Ruby Array object
+ */
+template <typename AlglibArray>
+Array alglib_1d_array_to_ruby_array(const AlglibArray &arr);
+
+/**
+ * @brief Convert a Ruby 2D Array (Array of Arrays) to an ALGLIB 2D array (e.g., real_2d_array).
+ * @tparam Alglib2DArray ALGLIB 2D array type (e.g., alglib::real_2d_array)
+ * @tparam CType C++ element type (e.g., double)
+ * @param ruby_array Ruby Array of Arrays
+ * @return Converted ALGLIB 2D array
+ * @throw std::invalid_argument if conversion fails
+ */
+template <typename Alglib2DArray, typename CType>
+Alglib2DArray ruby_array_to_alglib_2d_array(Array ruby_array);
+
+/**
+ * @brief Convert an ALGLIB 2D array to a Ruby 2D Array (Array of Arrays).
+ * @tparam Alglib2DArray ALGLIB 2D array type (e.g., alglib::real_2d_array)
+ * @param arr ALGLIB 2D array
+ * @return Ruby Array of Arrays
+ */
+template <typename Alglib2DArray>
+Array alglib_2d_array_to_ruby_array(const Alglib2DArray &arr);
+
+// Existing function declarations for backward compatibility
+alglib::real_1d_array ruby_array_to_real_1d_array(Array ruby_array);
+alglib::integer_1d_array ruby_array_to_integer_1d_array(Array ruby_array);
+alglib::real_2d_array ruby_array_to_real_2d_array(Array ruby_array);
+alglib::integer_2d_array ruby_array_to_integer_2d_array(Array ruby_array);
+Array real_1d_array_to_ruby_array(const alglib::real_1d_array &arr);
+Array real_2d_array_to_ruby_array(const alglib::real_2d_array &real_array);
+Array integer_1d_array_to_ruby_array(const alglib::integer_1d_array &arr);
+Array integer_2d_array_to_ruby_array(const alglib::integer_2d_array &arr);

data/ext/alglib/alglib_dataanalysis.cpp

@@ -0,0 +1,14 @@
+#include "alglib_dataanalysis.h"
+
+// void pcabuildbasis(const real_2d_array &x, real_1d_array &s2, real_2d_array &v, const xparams _xparams = alglib::xdefault);
+Hash rb_pcabuildbasis(Array x)
+{
+    Hash result;
+    auto a = ruby_array_to_real_2d_array(x);
+    alglib::real_1d_array s2;
+    alglib::real_2d_array v;
+    alglib::pcabuildbasis(a, s2, v, alglib::xdefault);
+    result["s2"] = real_1d_array_to_ruby_array(s2);
+    result["v"] = real_2d_array_to_ruby_array(v);
+    return result;
+}

data/ext/alglib/alglib_dataanalysis.h

@@ -0,0 +1,9 @@
+#include <rice/rice.hpp>
+#include <rice/stl.hpp>
+#include "dataanalysis.h"
+#include "alglib_converters.h"
+#include "alglib_utils.h"
+
+using namespace Rice;
+
+Hash rb_pcabuildbasis(Array x);

data/ext/alglib/alglib_specialfunctions.cpp

@@ -0,0 +1,199 @@
+#include "alglib_specialfunctions.h"
+
+// double gammafunction(const double x, const xparams _xparams = alglib::xdefault);
+double rb_gammafunction(double x)
+{
+    return alglib::gammafunction(x);
+}
+
+// double lngamma(const double x, double &sgngam, const xparams _xparams = alglib::xdefault);
+Array rb_lngamma(double x)
+{
+    Array result = Array(rb_ary_new2(2));
+    double sgngam;
+    result.push(alglib::lngamma(x, sgngam));
+    result.push(sgngam);
+    return result;
+}
+
+// double errorfunction(const double x, const xparams _xparams = alglib::xdefault);
+double rb_errorfunction(double x)
+{
+    return alglib::errorfunction(x);
+}
+
+// double errorfunctionc(const double x, const xparams _xparams = alglib::xdefault);
+double rb_errorfunctionc(double x)
+{
+    return alglib::errorfunctionc(x);
+}
+
+// double normalpdf(const double x, const xparams _xparams = alglib::xdefault);
+double rb_normalpdf(double x)
+{
+    return alglib::normalpdf(x);
+}
+
+// double normalcdf(const double x, const xparams _xparams = alglib::xdefault);
+double rb_normalcdf(double x)
+{
+    return alglib::normalcdf(x);
+}
+
+// double inverf(const double e, const xparams _xparams = alglib::xdefault);
+double rb_inverf(double e)
+{
+    return alglib::inverf(e);
+}
+
+// double invnormalcdf(const double y0, const xparams _xparams = alglib::xdefault);
+double rb_invnormalcdf(double y0)
+{
+    return alglib::invnormalcdf(y0);
+}
+
+// double bivariatenormalpdf(const double x, const double y, const double rho, const xparams _xparams = alglib::xdefault);
+double rb_bivariatenormalpdf(double x, double y, double rho)
+{
+    return alglib::bivariatenormalpdf(x, y, rho);
+}
+
+// double bivariatenormalcdf(const double x, const double y, const double rho, const xparams _xparams = alglib::xdefault);
+double rb_bivariatenormalcdf(double x, double y, double rho)
+{
+    return alglib::bivariatenormalcdf(x, y, rho);
+}
+
+// double incompletebeta(const double a, const double b, const double x, const xparams _xparams = alglib::xdefault);
+double rb_incompletebeta(double a, double b, double x)
+{
+    return alglib::incompletebeta(a, b, x);
+}
+
+// double invincompletebeta(const double a, const double b, const double y, const xparams _xparams = alglib::xdefault);
+double rb_invincompletebeta(double a, double b, double y)
+{
+    return alglib::invincompletebeta(a, b, y);
+}
+
+// double studenttdistribution(const ae_int_t k, const double t, const xparams _xparams = alglib::xdefault);
+double rb_studenttdistribution(alglib::ae_int_t k, double t)
+{
+    return alglib::studenttdistribution(k, t);
+}
+
+// double invstudenttdistribution(const ae_int_t k, const double p, const xparams _xparams = alglib::xdefault);
+double rb_invstudenttdistribution(alglib::ae_int_t k, double p)
+{
+    return alglib::invstudenttdistribution(k, p);
+}
+
+// double fdistribution(const ae_int_t a, const ae_int_t b, const double x, const xparams _xparams = alglib::xdefault);
+double rb_fdistribution(alglib::ae_int_t a, alglib::ae_int_t b, double x)
+{
+    return alglib::fdistribution(a, b, x);
+}
+
+// double fcdistribution(const ae_int_t a, const ae_int_t b, const double x, const xparams _xparams = alglib::xdefault);
+double rb_fcdistribution(alglib::ae_int_t a, alglib::ae_int_t b, double x)
+{
+    return alglib::fcdistribution(a, b, x);
+}
+
+// double invfdistribution(const ae_int_t a, const ae_int_t b, const double y, const xparams _xparams = alglib::xdefault);
+double rb_invfdistribution(alglib::ae_int_t a, alglib::ae_int_t b, double y)
+{
+    return alglib::invfdistribution(a, b, y);
+}
+
+// double incompletegamma(const double a, const double x, const xparams _xparams = alglib::xdefault);
+double rb_incompletegamma(double a, double x)
+{
+    return alglib::incompletegamma(a, x);
+}
+
+// double incompletegammac(const double a, const double x, const xparams _xparams = alglib::xdefault);
+double rb_incompletegammac(double a, double x)
+{
+    return alglib::incompletegammac(a, x);
+}
+
+// double invincompletegammac(const double a, const double y0, const xparams _xparams = alglib::xdefault);
+double rb_invincompletegammac(double a, double y0)
+{
+    return alglib::invincompletegammac(a, y0);
+}
+
+// double chisquaredistribution(const double v, const double x, const xparams _xparams = alglib::xdefault);
+double rb_chisquaredistribution(double v, double x)
+{
+    return alglib::chisquaredistribution(v, x);
+}
+
+// double chisquarecdistribution(const double v, const double x, const xparams _xparams = alglib::xdefault);
+double rb_chisquarecdistribution(double v, double x)
+{
+    return alglib::chisquarecdistribution(v, x);
+}
+
+// double invchisquaredistribution(const double v, const double y, const xparams _xparams = alglib::xdefault);
+double rb_invchisquaredistribution(double v, double y)
+{
+    return alglib::invchisquaredistribution(v, y);
+}
+
+// double binomialdistribution(const ae_int_t k, const ae_int_t n, const double p, const xparams _xparams = alglib::xdefault);
+double rb_binomialdistribution(alglib::ae_int_t k, alglib::ae_int_t n, double p)
+{
+    return alglib::binomialdistribution(k, n, p);
+}
+
+// double binomialcdistribution(const ae_int_t k, const ae_int_t n, const double p, const xparams _xparams = alglib::xdefault);
+double rb_binomialcdistribution(alglib::ae_int_t k, alglib::ae_int_t n, double p)
+{
+    return alglib::binomialcdistribution(k, n, p);
+}
+
+// double invbinomialdistribution(const ae_int_t k, const ae_int_t n, const double y, const xparams _xparams = alglib::xdefault);
+double rb_invbinomialdistribution(alglib::ae_int_t k, alglib::ae_int_t n, double y)
+{
+    return alglib::invbinomialdistribution(k, n, y);
+}
+
+// double exponentialintegralei(const double x, const xparams _xparams = alglib::xdefault);
+double rb_exponentialintegralei(double x)
+{
+    return alglib::exponentialintegralei(x);
+}
+
+// double exponentialintegralen(const double x, const ae_int_t n, const xparams _xparams = alglib::xdefault);
+double rb_exponentialintegralen(double x, alglib::ae_int_t n)
+{
+    return alglib::exponentialintegralen(x, n);
+}
+
+//
+
+// double poissondistribution(const ae_int_t k, const double m, const xparams _xparams = alglib::xdefault);
+double rb_poissondistribution(alglib::ae_int_t k, double m)
+{
+    return alglib::poissondistribution(k, m);
+}
+
+// double poissoncdistribution(const ae_int_t k, const double m, const xparams _xparams = alglib::xdefault);
+double rb_poissoncdistribution(alglib::ae_int_t k, double m)
+{
+    return alglib::poissoncdistribution(k, m);
+}
+
+// double invpoissondistribution(const ae_int_t k, const double y, const xparams _xparams = alglib::xdefault);
+double rb_invpoissondistribution(alglib::ae_int_t k, double y)
+{
+    return alglib::invpoissondistribution(k, y);
+}
+
+// double beta(const double a, const double b, const xparams _xparams = alglib::xdefault);
+double rb_beta(double a, double b)
+{
+    return alglib::beta(a, b);
+}

data/ext/alglib/alglib_specialfunctions.h

@@ -0,0 +1,41 @@
+#include <rice/rice.hpp>
+#include <rice/stl.hpp>
+#include "specialfunctions.h"
+#include "alglib_converters.h"
+#include "alglib_utils.h"
+
+using namespace Rice;
+
+double rb_gammafunction(double x);
+Array rb_lngamma(double x);
+double rb_errorfunction(double x);
+double rb_errorfunctionc(double x);
+double rb_normalpdf(double x);
+double rb_normalcdf(double x);
+double rb_inverf(double e);
+double rb_invnormalcdf(double y0);
+double rb_bivariatenormalpdf(double x, double y, double rho);
+double rb_bivariatenormalcdf(double x, double y, double rho);
+double rb_incompletebeta(double a, double b, double x);
+double rb_invincompletebeta(double a, double b, double y);
+double rb_studenttdistribution(alglib::ae_int_t k, double t);
+double rb_invstudenttdistribution(alglib::ae_int_t k, double p);
+double rb_fdistribution(alglib::ae_int_t a, alglib::ae_int_t b, double x);
+double rb_fcdistribution(alglib::ae_int_t a, alglib::ae_int_t b, double x);
+double rb_invfdistribution(alglib::ae_int_t a, alglib::ae_int_t b, double y);
+double rb_incompletegamma(double a, double x);
+double rb_incompletegammac(double a, double x);
+double rb_invincompletegammac(double a, double y0);
+double rb_chisquaredistribution(double v, double x);
+double rb_chisquarecdistribution(double v, double x);
+double rb_invchisquaredistribution(double v, double y);
+double rb_binomialdistribution(alglib::ae_int_t k, alglib::ae_int_t n, double p);
+double rb_binomialcdistribution(alglib::ae_int_t k, alglib::ae_int_t n, double p);
+double rb_invbinomialdistribution(alglib::ae_int_t k, alglib::ae_int_t n, double y);
+double rb_exponentialintegralei(double x);
+double rb_exponentialintegralen(double x, alglib::ae_int_t n);
+
+double rb_poissondistribution(alglib::ae_int_t k, double m);
+double rb_poissoncdistribution(alglib::ae_int_t k, double m);
+double rb_invpoissondistribution(alglib::ae_int_t k, double y);
+double rb_beta(double a, double b);