From f4865cf0939948f299aa069a080ab6d21a2e7f62 Mon Sep 17 00:00:00 2001 From: Matt Borland Date: Tue, 6 Oct 2026 08:35:47 -0400 Subject: [PATCH] Fix links due to repo renaming --- .github/workflows/metal.yml | 6 +- README.md | 30 +++++----- docs/antora-playbook.yml | 2 +- docs/modules/ROOT/pages/benchmarks.adoc | 60 ++++++++++---------- docs/modules/ROOT/pages/build_and_usage.adoc | 2 +- docs/modules/ROOT/pages/examples.adoc | 28 ++++----- docs/modules/ROOT/pages/numeric.adoc | 4 +- extra/README.md | 2 +- 8 files changed, 67 insertions(+), 67 deletions(-) diff --git a/.github/workflows/metal.yml b/.github/workflows/metal.yml index cf93006c..f89fa313 100644 --- a/.github/workflows/metal.yml +++ b/.github/workflows/metal.yml @@ -28,7 +28,7 @@ jobs: working-directory: ./tests/beman/big_int/metal/ - name: build benchmark_single-stm32f429 run: | - PATH="${{ runner.workspace }}/std-big-int/tests/beman/big_int/metal/emu_env/arm-gnu-toolchain-15.3.rel1-x86_64-arm-none-eabi/bin:$PATH" + PATH="${{ github.workspace }}/tests/beman/big_int/metal/emu_env/arm-gnu-toolchain-15.3.rel1-x86_64-arm-none-eabi/bin:$PATH" echo 'Query arm-none-eabi-g++ version' echo arm-none-eabi-g++ -v @@ -40,14 +40,14 @@ jobs: working-directory: ./tests/beman/big_int/metal/ - name: emulate-target stm32f429 run: | - PATH="${{ runner.workspace }}/std-big-int/tests/beman/big_int/metal/emu_env/xpack-qemu-arm-8.2.6-1/bin:$PATH" + PATH="${{ github.workspace }}/tests/beman/big_int/metal/emu_env/xpack-qemu-arm-8.2.6-1/bin:$PATH" qemu-system-gnuarmeclipse --verbose --mcu STM32F429ZI --nographic --gdb tcp::9999 -d unimp,guest_errors & sleep 2 working-directory: ./tests/beman/big_int/metal/ - name: run-test-on-target run: | sleep 2 - PATH="${{ runner.workspace }}/std-big-int/tests/beman/big_int/metal/emu_env/arm-gnu-toolchain-15.3.rel1-x86_64-arm-none-eabi/bin:$PATH" + PATH="${{ github.workspace }}/tests/beman/big_int/metal/emu_env/arm-gnu-toolchain-15.3.rel1-x86_64-arm-none-eabi/bin:$PATH" echo 'Run test on target' echo arm-none-eabi-gdb ./bin/app_benchmark_std_big_int.elf -x ./target/build/test_app_benchmarks_emulator.gdb > ./app_benchmark_std_big_int.txt diff --git a/README.md b/README.md index cde010fb..3e35f1ed 100644 --- a/README.md +++ b/README.md @@ -10,18 +10,18 @@ SPDX-License-Identifier: BSL-1.0 Library Status Standard Target - - Continuous Integration Tests - - Lint Check (pre-commit) - - fuzz - - metal - - Coverage - - publish gh-pages + + Continuous Integration Tests + + Lint Check (pre-commit) + + fuzz + + metal + + Coverage + + publish gh-pages

