differintC 0.1.0__tar.gz

differintc-0.1.0/CMakeLists.txt

@@ -0,0 +1,100 @@
+cmake_minimum_required(VERSION 3.15)
+# ——————————————————————————————————————————————————————————
+# 1) Project Declaration & C++ Standard
+# ——————————————————————————————————————————————————————————
+project(differintC
+    VERSION 0.1.0
+    DESCRIPTION "Standalone C++ library for fractional differintegrals"
+    LANGUAGES CXX
+)
+
+# Force C++17
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+# ——————————————————————————————————————————————————————————
+# 2) Find Python & pybind11
+# ——————————————————————————————————————————————————————————
+find_package(Python COMPONENTS Interpreter Development REQUIRED)
+
+include(FetchContent)
+FetchContent_Declare(
+  pybind11
+  GIT_REPOSITORY https://github.com/pybind/pybind11.git
+  GIT_TAG        v2.11.0
+)
+FetchContent_MakeAvailable(pybind11)
+
+# ——————————————————————————————————————————————————————————
+# 3) Core Library Target
+# ——————————————————————————————————————————————————————————
+add_library(differint_core
+    src/differint/differint.cpp
+)
+target_include_directories(differint_core
+    PUBLIC ${CMAKE_SOURCE_DIR}/include
+)
+
+# Optional standalone sanity checker
+if(DIFFCHECK_GL)
+  add_executable(sanity
+    src/differint/sanity.cpp
+  )
+  target_include_directories(sanity
+    PRIVATE ${CMAKE_SOURCE_DIR}/include
+  )
+  target_link_libraries(sanity
+    PRIVATE differint_core
+  )
+endif()
+
+# ——————————————————————————————————————————————————————————
+# 4) Python Extension Module (differintC.pyd)
+# ——————————————————————————————————————————————————————————
+pybind11_add_module(differintC MODULE
+    python/module.cpp
+)
+
+target_include_directories(differintC
+    PRIVATE ${CMAKE_SOURCE_DIR}/include
+)
+
+target_link_libraries(differintC
+    PRIVATE differint_core
+)
+
+# Fix Windows pyd naming and output
+set_target_properties(differintC PROPERTIES
+    PREFIX ""                         # Avoid "lib" prefix
+    SUFFIX ".pyd"                     # Ensure Python .pyd extension
+    LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/Release  # Optional: match build dir
+)
+
+
+
+# ——————————————————————————————————————————————————————————
+# 5) Install: Python module into site-packages
+# ——————————————————————————————————————————————————————————
+# Detect Python site-packages directory
+execute_process(
+  COMMAND "${Python_EXECUTABLE}" -c
+    "import sysconfig; print(sysconfig.get_paths()['purelib'])"
+  OUTPUT_VARIABLE PYTHON_SITE_PACKAGES
+  OUTPUT_STRIP_TRAILING_WHITESPACE
+)
+
+install(TARGETS differintC
+    LIBRARY DESTINATION "${PYTHON_SITE_PACKAGES}"  # for .pyd module
+)
+
+# Optional: install core lib if desired
+install(TARGETS differint_core
+    ARCHIVE DESTINATION lib
+    LIBRARY DESTINATION lib
+)
+
+# ——————————————————————————————————————————————————————————
+# 5) (Optional) Testing — commented out until you add tests
+# ——————————————————————————————————————————————————————————
+# enable_testing()
+# add_subdirectory(tests)

differintc-0.1.0/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: differintC
+Version: 0.1.0
+Summary: Fast C++ implementation of fractional calculus operators
+Author: Your Name
+License-Expression: MIT
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+

differintc-0.1.0/cmake/differintCConfig.cmake.in

@@ -0,0 +1,5 @@
+@PACKAGE_INIT@
+
+include("${CMAKE_CURRENT_LIST_DIR}/differintCTargets.cmake")
+
+set(differintC_INCLUDE_DIRS "${CMAKE_CURRENT_LIST_DIR}/../../../include")

differintc-0.1.0/include/differint/differint.hpp

