differintC 0.0.1__cp313-cp313-win_amd64.whl

differintc-0.0.1.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,6 @@
+python/CMakeLists.txt,sha256=YH4PMGwp8NqUb5ZsKmOjtoRmwdjqAr9T8bcRf59sJcE,401
+python/module.cpp,sha256=2ptoCWNYUXnhYlJfxMm_q6NM66goo1lB9WV6mbysTF0,5663
+differintc-0.0.1.dist-info/METADATA,sha256=TPcJPxQPP4AAdefMQfHPLoj-i-IjFkDpx0ixQbe0rh8,3285
+differintc-0.0.1.dist-info/WHEEL,sha256=_PdgJ-W7uMAsWwnGnEdiicDU_PKcobRdffEM23gmN6g,106
+differintc-0.0.1.dist-info/licenses/LICENSE,sha256=jqB4xKqXwsqHxw3nhNfX51kOCtYhxNDQFqCIl5Qj8h4,1091
+differintc-0.0.1.dist-info/RECORD,,

differintc-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: scikit-build-core 0.11.5
+Root-Is-Purelib: false
+Tag: cp313-cp313-win_amd64
+

differintc-0.0.1.dist-info/licenses/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.

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)

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);
+
+}