Conversation
added 2 commits
June 26, 2026 17:35
cmpute
commented
Jun 26, 2026
AbsEq was folded into AbsOrd and removed in Phase 1 (not merely deprecated); reword the §5.3 parenthetical to match. Co-Authored-By: Claude <noreply@anthropic.com>
TODO-v05.md: - Note the full C <tgmath.h> type-generic math surface as a long-term goal, explicitly out of scope for 0.5 and 0.5.x. TODO-cmplx.md: - unwrap_cfp: define dashu-cmplx's own Context::unwrap_cfp (the float unwrap_fp is pub but typed for FpResult<FBig>, unusable for CfpResult). - Conversions: replace from_real/from_int with From<FBig>/From<UBig>/ From<IBig> and add TryFrom<CBig> for FBig/IBig, mirroring FBig's "Convert from/to UBig/IBig" pattern. - hypot: make FBig::hypot (overflow-safe scaled sum-of-squares) a prerequisite dashu-float step; CBig::abs becomes a thin composition. Co-Authored-By: Claude <noreply@anthropic.com>
Add the new `dashu-cmplx` crate (the headline 0.5 feature) with the `CBig` arbitrary-precision complex type built on `dashu-float`'s `FBig`. Type & context model (§2): - `CBig<R: Round = Zero, const B: Word = 2>` — two `Repr<B>` parts over a single shared `dashu_cmplx::Context<R>` newtype, mirroring `FBig`'s `Repr`+`Context` layout (the uniform-precision invariant is structural). - `Context<R>` wraps `dashu_float::Context<R>` and hosts the context-layer ops; `CRounded`/`CfpResult` carry per-axis `(Rounding, Rounding)` inexactness. Construction/conversion (§5.1): `from_parts`/`re`/`imag`/`into_parts`, the `ZERO`/`ONE`/`I` constants, `From<FBig>`/`From<UBig>`/`From<IBig>`, and the lossy `TryFrom<CBig> for FBig`/`IBig` (composing CBig → FBig → IBig). Easy ops (single-pass rounding): add/sub (operators only, calling the context layer — matching `FBig`'s no-inherent-add pattern), `neg`/`conj`/`proj`/`mul_i` (exact), `norm` (squared modulus) and `arg` (Annex-G `atan2`). Comparison (§5.3): componentwise `Eq`, lexicographic `Ord`, `AbsOrd` via `|z|²`, and `NumOrd`/`NumHash` (behind `num-order`). I/O (§5.6): algebraic `a+bi` `Display`/`FromStr` (MPC's parenthesized form is rejected) and structured `Debug`. Workspace + meta-crate wiring: `complex/` added to the workspace, the meta-crate gains `dashu::complex` and the `dashu::Complex = CBig` alias, and `dashu-cmplx` is wired into the shared feature-forwarding lines. Co-Authored-By: Claude <noreply@anthropic.com>
dashu-float prerequisite: - `FBig::hypot` / `Context::hypot`: overflow-safe `sqrt(a²+b²)` via the scaled sum-of-squares (the larger operand is never squared; `m·sqrt(1+r²)` with `r=min/max ∈ [0,1]`). `hypot(±inf,·)=+inf`, `hypot(0,0)=+0`. This is the kernel `CBig::abs` composes, landed on FBig so it is a first-class real op too. CBig field arithmetic (near-correctly rounded via the §6.1 guard-digit recipe — evaluate each component at `p+g`, re-round to `p`; no Ziv retry): - `sqr` `(x²-y²)+i(2xy)`, `mul` `(xu-yv)+i(xv+yu)` (naive 4-mul), `div` (Smith's overflow-safe method, `|u|≥|v|` branch), `inv` `conj(z)/|z|²`. - `abs` = `ctx.hypot(re, im)` at guard precision. - Scalar mul/div by a real `FBig` via mixed-type operators (`z*r`, `z/r`, `r*z`, `r/z`) — no named methods (Decision 9). Annex-G special-value short-circuits: `0·∞`/`0/0`/`∞/∞` → `Indeterminate`; `z/0`/`∞·finite` → the Riemann point at infinity (`+∞+i·0`); `finite/∞`/`0/finite` → 0. (dashu's convention: complex infinity is the single Riemann point produced by `proj`.) Tests: - `tests/special_values.rs` — exact Annex-G vectors for mul/div/inv. - `tests/arith_prop.rs` — exact identity proptests (commutativity, z+0=z, z-z=0, z·1=z, z·0=0, mul_i⁴=id, conj²=id, proj idempotent, z+(-z)=0). - `tests/rounding_prop.rs` — correct-rounding self-oracle (mul/sqr/div/abs at `p` vs `2p` re-rounded, ≤1 ulp/component) and `z·conj(z)=norm`. Co-Authored-By: Claude <noreply@anthropic.com>
- `sqrt` (principal branch, cut `]−∞, 0]`): cancellation-free form — for `x ≥ 0`, `a = sqrt((r+x)/2)` and `b = y/(2a)`; for `x < 0`, `b` from `(r-x)/2` and `a = y/(2b)`. Avoids the `(r−x)` catastrophic cancellation when `|y|≪|x|`. Annex-G specials: `sqrt(±0)=±0`, `sqrt(+∞+iy)=+∞+i·0`, `sqrt(-∞+iy)=0+i·sign(y)∞`. - `exp(x+iy) = e^x·(cos y + i sin y)` reusing FBig `exp`/`sin_cos`; `exp(0)=1`, `exp(+∞+ifinite)=+∞`, `exp(-∞+ifinite)=0`, infinite imaginary → `Indeterminate`. - `log z = ln|z| + i·arg z` (Im ∈ `]−π,π]`); `log(0)=-∞`, `log(∞)=+∞`, cut `]−∞,0]`. - `powi` (integer exponent, repeated squaring, branch-cut-free) and `powf` (`exp(w·log z)` at `p+POWF_GUARD`, re-rounded); `powf(z,0)=1` incl. `powf(0,0)=1`. The transcendental context ops (`exp`/`log`/`powf`/`arg`) now carry `cache: Option<&mut ConstCache>` (threaded via a centralized `reborrow_cache` helper), matching the spec so the deferred `CachedCBig` needs no signature change. Tests: - `tests/transcendental_prop.rs` — sqrt/exp/log self-oracles (p vs 2p, ≤2 ulp), `sqrt(conj z)=conj(sqrt z)`, and `log z = ln|z| + i·arg z`. - `tests/special_values.rs` — extended with sqrt/exp/log special-value vectors. Co-Authored-By: Claude <noreply@anthropic.com>
Forward trig via the real–imaginary decomposition, reusing `dashu-float`'s real `sin`/`cos` and cancellation-free `sinh`/`cosh` (avoids the `exp(±iz)` blow-up for large `|Im z|`): - `sin(x+iy) = sin x·cosh y + i·cos x·sinh y` - `cos(x+iy) = cos x·cosh y − i·sin x·sinh y` - `sin_cos` (shared reduction), `tan = sin/cos`. Infinite input → `Indeterminate`. Inverse trig (Kahan log forms; the inner `log` argument always has positive real part, so the cut comes from the `sqrt`): - `asin z = -i·log(iz + sqrt(1-z²))`, `acos z = -i·log(z + i·sqrt(1-z²))`, `atan z = (i/2)·(log(1-iz) - log(1+iz))`. dashu-float: `FBig::from_repr`'s debug assert now accepts the documented single guard digit (`precision + 1`), so `CBig::into_parts` doesn't panic on a guard-digit part produced by an inexact add. Tests: `transcendental_prop.rs` extended with sin/cos/asin/atan self-oracles (p vs 2p) and the pythagorean identity (modest-range strategy, since `cosh²y`/ `sinh²y` cancel for large `|Im z|`). Co-Authored-By: Claude <noreply@anthropic.com>
…MPC oracle
- `tests/special_values.rs`: expanded Annex-G coverage — `proj` (Riemann collapse),
`conj` with infinities, `arg` of imaginary infinities, the signed-zero
`log(-r ± i0) = ln r ± iπ` branch cut, and `sqrt(-∞) = 0 + i·∞`.
- `benches/` (criterion, `required-features = ["rand"]`, not run in CI): `arith`
(`mul`/`div`/`sqr` over precisions {53,113,256,1024}), `transcendental`
(`exp`/`log`/`sin`/`cos`/`sqrt`/`abs`/`arg`), and `io` (`Display`/`FromStr`),
each with a `random_cbig` helper (log-scale sizing, `StdRng::seed_from_u64(1)`).
- `fuzz/tests/cmplx_random.rs`: a `rug::Complex` (GNU MPC) differential oracle for
field arithmetic at 53-bit precision — `mul`/`div`/`sqr` match MPC within a few
ulps over 8192 random cases (manual: `--ignored`). `dashu-cmplx` added to fuzz deps.
The pre-existing fuzz tests (`add_random`, `trig_random`) are stale against the
post-#83 `FpResult` (unchanged here); the new oracle compiles and passes standalone.
Co-Authored-By: Claude <noreply@anthropic.com>
cbig! literal macro (dashu-macros): - `cbig!` / `static_cbig!` (+ `cbig_embedded` / `static_cbig_embedded`) accepting the algebraic `a+bi` form or a `re, im` pair; each coefficient reuses the `fbig!` base-2 parser. The static variant builds via a new `CBig::from_repr_parts` const constructor (each Repr via `from_static_words`/`Repr::zero()`), gated on Rust 1.64+ like the other static macros. Exposed as `dashu::cbig!` in the meta-crate. Guide: a "Complex Numbers" chapter (construction, two-layer API, no-NaN special-value model, near-correct rounding), linked from SUMMARY.md. Version sync (Phase 5): all crates bumped to 0.5.0 (base/int/float/ratio/macros 0.4.x → 0.5.0; complex already 0.5.0) and every inter-crate dependency version string updated; changelels consolidated (Unreleased → 0.5.0). Co-Authored-By: Claude <noreply@anthropic.com>
The MSRV (1.68) job strips rand 0.9/0.10 (which need newer Rust) from the manifests before `cargo check --features rand`. The new `dashu-cmplx` crate wasn't in that list, and it forwards `rand_v09 → dashu-float/rand_v09`, while the meta-crate's `rand` feature still pointed at `dashu-cmplx/rand` — so after the strip, resolution failed with "dashu-float does not have feature rand_v09". Mirror the existing handling: strip `rand_v09`/`rand_v010` (and complex's `rand` alias + the `required-features = ["rand"]` benches) for the MSRV build, and drop the `dashu-cmplx/rand` forwarding from the meta-crate's `rand` line. Stable/1.85 still exercise the full rand surface via `--all-features`. Verified by running the script + the exact MSRV check command locally (`cargo check --workspace --exclude dashu-python --features "std,num-order,serde,zeroize,rand,num-traits_v02"` builds cleanly). Co-Authored-By: Claude <noreply@anthropic.com>
The inline Display/FromStr unit tests use format!, which is not in the prelude under no_std. The fmt/parse test modules now `use alloc::format;` (the same fix dashu-ratio uses), so `cargo test --no-default-features --features rand` compiles. Verified: `cargo test --no-default-features --features rand --workspace --exclude dashu-python` passes; the all-features (std) build and clippy are unchanged. Co-Authored-By: Claude <noreply@anthropic.com>
Add random generation for CBig, mirroring dashu-float/ratio: - Features: `rand = ["rand_v08"]` (default alias), with `rand_v09`/`rand_v010` opt-in — matching integer/float/rational, and MSRV-compatible (rand 0.8 runs on 1.68, so the MSRV `rand` build no longer needs a complex-specific carve-out). - `third_party/rand.rs`: `UniformCBig<R,B>` samples the box `[low, high)` (each part an independent `UniformFBig` range). `rand_v08`/`rand_v09`/`rand_v010` add the `Distribution<CBig>` impls; `Standard`/`StandardUniform`/`Open01`/ `OpenClosed01` sample the unit square `[0,1)²` (each part uniform in `[0,1)`). No bespoke sampling algorithm — it reuses `dashu_float::rand::UniformFBig`. - No single-axis `Uniform`/`SampleUniform` (complex has no interval order); the box `UniformCBig::new(low, high, precision)` is the ranged sampler. The MSRV dep-drop script is simplified back to just adding `complex/Cargo.toml` to the existing rand_v09/rand_v010 strip loop (complex now keeps `rand = rand_v08`). Tests: `tests/random.rs` (the `Standard` unit square, the `UniformCBig` box, and `Open01` excludes zero). Verified across rand 0.8/0.9/0.10, `no_std`, and the MSRV check command. Co-Authored-By: Claude <noreply@anthropic.com>
The old CBig NumHash hashed re and im sequentially (tuple-style), inconsistent with num-order's native Complex<f64> hashing (algebraic combination of the per-part field elements). CBig NumHash now mirrors num-order's "Case 4": treat z = a + b·i and write hash(a + bterm) where bterm = ∓PROOT²·b² (sign of b), with a, b the per-part residues. This keeps a CBig and a num-complex Complex<f64> of the same value in sync. dashu-float changes (behind `num-order`): - `Repr::num_hash_residue(&self) -> i128`: the numeric-hash field element (mod 2¹²⁷−1), extracted from `Repr::num_hash` so composite types can reuse it. For base-2 uses the same `absm(&127)` exponent reduction as num-order's f64 fhash. - ±∞ now map to `HASH_INF`/`HASH_NEGINF` (= ±M127), matching num-order's f64 fhash. The subsequent `i128::num_hash` still reduces these to 0 (since M127 ≡ 0 mod M127), so the *final* hash of a real ±∞ is unchanged — but the *residue* now distinguishes them so CBig's algebraic combination is correct for complex numbers with infinite parts. ±0 still maps to 0. - `test_fbig_num_hash_matches_f64` verifies FBig↔f64 consistency including ±∞ and -0. dashu-cmplx changes: - `_num-modular` added to the `num-order` feature. - `CBig::num_hash` rewritten to the algebraic formula. - `cbig_num_hash_matches_num_complex` cross-checks against the transcribed num-order Complex<f64> formula for 7 sample values. Co-Authored-By: Claude <noreply@anthropic.com>
Align dashu-cmplx's module layout and operator-impl style with dashu-float.
Pure restructuring; no behavioral change.
- Merge `sub.rs` into `add.rs` and `power.rs` into `exp.rs`, matching float's
single-file grouping: add+sub share one sign-parameterized kernel
(`signed_add`, sub = add with negated rhs), and `exp` hosts the power family.
- Rewrite the `CBig·CBig` `Mul`/`MulAssign` impls (and `add.rs`'s
`AddAssign`/`SubAssign`) as explicit ref/val impls plus a new
`impl_binop_assign_by_taking!` macro, mirroring float's `mul.rs`/`add.rs`
instead of the one-shot `impl_cbig_binop!` mega-macro.
- Promote `trig.rs` to a `math/` submodule (`math/{mod,trig}`), matching
float's `pub mod math`.
- Rename `context.rs` to `repr.rs` (float keeps `Context` in `repr.rs`),
updating every `crate::context::` path to `crate::repr::`.
Co-Authored-By: Claude <noreply@anthropic.com>
- Phase 3 (dashu-cmplx): mark ✅ Implemented (M1–M6); fold the detailed TODO-cmplx.md design doc into a consolidated §3.4 deferred-to-0.5.x list (Ziv, hyperbolics, fma, CachedCBig forward-compat note, CRound, etc.). TODO-cmplx.md is removed. - Phase 0: drop the "record baseline benchmark" item — results are hardware-dependent and won't be committed; note the decision inline. - Phase 1 §1.5: replace vague prose with four concrete checkboxes (guide prose migration + the pow/div/exp algorithm TODOs), line refs updated. - Remove the "Open Decisions" section — all four (CBig scope, serde padding, proptest, MSRV) are resolved and documented in their phases. Co-Authored-By: Claude <noreply@anthropic.com>
The `Context::sin` 49-digit-significand rounding regression (found during
fuzzing) lived only in the workspace-excluded `fuzz/` crate, so it never ran in
CI. Move it into float's inline trig tests as
`test_sin_many_digit_rounding_no_panic` (rewritten to the current
`Context::sin` API), and consolidate the pythagorean identity proptest to sweep
precisions {20, 50, 100} — a strict superset of the former single-precision
version, replacing the complementary fuzz sweep that was deleted.
Co-Authored-By: Claude <noreply@anthropic.com>
…d.yml The workspace-excluded `fuzz/` crate had not compiled since the #83 FpResult change (its tests targeted the pre-#83 `Context::sin(f)`/`FpResult::Normal` API). Restore it and convert the differentials to proptest. Fuzz crate (step 1): - Port every test to the current `Context`/`FpResult` API (`ctx.sin::<B>(&x, None).unwrap().value()`; `FpResult` is `Result<Rounded<_>, FpError>`). - Replace the `for _ in 0..N { rng… }` loops with proptest strategies (`fuzz_config` = 1024 cases, overridable via `PROPTEST_CASES`) so a mismatch shrinks to a minimal counterexample. Shared strategies live in `fuzz/src/lib.rs`. - `add_random`: dispatches all six rounding modes per case, precision biased toward 1/2/3. `trig_random`: five broad differentials (sin/cos/tan/atan2/ inv-trig) in proptest + three deterministic sweeps (pi/asin-near-1/large-exp tan) ported; `atan2(0,0)` indeterminate handled by skipping. `cmplx_random`: MPC mul/div/sqr over f64 pairs. Trig tests use `HalfAway` to match `DBig`. All remain `#[ignore]`d (manual, release-time — they link `rug` and run long). CI (step 2): - New `.github/workflows/build.yml` for compile-only checks: a `fuzz-check` job (cargo check the fuzz crate so it can't silently rot again — tests stay manual), plus `build-benchmark` and `build-aarch64` moved out of `tests.yml`, plus the `check` (cargo check, stable/1.85/1.68 MSRV matrix) job. - `tests.yml` now runs only the test matrix + x86/x86_64/no-std tests + fmt + clippy. Co-Authored-By: Claude <noreply@anthropic.com>
Co-Authored-By: Claude <noreply@anthropic.com>
Four new proptest-driven test files in the workspace-excluded `fuzz/` crate, differential against `rug` (GMP/MPFR/MPC) to complete the correctness-oracle coverage: - `transcendental.rs` — all 17 non-trig FBig transcendetals (exp/exp_m1, ln/ln_1p/sqrt/cbrt/nth_root/hypot/atan/powf/powi + the hyperbolic family), compared vs `rug::Float` (MPFR) with a `within_k_ulps(k=2)` tolerance (dashu near-correct, MPFR Ziv-correct → ≤1 ulp is legitimate). - `cmplx_transcendental.rs` — 10 CBig transcendetals (exp/log/sqrt/ sin/cos/tan/asin/acos/atan/powf) vs `rug::Complex` (MPC) at 53-bit, reusing the shared `close()` helpers. - `integer.rs` — 15 UBig/IBig ops (mul/sqr/gcd/div_rem/pow/sqrt/nth_root/ bit-ops/shifts) vs `rug::Integer` (GMP) via exact decimal-string round-trip. - `ratio.rs` — 8 RBig ops (add/sub/mul/div/sqr/pow/inv/reduce) vs `rug::Rational` (GMP mpq) via exact canonical-form comparison. Shared infra: `fuzz/src/lib.rs` gains `ubig_strategy`, `pos_dbig_strategy`, `unit_dbig` (promoted from trig_random), and a `cmplx` module holding the 53-bit build/compare helpers (moved from cmplx_random). The fuzz crate now depends on `dashu-ratio`. Bug fix discovered by the integer oracle: - `UBig/IBig::nth_root(0, n)` (and `cbrt(0)`) returned 1 instead of 0: the `bits <= n` shortcut in `integer/src/root_ops.rs` fired for the zero input (bit_len == 0). Fixed with a zero guard. Regression test added. Co-Authored-By: Claude <noreply@anthropic.com>
- Add Context::sinh_cosh(x, cache) -> (FpResult, FpResult) in float/src/math/hyper.rs, sharing the exp_m1(±x) sub-computations to roughly halve the cost vs separate calls. - Add FBig::sinh_cosh() -> (Self, Self) convenience method with doc example. - Add CachedFBig::sinh_cosh forwarding (mirrors sin_cos pattern, threads ConstCache). - Use sinh_cosh in complex CBig::sin_cos kernel instead of separate sinh+cosh calls. - Add sinh_cosh_fuzz proptest oracle vs rug's independent sinh/cosh (within 2 ulps). Co-Authored-By: Claude <noreply@anthropic.com>
cmpute
commented
Jun 28, 2026
- log() → ln() on CBig, matching FBig's naming; context-layer stays log() - imag() → im() across all call sites - Remove from_repr_parts; make new() pub (identical code) - Inline is_numeric_zero helper at call sites - Inline trig.rs helper fns (cbig_one, cbig_real, reround, …) - Add #[inline] to Context::sin/cos - Replace CBig::inv() with Inverse trait impl (matching FBig) - Split add.rs signed_add into per-ownership kernel functions - Use impl_cbig_binop! macro for Mul (matching Div) - Unroll parameterless impl_scalar_mul!/impl_scalar_div! macros - Fix abs_ge to avoid cloning Repr parts - Fix overflow: both parts +∞ instead of ±∞ + i·0 - Extract bterm helper; test shares it instead of duplicating formula - Add Uniform01<BASE> struct in rand.rs for complex unit-square sampling - Fix copyright year (2026), use IBig::ONE/NEG_ONE constants - Update CHANGELOG with all review-driven changes Co-Authored-By: Claude <noreply@anthropic.com>
…name cbig→cmplx - Inline abs_repr helper in float/src/root.rs (clone avoidance) - Delete premature guide/src/complex.md (deferred to post-merge) - Rename macros/src/parse/cbig.rs → cmplx.rs for naming consistency Co-Authored-By: Claude <noreply@anthropic.com>
cmpute
commented
Jun 29, 2026
cmpute
commented
Jun 29, 2026
- Simplify trig constant construction (CBig::ONE and IBig::from(2).into()) - Use impl_cbig_binop! for Add/Sub (replace kernel functions) - Add impl_cbig_scalar_binop! macro for CBig/FBig scalar ops - Remove unused impl_binop_assign_by_taking macro - Replace abs_ge with inline FBig::abs_cmp at call sites - Restore signed-zero preservation in underflow - Fix fuzz: rug::Complex::imag() accidentally renamed to im() - Fix formatting in float/src/root.rs - Update CHANGELOG to reflect current state Co-Authored-By: Claude <noreply@anthropic.com>
Add a deferred item under Phase 3.4 to make float's add_val_val / add_val_ref / add_ref_val / add_ref_ref kernel functions (and equivalents for sub/mul/div) public, so dashu-cmplx can call them directly in its own per-ownership operator impls rather than immediately borrowing through the complex Context. Co-Authored-By: Claude <noreply@anthropic.com>
…mula Make num-complex_v04 a non-optional regular dependency and enable num-order/num-complex so Complex<f64>: NumHash is available in unit tests. The cbig_num_hash_matches_num_complex test now calls residue(&Complex64::new(re, im)) directly against num-order's actual implementation — no duplicated bterm transcription. Co-Authored-By: Claude <noreply@anthropic.com>
- New `num-complex` feature providing TryFrom conversions between CBig and num-complex's Complex<f32>/Complex<f64> (base-2, composing through FBig): exact lift with NaN -> OutOfBounds, infinities/signed zeros preserved; rounding back errors on overflow or inexactness — mirroring FBig's primitive-float TryFrom pair. - The `num-order` feature no longer enables `num-order/num-complex`, and num-complex is no longer an unconditional dependency: it is now an opt-in normal dep behind `num-complex`, plus a dev-dependency (the num-order NumHash test compares against num-complex's live Complex<f64> reference, and the new conversion tests use it). Enabling only `num-order` (the default) therefore no longer drags num-complex into the dependency tree. Co-Authored-By: Claude <noreply@anthropic.com>
- New `rustdoc` job in build.yml runs `cargo doc --workspace` with `-D warnings` (stable, --all-features). The meta-crate `dashu` and `dashu-python` both name their lib `dashu`, so they collide on the output path and are documented in two invocations (both are checked). - Fix 9 broken intra-doc links surfaced by the check: dashu-cmplx (Context::guard pub(crate) link, dashu_float::Rounded path), dashu-float (Exact/Inexact variant paths, FpError::InfiniteInput crate path, static_fbig! external macro -> plain code), dashu-int (MontgomeryRepr self link), dashu-ratio (Display path). Co-Authored-By: Claude <noreply@anthropic.com>
The compliance page now covers two aspects of standards conformance: dashu-float's FBig vs IEEE 754-2008 (the former ieee754.md content, demoted one heading level) and dashu-cmplx's CBig vs C99 Annex G (IEC 60559 complex) — data model, arithmetic, branch cuts, and the no-NaN / Riemann-point policy, sourced from the crate's actual behavior. Also updates the SUMMARY.md link and a stale pointer in TODO-v05.md. Co-Authored-By: Claude <noreply@anthropic.com>
cmpute
pushed a commit
that referenced
this pull request
Jun 30, 2026
Integrates dashu-cmplx (complex numbers, #85) and other develop changes.
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
1 participant
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
No description provided.