@@ -0,0 +1,74 @@
+#pragma once
+
+#include <vector>
+#include <cstddef>
+
+namespace differint {
+
+/**
+ * Riemann–Liouville fractional derivative at a single point using trapezoid rule.
+ * @tparam T      Numeric type (e.g. float, double)
+ * @param alpha   Fractional order (0 < alpha < 1)
+ * @param f_vals  Either sample values of f at uniformly spaced points, or size-0 vector
+ *                if no precomputed samples; in that case, user must call with
+ *                a custom provider (see implementation)
+ * @param domain_start  Left endpoint of interval
+ * @param domain_end    Right endpoint of interval
+ * @param num_points    Number of discretization points
+ * @return             Approximated fractional derivative value
+ */
+template <typename T>
+T RLpoint(T alpha,
+           const std::vector<T>& f_vals,
+           T domain_start = T(0),
+           T domain_end   = T(1),
+           std::size_t num_points = 100);
+
+
+/// Riemann–Liouville fractional derivative over the entire grid
+template <typename T>
+std::vector<T> RL(T alpha,
+                  const std::vector<T>& f_vals,
+                  T domain_start = T(0),
+                  T domain_end   = T(1),
+                  std::size_t num_points = 100);
+
+
+
+
+
+/**
+ * Grünwald–Letnikov fractional derivative at a single point.
+ * @tparam T
+ * @param alpha         Fractional order
+ * @param f_vals        Sampled function values at uniform nodes
+ * @param domain_start  Left endpoint
+ * @param domain_end    Right endpoint
+ * @param num_points    Number of nodes
+ * @return              Approximated derivative
+ */
+template <typename T>
+T GLpoint(T alpha,
+          const std::vector<T>& f_vals,
+          T domain_start = T(0),
+          T domain_end   = T(1),
+          std::size_t num_points = 100);
+
+/**
+ * Grünwald–Letnikov fractional derivative over entire grid.
+ * @tparam T
+ * @param alpha         Fractional order
+ * @param f_vals        Sampled function values at uniform nodes
+ * @param domain_start  Left endpoint
+ * @param domain_end    Right endpoint
+ * @param num_points    Number of nodes
+ * @return              Vector of derivative values at each node
+ */
+template <typename T>
+std::vector<T> GL(T alpha,
+                  const std::vector<T>& f_vals,
+                  T domain_start = T(0),
+                  T domain_end   = T(1),
+                  std::size_t num_points = 100);
+
+} // namespace differint

differintc-0.1.0/pyproject.toml

@@ -0,0 +1,12 @@
+[build-system]
+requires = ["scikit-build-core", "pybind11"]
+build-backend = "scikit_build_core.build"
+
+[project]
+name = "differintC"
+version = "0.1.0"
+description = "Fast C++ implementation of fractional calculus operators"
+authors = [{ name = "Your Name" }]
+license = "MIT"
+readme = "README.md"
+requires-python = ">=3.8"

differintc-0.1.0/python/CMakeLists.txt

@@ -0,0 +1,21 @@
+# python/CMakeLists.txt
+
+# Create the Python extension module
+pybind11_add_module(differintC module.cpp)
+
+# Ensure it can include our public headers
+target_include_directories(differintC
+    PRIVATE ${CMAKE_SOURCE_DIR}/include
+)
+
+# Link against the core library
+target_link_libraries(differintC
+    PRIVATE differint_core
+)
+
+# Optionally set properties so it's built in Release by default
+set_target_properties(differintC PROPERTIES
+    CXX_STANDARD 17
+    CXX_STANDARD_REQUIRED YES
+    BUILD_WITH_INSTALL_RPATH ON
+)

differintc-0.1.0/python/module.cpp

