differintC 0.0.1__tar.gz

differintc-0.0.1/.gitattributes

@@ -0,0 +1,2 @@
+# Auto detect text files and perform LF normalization
+* text=auto

differintc-0.0.1/.gitignore

@@ -0,0 +1,221 @@
+# C++
+####################################
+
+# Prerequisites
+*.d
+
+# Compiled Object files
+*.slo
+*.lo
+*.o
+*.obj
+
+# Precompiled Headers
+*.gch
+*.pch
+
+# Compiled Dynamic libraries
+*.so
+*.dylib
+*.dll
+
+# Fortran module files
+*.mod
+*.smod
+
+# Compiled Static libraries
+*.lai
+*.la
+*.a
+*.lib
+
+# Executables
+*.exe
+*.out
+*.app
+
+####################################
+# Python
+####################################
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Cursor
+#  Cursor is an AI-powered code editor.`.cursorignore` specifies files/directories to
+#  exclude from AI features like autocomplete and code analysis. Recommended for sensitive data
+#  refer to https://docs.cursor.com/context/ignore-files
+.cursorignore
+.cursorindexingignore

differintc-0.0.1/CHANGELOG.md

@@ -0,0 +1 @@
+0.0.1: (6/30/2025) First working Version

differintc-0.0.1/CMakeLists.txt

@@ -0,0 +1,22 @@
+cmake_minimum_required(VERSION 3.15)
+
+project(differintC VERSION 0.1 LANGUAGES CXX)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+# Pybind11
+include(FetchContent)
+FetchContent_Declare(
+  pybind11
+  GIT_REPOSITORY https://github.com/pybind/pybind11.git
+  GIT_TAG        v2.11.0
+)
+FetchContent_MakeAvailable(pybind11)
+
+# Core C++ Library
+add_library(differint_core src/differint.cpp)
+target_include_directories(differint_core PUBLIC ${CMAKE_SOURCE_DIR}/include)
+
+# Add Python bindings
+add_subdirectory(python)

differintc-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 parsa roshanak
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

differintc-0.0.1/PKG-INFO