**Implements**: `std::big_int` proposed in [P4444](https://isocpp.org/files/papers/D4444R0.html). @@ -34,7 +34,7 @@ It may also find use as a minimal and modern C++ project structure. ## Documentation -For the full library documentation please see our [GitHub Pages Site](https://eisenwave.github.io/std-big-int/build_and_usage.html). +For the full library documentation please see our [GitHub Pages Site](https://bemanproject.github.io/big_int/build_and_usage.html). ## License @@ -45,7 +45,7 @@ For the full library documentation please see our [GitHub Pages Site](https://ei For build requirements and supported platforms, building, the optional SIMD-accelerated multiplication, installation, CMake integration, and basic usage, see the -[Build and Usage](https://eisenwave.github.io/std-big-int/build_and_usage.html) documentation. +[Build and Usage](https://bemanproject.github.io/big_int/build_and_usage.html) documentation. ## Development @@ -53,5 +53,5 @@ See the [Contributing Guidelines](CONTRIBUTING.md). ## References -See the [References](https://eisenwave.github.io/std-big-int/references.html) documentation for the +See the [References](https://bemanproject.github.io/big_int/references.html) documentation for the works underpinning the algorithms used in this library. diff --git a/docs/antora-playbook.yml b/docs/antora-playbook.yml index d8b77781..a19bde98 100644 --- a/docs/antora-playbook.yml +++ b/docs/antora-playbook.yml @@ -5,7 +5,7 @@ content: sources: - url: .. start_path: docs - edit_url: 'https://github.com/eisenwave/std-big-int/edit/develop/{path}' + edit_url: 'https://github.com/bemanproject/big_int/edit/develop/{path}' output: dir: html ui: diff --git a/docs/modules/ROOT/pages/benchmarks.adoc b/docs/modules/ROOT/pages/benchmarks.adoc index fba73535..11ac49ca 100644 --- a/docs/modules/ROOT/pages/benchmarks.adoc +++ b/docs/modules/ROOT/pages/benchmarks.adoc @@ -31,7 +31,7 @@ lives inplace; `basic_big_int<128>` keeps two. This suite quantifies that optimization by timing `+`, `-`, `*`, and `/` for `big_int` next to the native builtin integer types, using https://github.com/google/benchmark[Google Benchmark] for the measurement loop. It is built from -https://github.com/eisenwave/std-big-int/blob/main/tests/beman/big_int/perf/small_value_optimization.gbench.cpp[small_value_optimization.gbench.cpp]. +https://github.com/bemanproject/big_int/blob/main/tests/beman/big_int/perf/small_value_optimization.gbench.cpp[small_value_optimization.gbench.cpp]. Three tiers are measured for every operation: @@ -154,7 +154,7 @@ integer NTT of the default build, with a double-precision transform using AVX2 kernels that is about twice as fast. So it changes nothing below the FFT gate, and its FFT gate for this combination was fitted as described under the cost model below. Timed end to end through the public operators with -https://github.com/eisenwave/std-big-int/blob/main/tests/beman/big_int/perf/shape_sweep.cpp[shape_sweep.cpp] +https://github.com/bemanproject/big_int/blob/main/tests/beman/big_int/perf/shape_sweep.cpp[shape_sweep.cpp] on 34 shapes (balanced and unbalanced products up to 1,000,000 limbs, and squares), it was up to 1.8x faster than the IFMA build with the integer NTT. It was 3% and 4% slower at two balanced sizes (50,000 and 80,000 limbs), band tops where @@ -196,7 +196,7 @@ unary operations and allocations, and it is timed end to end (the median of five runs). Runs with `beman::big_int`, `boost::cpp_int`, and `boost::gmp_int` are compared. At 256 bits the operands are four limbs, below every kernel and FFT threshold, so the build configuration does not matter here. Source: -https://github.com/eisenwave/std-big-int/blob/main/tests/beman/big_int/perf/elliptic_ecc.perf.cpp[elliptic_ecc.perf.cpp]. +https://github.com/bemanproject/big_int/blob/main/tests/beman/big_int/perf/elliptic_ecc.perf.cpp[elliptic_ecc.perf.cpp]. [cols="2,1,1", options="header"] |=== @@ -351,7 +351,7 @@ kernel earlier the more lopsided the operands are. ==== Tier-by-tier timings To isolate each tier, a stress benchmark -(https://github.com/eisenwave/std-big-int/blob/main/tests/beman/big_int/multiplication_stress_bench.test.cpp[multiplication_stress_bench.test.cpp]) +(https://github.com/bemanproject/big_int/blob/main/tests/beman/big_int/multiplication_stress_bench.test.cpp[multiplication_stress_bench.test.cpp]) calls the kernels directly on balanced operands, bypassing the dispatcher. The schoolbook tier is the runtime basecase kernel (the IFMA kernel here). Every higher tier is forced at the top level through its benchmark-only @@ -454,7 +454,7 @@ image::crossover_square.png[Squaring algorithm crossover plot,align=center] The result of a multiplication adds the widths of its operands, so each row multiplies two operands of the stated width and the product is twice as wide. The times include allocating the result, for all three libraries. Source: -https://github.com/eisenwave/std-big-int/blob/main/tests/beman/big_int/perf/mul_big_int_vs_gmp_cpp.perf.cpp[mul_big_int_vs_gmp_cpp.perf.cpp]; +https://github.com/bemanproject/big_int/blob/main/tests/beman/big_int/perf/mul_big_int_vs_gmp_cpp.perf.cpp[mul_big_int_vs_gmp_cpp.perf.cpp]; pass an operand width in limbs (and optionally a trial count) on the command line to reproduce a row. @@ -489,7 +489,7 @@ A mixed sweep of 16,384 products with random widths from 4 to 16,384 limbs (the second operand 0.5x to 1.5x as wide as the first) checks every result against GMP and averages 2.2x GMP's time, a mean dominated by the widest operands (all below the FFT gate). See -https://github.com/eisenwave/std-big-int/blob/main/tests/beman/big_int/perf/mul_big_int_vs_gmp_cpp.limbs.cpp[mul_big_int_vs_gmp_cpp.limbs.cpp]. +https://github.com/bemanproject/big_int/blob/main/tests/beman/big_int/perf/mul_big_int_vs_gmp_cpp.limbs.cpp[mul_big_int_vs_gmp_cpp.limbs.cpp]. [#benchmarks_division] === Division @@ -504,7 +504,7 @@ listed in the crossover table above. ==== Tier-by-tier timings A stress benchmark -(https://github.com/eisenwave/std-big-int/blob/main/tests/beman/big_int/division_stress_bench.test.cpp[division_stress_bench.test.cpp]) +(https://github.com/bemanproject/big_int/blob/main/tests/beman/big_int/division_stress_bench.test.cpp[division_stress_bench.test.cpp]) calls the three kernels directly, including their scratch setup, and takes the median over three random operand pairs of the best of five repetitions. On balanced 2n / n shapes: @@ -529,7 +529,7 @@ As with multiplication, only the division itself is timed, with a stopwatch read immediately before and after the operation and the times summed and averaged over many trials. Each row divides an pass:[N]-digit numerator by an pass:[N/2]-digit denominator, producing an pass:[N/2]-digit quotient. Source: -https://github.com/eisenwave/std-big-int/blob/main/tests/beman/big_int/perf/div_big_int_vs_gmp_cpp.perf.cpp[div_big_int_vs_gmp_cpp.perf.cpp]. +https://github.com/bemanproject/big_int/blob/main/tests/beman/big_int/perf/div_big_int_vs_gmp_cpp.perf.cpp[div_big_int_vs_gmp_cpp.perf.cpp]. [cols="1,1,1,1,1,1", options="header"] |=== @@ -558,7 +558,7 @@ image::vs_libraries_div.png[big_int vs cpp_int vs gmp_int division plot,align=ce A mixed sweep of 16,384 quotients with divisors of 4 to 16,384 limbs and dividends 1.1x to 2.1x as wide checks every result against GMP and averages 2.0x GMP's time. See -https://github.com/eisenwave/std-big-int/blob/main/tests/beman/big_int/perf/div_big_int_vs_gmp_cpp.limbs.cpp[div_big_int_vs_gmp_cpp.limbs.cpp]. +https://github.com/bemanproject/big_int/blob/main/tests/beman/big_int/perf/div_big_int_vs_gmp_cpp.limbs.cpp[div_big_int_vs_gmp_cpp.limbs.cpp]. [#benchmarks_reproducing] === Reproducing the measurements @@ -665,13 +665,13 @@ simply via creation of and inclusion of a single hand-coded assembly routine for schoolbook long multiplication. An adaption of the program -https://github.com/eisenwave/std-big-int/blob/main/tests/beman/big_int/perf/mul_big_int_vs_gmp_cpp.limbs.cpp[mul_big_int_vs_gmp_cpp.limbs.cpp] +https://github.com/bemanproject/big_int/blob/main/tests/beman/big_int/perf/mul_big_int_vs_gmp_cpp.limbs.cpp[mul_big_int_vs_gmp_cpp.limbs.cpp] has been used for this runtime result. The implementations of the assembly subroutines `beman_big_int_multiply_long_runtime()` for `x86_64` using GCC(clang)/GAS and using MSVC/MASM can be found in -https://github.com/eisenwave/std-big-int/blob/main/src/multiply_long_runtime_x86_64_generic.s[multiply_long_runtime_x86_64_generic.s] +https://github.com/bemanproject/big_int/blob/main/src/multiply_long_runtime_x86_64_generic.s[multiply_long_runtime_x86_64_generic.s] and -https://github.com/eisenwave/std-big-int/blob/main/src/multiply_long_runtime_x86_64_generic.asm[multiply_long_runtime_x86_64_generic.asm], +https://github.com/bemanproject/big_int/blob/main/src/multiply_long_runtime_x86_64_generic.asm[multiply_long_runtime_x86_64_generic.asm], respectively. At the moment, the assembly optimized routines can not be used within @@ -717,9 +717,9 @@ Times are per square, measured on the same Intel(R) Core(TM) i9-11900K. |=== The implementations can be found in -https://github.com/eisenwave/std-big-int/blob/main/src/square_long_runtime_x86_64_generic.s[square_long_runtime_x86_64_generic.s] +https://github.com/bemanproject/big_int/blob/main/src/square_long_runtime_x86_64_generic.s[square_long_runtime_x86_64_generic.s] and -https://github.com/eisenwave/std-big-int/blob/main/src/square_long_runtime_x86_64_generic.asm[square_long_runtime_x86_64_generic.asm]. +https://github.com/bemanproject/big_int/blob/main/src/square_long_runtime_x86_64_generic.asm[square_long_runtime_x86_64_generic.asm]. [#benchmarks_arch_opts_aarch64] === AArch64 @@ -774,11 +774,11 @@ multiplication routine. |=== The implementations can be found in -https://github.com/eisenwave/std-big-int/blob/main/src/multiply_long_runtime_aarch64_generic.S[multiply_long_runtime_aarch64_generic.S], -https://github.com/eisenwave/std-big-int/blob/main/src/multiply_long_runtime_aarch64_generic.asm[multiply_long_runtime_aarch64_generic.asm], -https://github.com/eisenwave/std-big-int/blob/main/src/square_long_runtime_aarch64_generic.S[square_long_runtime_aarch64_generic.S], +https://github.com/bemanproject/big_int/blob/main/src/multiply_long_runtime_aarch64_generic.S[multiply_long_runtime_aarch64_generic.S], +https://github.com/bemanproject/big_int/blob/main/src/multiply_long_runtime_aarch64_generic.asm[multiply_long_runtime_aarch64_generic.asm], +https://github.com/bemanproject/big_int/blob/main/src/square_long_runtime_aarch64_generic.S[square_long_runtime_aarch64_generic.S], and -https://github.com/eisenwave/std-big-int/blob/main/src/square_long_runtime_aarch64_generic.asm[square_long_runtime_aarch64_generic.asm]. +https://github.com/bemanproject/big_int/blob/main/src/square_long_runtime_aarch64_generic.asm[square_long_runtime_aarch64_generic.asm]. With these basecases, `AArch64` uses schoolbook multiplication up to 112 limbs (the shorter operand's length) instead of 48, and the squaring basecase up to @@ -813,42 +813,42 @@ schoolbook multiplication needs. == Source programs The programs behind these measurements live in -https://github.com/eisenwave/std-big-int/tree/main/tests/beman/big_int/perf[tests/beman/big_int/perf]. +https://github.com/bemanproject/big_int/tree/main/tests/beman/big_int/perf[tests/beman/big_int/perf]. [cols="2,3", options="header"] |=== | Source file | Description -| https://github.com/eisenwave/std-big-int/blob/main/tests/beman/big_int/perf/small_value_optimization.gbench.cpp[small_value_optimization.gbench.cpp] +| https://github.com/bemanproject/big_int/blob/main/tests/beman/big_int/perf/small_value_optimization.gbench.cpp[small_value_optimization.gbench.cpp] | Google Benchmark comparison of `big_int` add/sub/mul/div against the builtin integer types, showcasing the small-value (inplace, no-allocation) optimization. -| https://github.com/eisenwave/std-big-int/blob/main/tests/beman/big_int/perf/elliptic_ecc.perf.cpp[elliptic_ecc.perf.cpp] +| https://github.com/bemanproject/big_int/blob/main/tests/beman/big_int/perf/elliptic_ecc.perf.cpp[elliptic_ecc.perf.cpp] | Elliptic-curve cryptography (ECDSA) overall performance gauge at modest limb counts. -| https://github.com/eisenwave/std-big-int/blob/main/tests/beman/big_int/perf/mul_big_int_vs_gmp_cpp.perf.cpp[mul_big_int_vs_gmp_cpp.perf.cpp] +| https://github.com/bemanproject/big_int/blob/main/tests/beman/big_int/perf/mul_big_int_vs_gmp_cpp.perf.cpp[mul_big_int_vs_gmp_cpp.perf.cpp] | Multiplication performance with fixed limb counts and timing. -| https://github.com/eisenwave/std-big-int/blob/main/tests/beman/big_int/perf/mul_big_int_vs_gmp_cpp.limbs.cpp[mul_big_int_vs_gmp_cpp.limbs.cpp] +| https://github.com/bemanproject/big_int/blob/main/tests/beman/big_int/perf/mul_big_int_vs_gmp_cpp.limbs.cpp[mul_big_int_vs_gmp_cpp.limbs.cpp] | Multiplication performance with mixed limb counts, with timing and numerical-correctness checks. -| https://github.com/eisenwave/std-big-int/blob/main/tests/beman/big_int/perf/div_big_int_vs_gmp_cpp.perf.cpp[div_big_int_vs_gmp_cpp.perf.cpp] +| https://github.com/bemanproject/big_int/blob/main/tests/beman/big_int/perf/div_big_int_vs_gmp_cpp.perf.cpp[div_big_int_vs_gmp_cpp.perf.cpp] | Division performance with fixed limb counts and timing. -| https://github.com/eisenwave/std-big-int/blob/main/tests/beman/big_int/perf/div_big_int_vs_gmp_cpp.limbs.cpp[div_big_int_vs_gmp_cpp.limbs.cpp] +| https://github.com/bemanproject/big_int/blob/main/tests/beman/big_int/perf/div_big_int_vs_gmp_cpp.limbs.cpp[div_big_int_vs_gmp_cpp.limbs.cpp] | Division performance with mixed limb counts, with timing and numerical-correctness checks. -| https://github.com/eisenwave/std-big-int/blob/main/tests/beman/big_int/perf/shape_sweep.cpp[shape_sweep.cpp] +| https://github.com/bemanproject/big_int/blob/main/tests/beman/big_int/perf/shape_sweep.cpp[shape_sweep.cpp] | End-to-end timing harness used for tuning: multiplication, squaring and division through the public operators over a list of operand shapes (balanced and unbalanced), with residue checks and an optional GMP column. Built as the `beman.big_int.benchmarks.shape_sweep` target. -| https://github.com/eisenwave/std-big-int/blob/main/tests/beman/big_int/multiplication_stress_bench.test.cpp[multiplication_stress_bench.test.cpp] +| https://github.com/bemanproject/big_int/blob/main/tests/beman/big_int/multiplication_stress_bench.test.cpp[multiplication_stress_bench.test.cpp] | Each multiplication and squaring tier (schoolbook kernels through FFT) forced at the top level on balanced operands; CSV output for `plot_crossover.py`. -| https://github.com/eisenwave/std-big-int/blob/main/tests/beman/big_int/division_stress_bench.test.cpp[division_stress_bench.test.cpp] +| https://github.com/bemanproject/big_int/blob/main/tests/beman/big_int/division_stress_bench.test.cpp[division_stress_bench.test.cpp] | The schoolbook, Burnikel-Ziegler and Barrett division kernels called directly on balanced, quotient-length and unbalanced shapes; CSV output for `plot_crossover.py --division`. -| https://github.com/eisenwave/std-big-int/blob/main/tests/beman/big_int/perf/plot_crossover.py[plot_crossover.py] +| https://github.com/bemanproject/big_int/blob/main/tests/beman/big_int/perf/plot_crossover.py[plot_crossover.py] | Plots the tier timings and crossovers of multiplication, squaring and division, and fits their empirical complexity. -| https://github.com/eisenwave/std-big-int/blob/main/tests/beman/big_int/perf/plot_vs_libraries.py[plot_vs_libraries.py] +| https://github.com/bemanproject/big_int/blob/main/tests/beman/big_int/perf/plot_vs_libraries.py[plot_vs_libraries.py] | Plots `big_int` against `cpp_int` and `gmp_int` for multiplication and division. |=== diff --git a/docs/modules/ROOT/pages/build_and_usage.adoc b/docs/modules/ROOT/pages/build_and_usage.adoc index a51e3977..6acc7e0e 100644 --- a/docs/modules/ROOT/pages/build_and_usage.adoc +++ b/docs/modules/ROOT/pages/build_and_usage.adoc @@ -58,7 +58,7 @@ cmake --list-presets=workflow ---- For details on building `beman.big_int` without using a CMake preset, refer to -the https://github.com/eisenwave/std-big-int/blob/main/CONTRIBUTING.md[Contributing Guidelines]. +the https://github.com/bemanproject/big_int/blob/main/CONTRIBUTING.md[Contributing Guidelines]. [#build_and_usage_simd] === Optional: SIMD-accelerated multiplication diff --git a/docs/modules/ROOT/pages/examples.adoc b/docs/modules/ROOT/pages/examples.adoc index c0b4676f..a0491715 100644 --- a/docs/modules/ROOT/pages/examples.adoc +++ b/docs/modules/ROOT/pages/examples.adoc @@ -14,7 +14,7 @@ We will first start with the basics and then move on to more advanced examples. [#examples_construction] === Construction -.This https://github.com/eisenwave/std-big-int/blob/main/examples/construction.cpp[example] demonstrates the many ways to create a `beman::big_int`: from built-in integers, from floating-point values, from a user-defined literal, by copy and move, and from a range of limbs +.This https://github.com/bemanproject/big_int/blob/main/examples/construction.cpp[example] demonstrates the many ways to create a `beman::big_int`: from built-in integers, from floating-point values, from a user-defined literal, by copy and move, and from a range of limbs ==== [source, c++] ---- @@ -38,7 +38,7 @@ result_is_ok: true [#examples_operators] === Fundamental operators -.This https://github.com/eisenwave/std-big-int/blob/main/examples/operators.cpp[example] demonstrates the fundamental arithmetic, comparison, bitwise, shift, increment, and compound-assignment operators of `beman::big_int` +.This https://github.com/bemanproject/big_int/blob/main/examples/operators.cpp[example] demonstrates the fundamental arithmetic, comparison, bitwise, shift, increment, and compound-assignment operators of `beman::big_int` ==== [source, c++] ---- @@ -62,7 +62,7 @@ result_is_ok: true [#examples_factorial] === Factorial -.This https://github.com/eisenwave/std-big-int/blob/main/examples/factorial.cpp[example] demonstrates computing the 100th factorial with `beman::big_int` using ordinary arithmetic operators in a recursive function +.This https://github.com/bemanproject/big_int/blob/main/examples/factorial.cpp[example] demonstrates computing the 100th factorial with `beman::big_int` using ordinary arithmetic operators in a recursive function ==== [source, c++] ---- @@ -82,7 +82,7 @@ result_is_ok: true [#examples_literals] === User-defined literals -.This https://github.com/eisenwave/std-big-int/blob/main/examples/literals.cpp[example] demonstrates writing `beman::big_int` constants directly in source code with the `_n` and `_N` literal suffixes, including non-decimal bases, digit separators, and negative values +.This https://github.com/bemanproject/big_int/blob/main/examples/literals.cpp[example] demonstrates writing `beman::big_int` constants directly in source code with the `_n` and `_N` literal suffixes, including non-decimal bases, digit separators, and negative values ==== [source, c++] ---- @@ -103,7 +103,7 @@ result_is_ok: true [#examples_charconv] === Numeric conversions -.This https://github.com/eisenwave/std-big-int/blob/main/examples/charconv.cpp[example] demonstrates parsing a `beman::big_int` from text with `from_chars` and rendering it back with `to_chars`, including the `to_chars` overload that takes the value over +.This https://github.com/bemanproject/big_int/blob/main/examples/charconv.cpp[example] demonstrates parsing a `beman::big_int` from text with `from_chars` and rendering it back with `to_chars`, including the `to_chars` overload that takes the value over ==== [source, c++] ---- @@ -123,7 +123,7 @@ result_is_ok: true [#examples_string] === String conversions -.This https://github.com/eisenwave/std-big-int/blob/main/examples/string.cpp[example] demonstrates rendering a `beman::big_int` to a `std::string` with `to_string` and to a `std::wstring` with `to_wstring`, including the overloads that take the value over +.This https://github.com/bemanproject/big_int/blob/main/examples/string.cpp[example] demonstrates rendering a `beman::big_int` to a `std::string` with `to_string` and to a `std::wstring` with `to_wstring`, including the overloads that take the value over ==== [source, c++] ---- @@ -144,7 +144,7 @@ result_is_ok: true [#examples_numeric] === Numeric functions -.This https://github.com/eisenwave/std-big-int/blob/main/examples/numeric.cpp[example] demonstrates the free numeric helpers in ``: `abs` for the magnitude of a value, `saturating_cast` for range-clamped narrowing to a built-in integer, `in_range` for range checking, `gcd` and `lcm` for the greatest common divisor and least common multiple, and `midpoint` for half the sum of any mix of `big_int` and built-in integer arguments +.This https://github.com/bemanproject/big_int/blob/main/examples/numeric.cpp[example] demonstrates the free numeric helpers in ``: `abs` for the magnitude of a value, `saturating_cast` for range-clamped narrowing to a built-in integer, `in_range` for range checking, `gcd` and `lcm` for the greatest common divisor and least common multiple, and `midpoint` for half the sum of any mix of `big_int` and built-in integer arguments ==== [source, c++] ---- @@ -178,7 +178,7 @@ result_is_ok: true [#examples_limits] === Numeric limits -.This https://github.com/eisenwave/std-big-int/blob/main/examples/limits.cpp[example] demonstrates the `std::numeric_limits` specialization in ``: what it reports for an unbounded type, why `is_bounded` rather than `max()` is the member to test, and how a single template can serve `big_int` and a built-in integer alike +.This https://github.com/bemanproject/big_int/blob/main/examples/limits.cpp[example] demonstrates the `std::numeric_limits` specialization in ``: what it reports for an unbounded type, why `is_bounded` rather than `max()` is the member to test, and how a single template can serve `big_int` and a built-in integer alike ==== [source, c++] ---- @@ -202,7 +202,7 @@ result_is_ok: true [#examples_division] === Integer division -.This https://github.com/eisenwave/std-big-int/blob/main/examples/division.cpp[example] demonstrates the `div_rem_to_zero` free function, which computes the quotient and remainder together in a single division +.This https://github.com/bemanproject/big_int/blob/main/examples/division.cpp[example] demonstrates the `div_rem_to_zero` free function, which computes the quotient and remainder together in a single division ==== [source, c++] ---- @@ -224,7 +224,7 @@ result_is_ok: true [#examples_io] === Formatting and output -.This https://github.com/eisenwave/std-big-int/blob/main/examples/io.cpp[example] demonstrates displaying a `beman::big_int` by converting it to text with `to_string` and by formatting it with `std::format` +.This https://github.com/bemanproject/big_int/blob/main/examples/io.cpp[example] demonstrates displaying a `beman::big_int` by converting it to text with `to_string` and by formatting it with `std::format` ==== [source, c++] ---- @@ -251,7 +251,7 @@ result_is_ok: true [#examples_fibonacci] === Fibonacci -.This https://github.com/eisenwave/std-big-int/blob/main/examples/fibonacci.cpp[example] demonstrates computing the 10,000th Fibonacci number with `beman::big_int` using fast matrix exponentiation by squaring +.This https://github.com/bemanproject/big_int/blob/main/examples/fibonacci.cpp[example] demonstrates computing the 10,000th Fibonacci number with `beman::big_int` using fast matrix exponentiation by squaring ==== [source, c++] ---- @@ -271,7 +271,7 @@ result_is_ok: true [#examples_roots] === Roots -.This https://github.com/eisenwave/std-big-int/blob/main/examples/roots.cpp[example] demonstrates computing the exact integer square root and cube root of a 1,001-digit integer with `beman::big_int` +.This https://github.com/bemanproject/big_int/blob/main/examples/roots.cpp[example] demonstrates computing the exact integer square root and cube root of a 1,001-digit integer with `beman::big_int` ==== [source, c++] ---- @@ -294,7 +294,7 @@ result_is_ok: true [#examples_primes] === Primes -.This https://github.com/eisenwave/std-big-int/blob/main/examples/primes.cpp[example] demonstrates generating pseudo-random 512-bit prime numbers with `beman::big_int` using the Miller-Rabin primality test +.This https://github.com/bemanproject/big_int/blob/main/examples/primes.cpp[example] demonstrates generating pseudo-random 512-bit prime numbers with `beman::big_int` using the Miller-Rabin primality test ==== [source, c++] ---- @@ -343,7 +343,7 @@ prime density: 1/324.1 [#examples_rsa] === RSA -.This https://github.com/eisenwave/std-big-int/blob/main/examples/rsa.cpp[example] demonstrates the usage of `beman::big_int` in the RSA algorithm +.This https://github.com/bemanproject/big_int/blob/main/examples/rsa.cpp[example] demonstrates the usage of `beman::big_int` in the RSA algorithm ==== [source, c++] ---- diff --git a/docs/modules/ROOT/pages/numeric.adoc b/docs/modules/ROOT/pages/numeric.adoc index 2c8b216f..51bebeac 100644 --- a/docs/modules/ROOT/pages/numeric.adoc +++ b/docs/modules/ROOT/pages/numeric.adoc @@ -253,7 +253,7 @@ linear passes per limb of progress. Where the leading limbs determine nothing -- operands that differ widely in size -- a division or a binary step carries the reduction instead. -https://github.com/eisenwave/std-big-int/blob/main/tests/beman/big_int/gcd_bench.test.cpp[gcd_bench.test.cpp] +https://github.com/bemanproject/big_int/blob/main/tests/beman/big_int/gcd_bench.test.cpp[gcd_bench.test.cpp] measures the result against `boost::multiprecision::cpp_int`, which reduces wide operands with the same algorithm. It is built with the tests and runs when `BEMAN_BIG_INT_RUN_BENCHMARKS` is defined. On an Apple M4 Max (AppleClang, @@ -338,7 +338,7 @@ Where both magnitudes fit a single limb the whole computation is scalar -- a single-limb binary gcd, one division, and one widening multiplication -- and a result that fits a limb as well stays in the small-object buffer. -https://github.com/eisenwave/std-big-int/blob/main/tests/beman/big_int/lcm_bench.test.cpp[lcm_bench.test.cpp] +https://github.com/bemanproject/big_int/blob/main/tests/beman/big_int/lcm_bench.test.cpp[lcm_bench.test.cpp] measures the result against `boost::multiprecision::cpp_int`, which composes its own `lcm` the same way. It is built with the tests and runs when `BEMAN_BIG_INT_RUN_BENCHMARKS` is defined. On an Apple M4 Max (AppleClang, diff --git a/extra/README.md b/extra/README.md index f9bdd51f..d883cc41 100644 --- a/extra/README.md +++ b/extra/README.md @@ -19,7 +19,7 @@ in-place static buffer or on the heap. The full write-up, including every way to load the Natvis file and what it displays, is on the -[Debugger Visualizers](https://eisenwave.github.io/std-big-int/debugging.html) +[Debugger Visualizers](https://bemanproject.github.io/big_int/debugging.html) documentation page. ## Loading the visualizers