@@ -0,0 +1,80 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/numpy.h>
+#include "differint/differint.hpp"
+
+namespace py = pybind11;
+
+template <typename Func>
+std::vector<double> call_and_sample(Func&& f, double a, double b, size_t n) {
+    // Build the input grid
+    std::vector<double> vals(n);
+    double step = (b - a) / (n - 1);
+    for (size_t i = 0; i < n; ++i)
+        vals[i] = f(a + step * i);
+    return vals;
+}
+
+// Helper to convert any array-like or callable to a std::vector<double>
+std::vector<double> prepare_fvals(py::object f_obj,
+                                  double a, double b, size_t n) {
+    // If it's an array or list, cast directly
+    if (py::isinstance<py::array>(f_obj) ||
+        py::isinstance<py::list>(f_obj)) {
+        auto arr = py::array_t<double>::ensure(f_obj);
+        if (!arr || arr.size() != n)
+            throw std::runtime_error("Input array length must equal num_points");
+        std::vector<double> v(n);
+        std::memcpy(v.data(), arr.data(), n * sizeof(double));
+        return v;
+    }
+    // Otherwise assume callable
+    auto cb = f_obj.cast<py::function>();
+    return call_and_sample(
+      [&](double x){ return cb(x).cast<double>(); },
+      a, b, n
+    );
+}
+
+PYBIND11_MODULE(differintC, m) {
+    m.doc() = "Fractional differintegral routines (RL & GL)";
+
+    m.def("RLpoint",
+        [](double alpha, py::object f, double a, double b, size_t n) {
+            auto fv = prepare_fvals(f, a, b, n);
+            return differint::RLpoint(alpha, fv, a, b, n);
+        },
+        py::arg("alpha"), py::arg("f_name"),
+        py::arg("domain_start")=0.0, py::arg("domain_end")=1.0,
+        py::arg("num_points")=100
+    );
+
+    m.def("RL",
+        [](double alpha, py::object f, double a, double b, size_t n) {
+            auto fv = prepare_fvals(f, a, b, n);
+            return differint::RL(alpha, fv, a, b, n);
+        },
+        py::arg("alpha"), py::arg("f_name"),
+        py::arg("domain_start")=0.0, py::arg("domain_end")=1.0,
+        py::arg("num_points")=100
+    );
+
+    m.def("GLpoint",
+        [](double alpha, py::object f, double a, double b, size_t n) {
+            auto fv = prepare_fvals(f, a, b, n);
+            return differint::GLpoint(alpha, fv, a, b, n);
+        },
+        py::arg("alpha"), py::arg("f_name"),
+        py::arg("domain_start")=0.0, py::arg("domain_end")=1.0,
+        py::arg("num_points")=100
+    );
+
+    m.def("GL",
+        [](double alpha, py::object f, double a, double b, size_t n) {
+            auto fv = prepare_fvals(f, a, b, n);
+            return differint::GL(alpha, fv, a, b, n);
+        },
+        py::arg("alpha"), py::arg("f_name"),
+        py::arg("domain_start")=0.0, py::arg("domain_end")=1.0,
+        py::arg("num_points")=100
+    );
+}

differintc-0.1.0/src/differint/differint.cpp

