square-rulerpack-native 0.2.0__tar.gz

square_rulerpack_native-0.2.0/Cargo.lock

@@ -0,0 +1,249 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "autocfg"
+version = "1.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53"
+
+[[package]]
+name = "crossbeam-deque"
+version = "0.8.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "622f3fc73690be383c7214310406f28a90e6edeadc3cea882f9d71e495b9711a"
+dependencies = [
+ "crossbeam-epoch",
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-epoch"
+version = "0.9.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc74980687109a3b14c72fd458107bf0baa1da1a1a805e178d15501ba9b86d9d"
+dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-utils"
+version = "0.8.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a31eee39dddec8330830986fcd7625edb5a24ec90ea038215273bbc3adb08ac6"
+
+[[package]]
+name = "either"
+version = "1.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0e9c71c2167ca323c882b99918929403426e2373ea17242ff5653e0d5e1058be"
+
+[[package]]
+name = "heck"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
+
+[[package]]
+name = "libc"
+version = "0.2.191"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "65cd87c9a6d60536580b316ad985726104730a5151c99845f2490428ef91240a"
+
+[[package]]
+name = "num-bigint"
+version = "0.4.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c89e69e7e0f03bea5ef08013795c25018e101932225a656383bd384495ecc367"
+dependencies = [
+ "num-integer",
+ "num-traits",
+]
+
+[[package]]
+name = "num-integer"
+version = "0.1.47"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7ce2d95d4b3734dc35aa2f45e1aa22cd416814592a4f9d9205e11affd5b8e10b"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "num-traits"
+version = "0.2.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.21.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
+
+[[package]]
+name = "portable-atomic"
+version = "1.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05c8b63e8d9609db387f0324918f81d68fe27748f084ef092fb35954d0539a85"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.107"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "985e7ec9bb745e6ce6535b544d84d6cd6f7ad8bd711c398938ae983b91a766d9"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "pyo3"
+version = "0.30.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "229ca13b8a15bb0d1487b81ab975bfcd97513416499a8312011b6036e42e0de4"
+dependencies = [
+ "libc",
+ "num-bigint",
+ "num-traits",
+ "once_cell",
+ "portable-atomic",
+ "pyo3-build-config",
+ "pyo3-ffi",
+ "pyo3-macros",
+]
+
+[[package]]
+name = "pyo3-build-config"
+version = "0.30.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "70130e2b6dd1ee589a8788026a429561ca5c40fa7a2fa7914c2282eddae24700"
+dependencies = [
+ "target-lexicon",
+]
+
+[[package]]
+name = "pyo3-ffi"
+version = "0.30.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e7ff73c555c286d212d4ce7e5fbda845a973c4f61bd5f160f5f2c3c2a04d1c4"
+dependencies = [
+ "libc",
+ "pyo3-build-config",
+]
+
+[[package]]
+name = "pyo3-macros"
+version = "0.30.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c46d2e5862c7bb8207e3b639f713dda3c499933444784154c11d013c5a691b60"
+dependencies = [
+ "proc-macro2",
+ "pyo3-macros-backend",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "pyo3-macros-backend"
+version = "0.30.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "38b89f066f2ae72a2aef52d1537ca2fcd104440ebfadee06e97aa90738a25b9b"
+dependencies = [
+ "heck",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.47"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fbf4db142a473a8d80c26bbf18454ed458bf8d26c8219c331daecfdbd079001"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "rayon"
+version = "1.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fb39b166781f92d482534ef4b4b1b2568f42613b53e5b6c160e24cfbfa30926d"
+dependencies = [
+ "either",
+ "rayon-core",
+]
+
+[[package]]
+name = "rayon-core"
+version = "1.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "22e18b0f0062d30d4230b2e85ff77fdfe4326feb054b9783a3460d8435c8ab91"
+dependencies = [
+ "crossbeam-deque",
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "rulerpack"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5719c79cb15f909462649c00e447e222e20d79fd14b193882800679872b42cc3"
+dependencies = [
+ "num-bigint",
+ "num-integer",
+ "num-traits",
+ "rayon",
+]
+
+[[package]]
+name = "square-rulerpack"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ed52ed5e1dc61c06ad2e25fa633abc9bd7fda94c5357d7b7802d18c5a5e6935"
+dependencies = [
+ "num-bigint",
+ "num-integer",
+ "num-traits",
+ "rayon",
+ "rulerpack",
+]
+
+[[package]]
+name = "square-rulerpack-native"
+version = "0.2.0"
+dependencies = [
+ "num-bigint",
+ "num-traits",
+ "pyo3",
+ "rayon",
+ "rulerpack",
+ "square-rulerpack",
+]
+
+[[package]]
+name = "syn"
+version = "3.0.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ae9ccbea3a7b0b09443036490c8f34a8b1b760fd345e5c0dae0aac718faea79"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "target-lexicon"
+version = "0.13.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8c447be3a2abfa84b2d91680c56600bd6b2873866de27b36ec911be705e291da"
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a2c754d6c33795a1c324727428e5a7dedb5b06195f9890bdbcba760d3e246563"

square_rulerpack_native-0.2.0/Cargo.toml

@@ -0,0 +1,26 @@
+[package]
+name = "square-rulerpack-native"
+version = "0.2.0"
+edition = "2021"
+license = "MIT"
+description = "Lars Rocha's square-rulerpack quadratic sieve (Rust) as a Python extension module."
+repository = "https://github.com/oppressionslayer/square-rulerpack-py"
+authors = ["Lars Rocha"]
+readme = "README.md"
+
+[lib]
+name = "square_rulerpack_native"
+crate-type = ["cdylib"]
+
+[dependencies]
+pyo3 = { version = "0.30", features = ["extension-module", "abi3-py310", "num-bigint"] }
+square-rulerpack = "0.2.0"
+rulerpack = { version = "0.3.1", features = ["big"] }
+num-bigint = "0.4"
+num-traits = "0.2"
+rayon = "1"
+
+[profile.release]
+opt-level = 3
+lto = "thin"
+codegen-units = 1

square_rulerpack_native-0.2.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Lars Rocha
+
+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.

square_rulerpack_native-0.2.0/PKG-INFO

@@ -0,0 +1,54 @@
+Metadata-Version: 2.4
+Name: square-rulerpack-native
+Version: 0.2.0
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Rust
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+License-File: LICENSE
+Summary: Lars Rocha's square-rulerpack quadratic sieve (Rust, double large primes, AVX2) compiled as a Python extension: factor 40-100 digit numbers from Python at native speed.
+Keywords: quadratic-sieve,siqs,factorization,number-theory,rust,pyo3
+Author: Lars Rocha
+License-Expression: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: Homepage, https://github.com/oppressionslayer/square-rulerpack-py
+Project-URL: Pure Python package, https://pypi.org/project/square-rulerpack/
+Project-URL: Rust crate, https://crates.io/crates/square-rulerpack
+
+# square-rulerpack-native
+
+Lars Rocha's [square-rulerpack](https://crates.io/crates/square-rulerpack) factoring engine
+(self-initialising quadratic sieve with double large primes, AVX2 kernels, rayon threads, in Rust)
+compiled as a Python extension module with PyO3. It is the fast path of the pure-Python
+[square-rulerpack](https://pypi.org/project/square-rulerpack/) package, which does the teaching;
+this module does the factoring.
+
+```sh
+pip install square-rulerpack[native]      # or: pip install square-rulerpack-native
+```
+
+```python
+import square_rulerpack_native as srn
+srn.factor_completely(50726044447758565750355444206008211963939957754977146054012847169421070122136537, threads=8)
+srn.factor(n, threads=8)                  # one nontrivial factor from the sieve, or None
+srn.is_prime(2**61 - 1)                   # strong probable-prime test
+srn.factor_completely(n, threads=8, progress=lambda stage, full, need, partials, polys: print(stage, full, need))
+```
+
+Through the pure package it is the default engine once installed:
+
+```python
+import square_rulerpack as sq
+sq.factor_completely(n, workers=8)        # engine="auto": Rust when installed, Python otherwise
+```
+
+Python ints cross as big integers (no string round trip). The GIL is released while the sieve
+runs; Ctrl-C does not interrupt it. The engine's switches (`SIQS_Q2`, `SIQS_SMALL`, `SIQS_EXACT`,
+`SIQS_DLP`, …) are read from the environment at call time, exactly as the Rust CLI reads them;
+the pure package sets them from its `Settings`. Wheels are abi3 (one wheel per platform for
+every Python ≥ 3.10); building from the sdist needs a Rust toolchain.
+
+MIT, as the crate.
+

square_rulerpack_native-0.2.0/README.md

@@ -0,0 +1,34 @@
+# square-rulerpack-native
+
+Lars Rocha's [square-rulerpack](https://crates.io/crates/square-rulerpack) factoring engine
+(self-initialising quadratic sieve with double large primes, AVX2 kernels, rayon threads, in Rust)
+compiled as a Python extension module with PyO3. It is the fast path of the pure-Python
+[square-rulerpack](https://pypi.org/project/square-rulerpack/) package, which does the teaching;
+this module does the factoring.
+
+```sh
+pip install square-rulerpack[native]      # or: pip install square-rulerpack-native
+```
+
+```python
+import square_rulerpack_native as srn
+srn.factor_completely(50726044447758565750355444206008211963939957754977146054012847169421070122136537, threads=8)
+srn.factor(n, threads=8)                  # one nontrivial factor from the sieve, or None
+srn.is_prime(2**61 - 1)                   # strong probable-prime test
+srn.factor_completely(n, threads=8, progress=lambda stage, full, need, partials, polys: print(stage, full, need))
+```
+
+Through the pure package it is the default engine once installed:
+
+```python
+import square_rulerpack as sq
+sq.factor_completely(n, workers=8)        # engine="auto": Rust when installed, Python otherwise
+```
+
+Python ints cross as big integers (no string round trip). The GIL is released while the sieve
+runs; Ctrl-C does not interrupt it. The engine's switches (`SIQS_Q2`, `SIQS_SMALL`, `SIQS_EXACT`,
+`SIQS_DLP`, …) are read from the environment at call time, exactly as the Rust CLI reads them;
+the pure package sets them from its `Settings`. Wheels are abi3 (one wheel per platform for
+every Python ≥ 3.10); building from the sdist needs a Rust toolchain.
+
+MIT, as the crate.

square_rulerpack_native-0.2.0/pyproject.toml

@@ -0,0 +1,31 @@
+[build-system]
+requires = ["maturin>=1.7,<2.0"]
+build-backend = "maturin"
+
+[project]
+name = "square-rulerpack-native"
+version = "0.2.0"
+description = "Lars Rocha's square-rulerpack quadratic sieve (Rust, double large primes, AVX2) compiled as a Python extension: factor 40-100 digit numbers from Python at native speed."
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{name = "Lars Rocha"}]
+keywords = ["quadratic-sieve", "siqs", "factorization", "number-theory", "rust", "pyo3"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Science/Research",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Rust",
+    "Topic :: Scientific/Engineering :: Mathematics",
+]
+
+[project.urls]
+Homepage = "https://github.com/oppressionslayer/square-rulerpack-py"
+"Rust crate" = "https://crates.io/crates/square-rulerpack"
+"Pure Python package" = "https://pypi.org/project/square-rulerpack/"
+
+[tool.maturin]
+module-name = "square_rulerpack_native"
+features = ["pyo3/extension-module"]
+strip = true

square_rulerpack_native-0.2.0/src/lib.rs

@@ -0,0 +1,156 @@
+//! square-rulerpack for Python. Python ints cross as `BigUint` (pyo3's `num-bigint` feature), the
+//! sieve runs with the GIL released on a rayon pool of the requested size, and the engine's
+//! progress hook can call back into Python.
+//!
+//! The engine reads its switches (`SIQS_Q2`, `SIQS_SMALL`, `SIQS_EXACT`, …) from the process
+//! environment at call time; the pure-Python package sets them from its `Settings` before calling.
+use std::sync::Mutex;
+
+use num_bigint::BigUint;
+use num_traits::{One, Zero};
+use pyo3::exceptions::{PyRuntimeError, PyValueError};
+use pyo3::prelude::*;
+
+/// The Python callable the progress hook forwards to (set for the duration of one call).
+static PROGRESS: Mutex<Option<Py<PyAny>>> = Mutex::new(None);
+
+/// The engine's hook is a plain `fn` pointer kept in a thread-local, so it fires on the thread
+/// that called `factor`; that thread has released the GIL, so we re-attach to call Python.
+fn py_hook(stage: u32, full: usize, need: usize, partials: usize, polys: usize) {
+    let cb = PROGRESS.lock().ok().and_then(|g| g.as_ref().map(|c| c.clone_ref_detached()));
+    if let Some(cb) = cb {
+        Python::attach(|py| {
+            if let Err(e) = cb.call1(py, (stage, full, need, partials, polys)) {
+                e.print(py);
+            }
+        });
+    }
+}
+
+trait CloneDetached {
+    fn clone_ref_detached(&self) -> Py<PyAny>;
+}
+impl CloneDetached for Py<PyAny> {
+    fn clone_ref_detached(&self) -> Py<PyAny> {
+        Python::attach(|py| self.clone_ref(py))
+    }
+}
+
+fn pool(threads: Option<usize>) -> PyResult<rayon::ThreadPool> {
+    let t = match threads {
+        Some(0) | None => std::thread::available_parallelism().map(|n| (n.get() / 2).max(1)).unwrap_or(1),
+        Some(t) => t,
+    };
+    rayon::ThreadPoolBuilder::new()
+        .num_threads(t)
+        .build()
+        .map_err(|e| PyRuntimeError::new_err(format!("rayon pool: {e}")))
+}
+
+fn with_progress<T>(py: Python<'_>, progress: Option<Py<PyAny>>, threads: Option<usize>,
+                    f: impl FnOnce() -> T + Send) -> PyResult<T>
+where
+    T: Send,
+{
+    let pool = pool(threads)?;
+    let hooked = progress.is_some();
+    if let Some(cb) = progress {
+        *PROGRESS.lock().map_err(|_| PyRuntimeError::new_err("progress lock"))? = Some(cb);
+    }
+    let out = py.detach(|| {
+        pool.install(|| {
+            if hooked {
+                square_rulerpack::siqs::set_progress_hook(Some(py_hook));
+            }
+            let r = f();
+            square_rulerpack::siqs::set_progress_hook(None);
+            r
+        })
+    });
+    if hooked {
+        if let Ok(mut g) = PROGRESS.lock() {
+            *g = None;
+        }
+    }
+    Ok(out)
+}
+
+fn check(n: &BigUint) -> PyResult<()> {
+    if n.is_zero() {
+        return Err(PyValueError::new_err("n must be a positive integer"));
+    }
+    Ok(())
+}
+
+/// The complete factorisation of n: sorted prime factors with multiplicity (small primes by
+/// trial division, perfect powers, then the self-initialising quadratic sieve on every composite
+/// piece). `threads` is the rayon pool size (default half the hardware threads). `progress`, if
+/// given, is called as progress(stage, full, need, partials, polys) with stage 0 preparing,
+/// 1 collecting, 2 matrix, 3 square root. The GIL is released while the sieve runs; Ctrl-C does
+/// not interrupt it.
+#[pyfunction]
+#[pyo3(signature = (n, threads=None, progress=None))]
+fn factor_completely(py: Python<'_>, n: BigUint, threads: Option<usize>, progress: Option<Py<PyAny>>) -> PyResult<Vec<BigUint>> {
+    check(&n)?;
+    if n.is_one() {
+        return Ok(vec![]);
+    }
+    with_progress(py, progress, threads, move || square_rulerpack::siqs::factor_completely(&n))
+}
+
+/// One nontrivial factor of n from the sieve alone, or None (prime, a prime power the sieve
+/// does not handle, too small, or unlucky). Use `factor_completely` for the whole factorisation.
+#[pyfunction]
+#[pyo3(signature = (n, threads=None, progress=None))]
+fn factor(py: Python<'_>, n: BigUint, threads: Option<usize>, progress: Option<Py<PyAny>>) -> PyResult<Option<BigUint>> {
+    check(&n)?;
+    with_progress(py, progress, threads, move || square_rulerpack::siqs::factor(&n))
+}
+
+/// Primality: deterministic Miller–Rabin below 2^64 (the engine's `is_prime_u64`), rulerpack's
+/// strong probable-prime test above. (rulerpack 0.3.1's `is_prime_big` returns false for the
+/// primes it uses as witnesses, 2..37, so small n must not go through it.)
+#[pyfunction]
+fn is_prime(n: BigUint) -> bool {
+    match u64::try_from(&n) {
+        Ok(v) => square_rulerpack::siqs::is_prime_u64(v),
+        Err(_) => rulerpack::big::is_prime_big(&n),
+    }
+}
+
+/// The version of this binding.
+#[pyfunction]
+fn version() -> &'static str {
+    env!("CARGO_PKG_VERSION")
+}
+
+/// The version of the square-rulerpack engine crate linked in.
+#[pyfunction]
+fn engine_version() -> &'static str {
+    "0.2.0"
+}
+
+/// Whether the engine will use its AVX2 kernels on this machine.
+#[pyfunction]
+fn have_avx2() -> bool {
+    #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
+    {
+        std::env::var("SIQS_NO_AVX2").is_err() && std::arch::is_x86_feature_detected!("avx2")
+    }
+    #[cfg(not(any(target_arch = "x86", target_arch = "x86_64")))]
+    {
+        false
+    }
+}
+
+#[pymodule]
+fn square_rulerpack_native(m: &Bound<'_, PyModule>) -> PyResult<()> {
+    m.add_function(wrap_pyfunction!(factor_completely, m)?)?;
+    m.add_function(wrap_pyfunction!(factor, m)?)?;
+    m.add_function(wrap_pyfunction!(is_prime, m)?)?;
+    m.add_function(wrap_pyfunction!(version, m)?)?;
+    m.add_function(wrap_pyfunction!(engine_version, m)?)?;
+    m.add_function(wrap_pyfunction!(have_avx2, m)?)?;
+    m.add("__version__", env!("CARGO_PKG_VERSION"))?;
+    Ok(())
+}