@@ -0,0 +1,98 @@
+Metadata-Version: 2.2
+Name: differintC
+Version: 0.0.1
+Summary: Fast C++ implementation of fractional calculus operators via pybind11
+Author: Parsa Roshanak
+License: MIT
+Classifier: Development Status :: 3 - Alpha
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: C++
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Intended Audience :: Science/Research
+Project-URL: Homepage, https://github.com/iparsw/differintC
+Project-URL: Repository, https://github.com/iparsw/differintC
+Project-URL: Issues, https://github.com/iparsw/differintC/issues
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# differintC
+
+`differintC` is a high-performance C++ library with Python bindings for computing fractional differintegrals (derivatives and integrals of arbitrary real order) using numerical methods.
+
+This package implements optimized versions of the Riemann–Liouville and Grünwald–Letnikov (GL) fractional differintegral operators, inspired by the original [DifferInt project](https://placeholder-link-to-original-differint-project).
+
+> ⚙️ Built with modern C++17 and exposed to Python via `pybind11`, this library is significantly faster than pure-Python equivalents, especially for large arrays and high-precision needs.
+
+---
+
+## 📦 Installation
+
+```bash
+pip install differintC
+````
+
+To build from source:
+
+```bash
+git clone https://github.com/your-username/differintC-project.git
+cd differintC-project
+pip install .
+```
+
+---
+
+## 🚀 Usage
+
+```python
+from differintC import RLpoint, RL, GLpoint, GL
+
+# Example 1: Riemann–Liouville at a single point
+result = RLpoint(0.5, lambda x: x**2)
+print("RLpoint(0.5, x^2) =", result)
+
+# Example 2: RL on a whole domain
+import numpy as np
+x = np.linspace(0, 1, 100)
+f = x**2
+out = RL(0.5, f)
+
+# Example 3: Grünwald–Letnikov pointwise
+gl_res = GLpoint(0.5, lambda x: np.sqrt(x))
+
+# Example 4: Full array version (fastest)
+gl_array = GL(0.5, lambda x: np.sqrt(x))
+```
+
+All functions support either a NumPy array or a Python callable as the `f_name` argument.
+
+---
+
+## 📚 Implemented Functions
+
+| Function  | Description                                 |
+| --------- | ------------------------------------------- |
+| `RLpoint` | Riemann–Liouville differintegral at a point |
+| `RL`      | RL differintegral over a uniform domain     |
+| `GLpoint` | Grünwald–Letnikov at a point (optimized)    |
+| `GL`      | Vectorized GL differintegral with FFT       |
+
+---
+
+## ⚖️ License and Credits
+
+This package was inspired by and based on the original [`DifferInt`](https://placeholder-link-to-original-differint-project) project. We thank the authors for their foundational work in fractional calculus.
+
+Licensed under MIT.
+
+---
+
+## 🛠 Development Notes
+
+See the [todo list 1](https://github.com/your-username/differintC-project/issues/1) for the development roadmap and planned features. Contributions are welcome.

differintc-0.0.1/README.MD

@@ -0,0 +1,74 @@
+# differintC
+
+`differintC` is a high-performance C++ library with Python bindings for computing fractional differintegrals (derivatives and integrals of arbitrary real order) using numerical methods.
+
+This package implements optimized versions of the Riemann–Liouville and Grünwald–Letnikov (GL) fractional differintegral operators, inspired by the original [DifferInt project](https://placeholder-link-to-original-differint-project).
+
+> ⚙️ Built with modern C++17 and exposed to Python via `pybind11`, this library is significantly faster than pure-Python equivalents, especially for large arrays and high-precision needs.
+
+---
+
+## 📦 Installation
+
+```bash
+pip install differintC
+````
+
+To build from source:
+
+```bash
+git clone https://github.com/your-username/differintC-project.git
+cd differintC-project
+pip install .
+```
+
+---
+
+## 🚀 Usage
+
+```python
+from differintC import RLpoint, RL, GLpoint, GL
+
+# Example 1: Riemann–Liouville at a single point
+result = RLpoint(0.5, lambda x: x**2)
+print("RLpoint(0.5, x^2) =", result)
+
+# Example 2: RL on a whole domain
+import numpy as np
+x = np.linspace(0, 1, 100)
+f = x**2
+out = RL(0.5, f)
+
+# Example 3: Grünwald–Letnikov pointwise
+gl_res = GLpoint(0.5, lambda x: np.sqrt(x))
+
+# Example 4: Full array version (fastest)
+gl_array = GL(0.5, lambda x: np.sqrt(x))
+```
+
+All functions support either a NumPy array or a Python callable as the `f_name` argument.
+
+---
+
+## 📚 Implemented Functions
+
+| Function  | Description                                 |
+| --------- | ------------------------------------------- |
+| `RLpoint` | Riemann–Liouville differintegral at a point |
+| `RL`      | RL differintegral over a uniform domain     |
+| `GLpoint` | Grünwald–Letnikov at a point (optimized)    |
+| `GL`      | Vectorized GL differintegral with FFT       |
+
+---
+
+## ⚖️ License and Credits
+
+This package was inspired by and based on the original [`DifferInt`](https://placeholder-link-to-original-differint-project) project. We thank the authors for their foundational work in fractional calculus.
+
+Licensed under MIT.
+
+---
+
+## 🛠 Development Notes
+
+See the [todo list 1](https://github.com/your-username/differintC-project/issues/1) for the development roadmap and planned features. Contributions are welcome.

differintc-0.0.1/include/differint.hpp

@@ -0,0 +1,28 @@
+#pragma once
+
+#include <vector>
+#include <cstddef>
+
+
+namespace differint {
+
+// Templated versions
+template <typename T>
+std::vector<T> GL(T alpha, const std::vector<T>& f_vals, T a, T b, std::size_t N);
+
+template <typename T>
+std::vector<T> RL(T alpha, const std::vector<T>& f_vals, T a, T b, std::size_t N);
+
+template <typename T>
+T GLpoint(T alpha, const std::vector<T>& f_vals, T a, T b, std::size_t N);
+
+template <typename T>
+T RLpoint(T alpha, const std::vector<T>& f_vals, T a, T b, std::size_t N);
+
+// Concrete declarations for pybind11 linkage
+std::vector<double> GL(double alpha, const std::vector<double>& f_vals, double a, double b, std::size_t N);
+std::vector<double> RL(double alpha, const std::vector<double>& f_vals, double a, double b, std::size_t N);
+double GLpoint(double alpha, const std::vector<double>& f_vals, double a, double b, std::size_t N);
+double RLpoint(double alpha, const std::vector<double>& f_vals, double a, double b, std::size_t N);
+
+}

differintc-0.0.1/pyproject.toml

@@ -0,0 +1,47 @@
+[build-system]
+requires = [
+    "scikit-build-core>=0.5.1",  # or latest known stable
+    "pybind11>=2.10",
+    "setuptools",                # required by many tools
+    "wheel"                      # for building wheels
+]
+build-backend = "scikit_build_core.build"
+
+[project]
+name = "differintC"
+version = "0.0.1"
+description = "Fast C++ implementation of fractional calculus operators via pybind11"
+authors = [{ name = "Parsa Roshanak" }]
+license = { text = "MIT" }
+readme = "README.md"
+requires-python = ">=3.8"
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: C++",
+    "Topic :: Scientific/Engineering :: Mathematics",
+    "Intended Audience :: Science/Research"
+]
+
+[project.urls]
+Homepage = "https://github.com/iparsw/differintC"
+Repository = "https://github.com/iparsw/differintC"
+Issues = "https://github.com/iparsw/differintC/issues"
+
+[tool.scikit-build]
+wheel.packages = ["python"]     # The folder where your .py and .cpp binding is
+build-dir = "build"             # Optional: place build here
+cmake.verbose = true            # Optional: for easier debugging
+sdist.include = ["src", "include", "python", "README.md", "LICENSE", "CMakeLists.txt"]
+install.components = ["python"] # Only install the pybind11 module, not dev headers
+
+# Optional: make version dynamic from a single file (uncomment when ready)
+# [tool.setuptools.dynamic]
+# version = { file = "python/_version.py" }

differintc-0.0.1/python/CMakeLists.txt

@@ -0,0 +1,17 @@
+pybind11_add_module(differintC module.cpp ../src/differint.cpp)
+
+target_include_directories(differintC
+    PRIVATE ${CMAKE_SOURCE_DIR}/include
+)
+
+target_link_libraries(differintC
+    PRIVATE differint_core
+)
+
+set_target_properties(differintC PROPERTIES
+    PREFIX ""
+    SUFFIX ".pyd"
+)
+
+install(TARGETS differintC
+        LIBRARY DESTINATION ${CMAKE_INSTALL_PREFIX}/Lib/site-packages)

differintc-0.0.1/python/module.cpp

@@ -0,0 +1,110 @@
+#include <pybind11/stl.h>
+#include <pybind11/pybind11.h>
+#include <pybind11/numpy.h>
+#include <vector>
+#include <stdexcept>
+
+namespace py = pybind11;
+
+namespace differint {
+    std::vector<double> RL(double, const std::vector<double>&, double, double, size_t);
+    double RLpoint(double, const std::vector<double>&, double, double, size_t);
+    std::vector<double> GL(double, const std::vector<double>&, double, double, size_t);
+    double GLpoint(double, const std::vector<double>&, double, double, size_t);
+}
+using namespace differint;
+
+
+
+// Helper to sample a Python callable into a std::vector<double>
+template <typename Func>
+std::vector<double> call_and_sample(Func&& f, double a, double b, size_t n) {
+    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;
+}
+
+// Overload 1: Input is a NumPy array or list (accept py::array_t<double>)
+std::vector<double> prepare_fvals(py::array_t<double> arr, size_t expected_size) {
+    if (arr.size() != expected_size)
+        throw std::runtime_error("Input array length must equal num_points");
+    // Copy data from NumPy array (you could do zero-copy with caution, but copying is safer here)
+    std::vector<double> v(arr.size());
+    std::memcpy(v.data(), arr.data(), sizeof(double) * arr.size());
+    return v;
+}
+
+// Overload 2: Input is a Python callable (py::function)
+std::vector<double> prepare_fvals(py::function func, double a, double b, size_t n) {
+    return call_and_sample([&func](double x) {
+        return func(x).cast<double>();
+    }, a, b, n);
+}
+
+
+
+
+
+PYBIND11_MODULE(differintC, m) {
+    m.doc() = "Fast fractional calculus operators in C++ with Python bindings";
+
+    // RL (whole array)
+    m.def("RL", [](double alpha, py::object f, double domain_start, double domain_end, size_t num_points) {
+        // Dispatch based on type
+        if (py::isinstance<py::array>(f)) {
+            return RL(alpha, prepare_fvals(f.cast<py::array_t<double>>(), num_points), domain_start, domain_end, num_points);
+        } else if (py::isinstance<py::function>(f)) {
+            return RL(alpha, prepare_fvals(f.cast<py::function>(), domain_start, domain_end, num_points), domain_start, domain_end, num_points);
+        } else if (py::isinstance<py::list>(f)) {
+            // treat list as array
+            return RL(alpha, prepare_fvals(f.cast<py::array_t<double>>(), num_points), domain_start, domain_end, num_points);
+        } else {
+            throw std::runtime_error("Unsupported input type for function f");
+        }
+    }, py::arg("alpha"), py::arg("f"), py::arg("domain_start") = 0.0, py::arg("domain_end") = 1.0, py::arg("num_points") = 100);
+
+    // RLpoint (single point)
+    m.def("RLpoint", [](double alpha, py::object f, double domain_start, double domain_end, size_t num_points) {
+        if (py::isinstance<py::array>(f)) {
+            return RLpoint(alpha, prepare_fvals(f.cast<py::array_t<double>>(), num_points), domain_start, domain_end, num_points);
+        } else if (py::isinstance<py::function>(f)) {
+            return RLpoint(alpha, prepare_fvals(f.cast<py::function>(), domain_start, domain_end, num_points), domain_start, domain_end, num_points);
+        } else if (py::isinstance<py::list>(f)) {
+            return RLpoint(alpha, prepare_fvals(f.cast<py::array_t<double>>(), num_points), domain_start, domain_end, num_points);
+        } else {
+            throw std::runtime_error("Unsupported input type for function f");
+        }
+    }, py::arg("alpha"), py::arg("f"), 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 domain_start, double domain_end, size_t num_points) {
+        // Dispatch based on type
+        if (py::isinstance<py::array>(f)) {
+            return GL(alpha, prepare_fvals(f.cast<py::array_t<double>>(), num_points), domain_start, domain_end, num_points);
+        } else if (py::isinstance<py::function>(f)) {
+            return GL(alpha, prepare_fvals(f.cast<py::function>(), domain_start, domain_end, num_points), domain_start, domain_end, num_points);
+        } else if (py::isinstance<py::list>(f)) {
+            // treat list as array
+            return GL(alpha, prepare_fvals(f.cast<py::array_t<double>>(), num_points), domain_start, domain_end, num_points);
+        } else {
+            throw std::runtime_error("Unsupported input type for function f");
+        }
+    }, py::arg("alpha"), py::arg("f"), py::arg("domain_start") = 0.0, py::arg("domain_end") = 1.0, py::arg("num_points") = 100);
+
+    // GLpoint (single point)
+    m.def("GLpoint", [](double alpha, py::object f, double domain_start, double domain_end, size_t num_points) {
+        if (py::isinstance<py::array>(f)) {
+            return GLpoint(alpha, prepare_fvals(f.cast<py::array_t<double>>(), num_points), domain_start, domain_end, num_points);
+        } else if (py::isinstance<py::function>(f)) {
+            return GLpoint(alpha, prepare_fvals(f.cast<py::function>(), domain_start, domain_end, num_points), domain_start, domain_end, num_points);
+        } else if (py::isinstance<py::list>(f)) {
+            return GLpoint(alpha, prepare_fvals(f.cast<py::array_t<double>>(), num_points), domain_start, domain_end, num_points);
+        } else {
+            throw std::runtime_error("Unsupported input type for function f");
+        }
+    }, py::arg("alpha"), py::arg("f"), py::arg("domain_start") = 0.0, py::arg("domain_end") = 1.0, py::arg("num_points") = 100);
+
+}

differintc-0.0.1/src/differint.cpp

@@ -0,0 +1,220 @@
+#include "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;
+}
+
+
+} // namespace differint
+
+// Explicit instantiations for double
+template std::vector<double> differint::GL<double>(double, const std::vector<double>&, double, double, std::size_t);
+template std::vector<double> differint::RL<double>(double, const std::vector<double>&, double, double, std::size_t);
+template double differint::GLpoint<double>(double, const std::vector<double>&, double, double, std::size_t);
+template double differint::RLpoint<double>(double, const std::vector<double>&, double, double, std::size_t);
+template std::vector<double> differint::GLcoeffs<double>(double, std::size_t);
+
+
+// Expose concrete symbols
+namespace differint {
+    std::vector<double> GL(double alpha, const std::vector<double>& f_vals, double a, double b, std::size_t N) {
+        return GL<double>(alpha, f_vals, a, b, N);
+    }
+    std::vector<double> RL(double alpha, const std::vector<double>& f_vals, double a, double b, std::size_t N) {
+        return RL<double>(alpha, f_vals, a, b, N);
+    }
+    double GLpoint(double alpha, const std::vector<double>& f_vals, double a, double b, std::size_t N) {
+        return GLpoint<double>(alpha, f_vals, a, b, N);
+    }
+    double RLpoint(double alpha, const std::vector<double>& f_vals, double a, double b, std::size_t N) {
+        return RLpoint<double>(alpha, f_vals, a, b, N);
+    }
+}