@@ -0,0 +1,208 @@
+#include <differint/differint.hpp>
+#include <cmath>
+#include <stdexcept>
+#include <algorithm>
+
+namespace differint {
+
+template <typename T>
+T RLpoint(T alpha,
+           const std::vector<T>& f_vals,
+           T domain_start,
+           T domain_end,
+           std::size_t num_points) {
+    if (num_points < 2) {
+        throw std::invalid_argument("num_points must be at least 2");
+    }
+    // Ensure domain ordering
+    if (domain_start > domain_end) {
+        std::swap(domain_start, domain_end);
+    }
+    // Check input vector length
+    if (f_vals.size() != num_points) {
+        throw std::invalid_argument("f_vals size does not match num_points");
+    }
+    // Compute step size
+    T step = (domain_end - domain_start) / static_cast<T>(num_points - 1);
+
+    std::size_t k = num_points - 1;
+    std::vector<T> coeffs(num_points);
+
+    // Case j == 0
+    if (k > 0) {
+        coeffs[0] = std::pow(static_cast<T>(k - 1), static_cast<T>(1) - alpha)
+                    - (static_cast<T>(k) + alpha - static_cast<T>(1))
+                      * std::pow(static_cast<T>(k), -alpha);
+    } else {
+        coeffs[0] = T(1);
+    }
+
+    // Case j == k
+    coeffs[k] = T(1);
+
+    // Other indices
+    for (std::size_t j = 1; j < k; ++j) {
+        T d = static_cast<T>(k - j);
+        coeffs[j] = std::pow(d + static_cast<T>(1), static_cast<T>(1) - alpha)
+                    + std::pow(d - static_cast<T>(1), static_cast<T>(1) - alpha)
+                    - static_cast<T>(2) * std::pow(d, static_cast<T>(1) - alpha);
+    }
+
+    // Compute normalization constant
+    T C = static_cast<T>(1) / std::tgamma(static_cast<T>(2) - alpha);
+
+    // Dot product
+    T result = T(0);
+    for (std::size_t i = 0; i < num_points; ++i) {
+        result += coeffs[i] * f_vals[i];
+    }
+
+    return C * std::pow(step, -alpha) * result;
+}
+
+
+// RL entire-grid implementation
+template <typename T>
+std::vector<T> RL(T alpha,
+                  const std::vector<T>& f_vals,
+                  T domain_start,
+                  T domain_end,
+                  std::size_t num_points) {
+    if (num_points < 2) {
+        throw std::invalid_argument("num_points must be at least 2");
+    }
+    if (domain_start > domain_end) {
+        std::swap(domain_start, domain_end);
+    }
+    if (f_vals.size() != num_points) {
+        throw std::invalid_argument("f_vals size does not match num_points");
+    }
+    T step = (domain_end - domain_start) / static_cast<T>(num_points - 1);
+
+    // Precompute coefficient matrix D
+    std::vector<std::vector<T>> D(num_points, std::vector<T>(num_points));
+    // Precompute powers v[k] = (k)^(1-alpha)
+    std::vector<T> v(num_points + 1);
+    for (std::size_t k = 0; k <= num_points; ++k) {
+        v[k] = std::pow(static_cast<T>(k), static_cast<T>(1) - alpha);
+    }
+
+    // Fill D
+    for (std::size_t i = 0; i < num_points; ++i) {
+        for (std::size_t j = 0; j < num_points; ++j) {
+            if (j == i) {
+                D[i][j] = T(1);
+            } else if (j == 0 && i > 0) {
+                T k = static_cast<T>(i);
+                D[i][0] = v[i - 1] - (k + alpha - static_cast<T>(1)) * std::pow(k, -alpha);
+            } else if (j < i) {
+                std::size_t k = i - j;
+                D[i][j] = v[k + 1] + v[k - 1] - static_cast<T>(2) * v[k];
+            } else {
+                D[i][j] = T(0);
+            }
+        }
+    }
+
+    // Normalize by Gamma
+    T C = static_cast<T>(1) / std::tgamma(static_cast<T>(2) - alpha);
+
+    // Multiply D @ f_vals
+    std::vector<T> result(num_points, T(0));
+    for (std::size_t i = 0; i < num_points; ++i) {
+        T acc = T(0);
+        for (std::size_t j = 0; j < num_points; ++j) {
+            acc += D[i][j] * f_vals[j];
+        }
+        result[i] = C * std::pow(step, -alpha) * acc;
+    }
+    return result;
+}
+
+
+
+
+// Compute GL coefficients up to order n
+template <typename T>
+std::vector<T> GLcoeffs(T alpha, std::size_t n) {
+    // b[0] = 1
+    std::vector<T> b(n + 1, T(1));
+    for (std::size_t j = 1; j <= n; ++j) {
+        b[j] = b[j - 1] * (static_cast<T>(-alpha) + static_cast<T>(j - 1))
+               / static_cast<T>(j);
+    }
+    return b;
+}
+
+
+// GL at a single point (endpoint)
+template <typename T>
+T GLpoint(T alpha,
+          const std::vector<T>& f_vals,
+          T domain_start,
+          T domain_end,
+          std::size_t num_points) {
+    if (num_points < 1) {
+        throw std::invalid_argument("num_points must be at least 1");
+    }
+    if (domain_start > domain_end) {
+        std::swap(domain_start, domain_end);
+    }
+    if (f_vals.size() != num_points) {
+        throw std::invalid_argument("f_vals size must equal num_points");
+    }
+    T step = (domain_end - domain_start) / static_cast<T>(num_points - 1);
+    // Compute coefficients for k = num_points - 1
+    std::size_t k = num_points - 1;
+    auto b = GLcoeffs(alpha, k);
+    T acc = T(0);
+    for (std::size_t j = 0; j <= k; ++j) {
+        acc += b[j] * f_vals[k - j];
+    }
+    return std::pow(step, -alpha) * acc;
+}
+
+// GL over entire grid
+template <typename T>
+std::vector<T> GL(T alpha,
+                  const std::vector<T>& f_vals,
+                  T domain_start,
+                  T domain_end,
+                  std::size_t num_points) {
+    if (num_points < 1) {
+        throw std::invalid_argument("num_points must be at least 1");
+    }
+    if (domain_start > domain_end) {
+        std::swap(domain_start, domain_end);
+    }
+    if (f_vals.size() != num_points) {
+        throw std::invalid_argument("f_vals size must equal num_points");
+    }
+    T step = (domain_end - domain_start) / static_cast<T>(num_points - 1);
+    auto b = GLcoeffs(alpha, num_points - 1);
+    std::vector<T> result(num_points, T(0));
+    for (std::size_t i = 0; i < num_points; ++i) {
+        T acc = T(0);
+        // convolution-like sum
+        for (std::size_t j = 0; j <= i; ++j) {
+            acc += b[j] * f_vals[i - j];
+        }
+        result[i] = std::pow(step, -alpha) * acc;
+    }
+    return result;
+}
+
+
+// Explicit instantiations for double
+template double RLpoint<double>(double, const std::vector<double>&, double, double, std::size_t);
+template std::vector<double> RL<double>(double, const std::vector<double>&, double, double, std::size_t);
+template double GLpoint<double>(double, const std::vector<double>&, double, double, std::size_t);
+template std::vector<double> GL<double>(double, const std::vector<double>&, double, double, std::size_t);
+
+template std::vector<double> GLcoeffs<double>(double, std::size_t);
+
+
+
+
+} // namespace differint
+