differintc-0.0.1/todo.md

@@ -0,0 +1,84 @@
+# Todo List 1 (6/30/2025) (AI Generated)
+
+---
+
+### ✅ Immediate TODOs (essential for adding new functions)
+
+These are required for each additional fractional differintegral method you want to port:
+
+#### For each new C++ function:
+
+1. **`include/differint/differint.hpp`**
+
+   * Add the `template <typename T> T|std::vector<T> FunctionName(...)` declaration.
+
+2. **`src/differint/differint.cpp`**
+
+   * Implement the function.
+   * Add `template` instantiation at the bottom:
+     `template double FunctionName<double>(...);`
+
+3. **`python/module.cpp`**
+
+   * Bind the function to Python using `m.def(...)`.
+
+4. **Optional: `src/differint/sanity.cpp`**
+
+   * Add a manual C++ test to verify numeric accuracy.
+
+---
+
+### 📦 Packaging & Distribution
+
+* ~~**Add `README.md` and `LICENSE` files** in the root for PyPI display.~~
+* [ ] **Set versioning strategy** (e.g., `semver`, calendar versioning).
+* ~~**Add a `setup.cfg` or more advanced `pyproject.toml`** with classifiers, long description from `README.md`, etc.~~
+
+---
+
+### 🧪 Usability Improvements
+
+* [ ] **Support `Callable` Python functions directly** via `py::function` overloads.
+
+  * This will let users call C++ methods with `lambda x: ...` directly.
+  * Requires defining Python overloads (already mostly done).
+
+* [ ] **Add NumPy array support directly via `py::array_t<double>`**:
+
+  * Improves interop and reduces unnecessary Python → C++ copies.
+
+---
+
+### 🧹 Code Quality & Developer Experience
+
+* [ ] **Add CMake options to toggle building:**
+
+  * `DIFFERINT_BUILD_SANITY`
+  * `DIFFERINT_BUILD_PYTHON`
+  * Cleaner, configurable builds.
+
+* [ ] **Write a test script in Python**:
+
+  * `tests/test_rl.py` with assertions
+  * Could use `pytest` later, but start with simple scripts
+
+* [ ] **Add Doxygen-style comments** to your headers
+
+  * Enables future documentation generation.
+
+---
+
+### 📘 Longer-Term / Optional
+
+* [ ] **Benchmarking tools** for RL vs GL methods.
+* [ ] **CI/CD automation** (GitHub Actions or similar for testing + PyPI deploy).
+* [ ] **Optional GUI or CLI** interface for experimentation.
+* [ ] **Add support for complex-valued functions** if useful.
+* [ ] **Support mixed precision or `float`, `long double`**, if needed.
+
+---
+
+Would you like to continue by:
+
+* Implementing the next function (e.g., `GLpoint`)
+* Or tackling one of the improvements from above (e.g., better Python interop)?