differintc-0.1.0/src/differint/sanity.cpp

@@ -0,0 +1,50 @@
+#include <iostream>
+#include <vector>
+#include <cmath>
+#include "differint/differint.hpp"
+
+int main() {
+    double alpha = 0.5;
+    std::size_t n = 1000;
+    double a = 0.0, b = 1.0;
+
+    // sample f(x)=x^2
+    std::vector<double> vals(n);
+    for (std::size_t i = 0; i < n; ++i) {
+        double x = a + (b - a) * i / (n - 1);
+        vals[i] = x * x;
+    }
+
+    double num = differint::GLpoint(alpha, vals, a, b, n);
+    double exact = std::tgamma(3.0) / std::tgamma(3.0 - alpha);
+
+    std::cout << "GLpoint_num  = " << num << "\n"
+              << "GLpoint_exact= " << exact << "\n"
+              << "Error        = " << std::abs(num - exact) << "\n";
+
+    auto gl_vec = differint::RL(alpha, vals, a, b, n);
+    double gl_end = gl_vec.back();
+    std::cout << "\nGL.back()    = " << gl_end
+              << "\nGL_exact    = " << exact
+              << "\nError       = " << std::abs(gl_end - exact) << "\n";
+
+
+
+
+    // RLpoint test: f(x)=x^2 at endpoint
+    double rl_num = differint::RLpoint(alpha, vals, a, b, n);
+    double rl_exact = std::tgamma(3.0)/std::tgamma(3.0 - alpha);
+    std::cout << "\nRLpoint_num  = " << rl_num
+                << "\nRLpoint_exact= " << rl_exact
+                << "\nError        = " << std::abs(rl_num - rl_exact) << "\n";
+
+    auto rl_vec = differint::RL(alpha, vals, a, b, n);
+    double rl_end = rl_vec.back();
+    std::cout << "\nRL.back()    = " << rl_end
+              << "\nRL_exact    = " << exact
+              << "\nError       = " << std::abs(rl_end - exact) << "\n";
+
+    std::cout << "\nPress ENTER to exit...";
+    std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
+    return 0;
+}