NumForge 2.2.1

NumForge 2.2.1 is a performance and reliability patch following 2.2.0. The main changes come from independent benchmarks and resource-limit diagnostics; public numeric C signatures and ownership contracts remain unchanged.

Improvements

• Faster large balanced multiplication with budget-aware Karatsuba and normalized integer division.
• Grouped/product-tree factorials with reusable split scratch, tighter admission and faster exact zero normalization. The practical 100000-input cap is removed; counter-range and time/memory/output budgets remain.
• Bounded theta/AGM for suitable high-precision logarithms, reusable ln/exp workspaces and lower GCD/decimal allocation traffic.
• Shared scalar trigonometric and hyperbolic evaluations in complex functions, direct coefficient/digit handling and faster permutations/combinations.
• Calculator and Units previews wait for two seconds without edits. Enter and Calculate/Convert still run immediately.
• Expanded independent reference/benchmark coverage, exhaustive allocation test shards, sanitizer cleanup and stable browser geometry checks.

Verification

The final release commit is checked by the full CI matrix: Windows, Linux GCC/Clang sanitizers, Linux 32-bit, Linux/macOS ARM64, fuzzing, coverage, numeric benchmark checks and the 166-test Chromium suite. Portable Windows/Linux applications and C/C++ developer SDKs are built from the exact release tag and attached with SHA-256 files after extracted-archive verification completes.

Large inputs are still subject to resource budgets, and approximate transcendental functions retain their documented precision contracts. This release does not promise universal correct rounding or completion of arbitrary inputs within five seconds.

Full changelog · Release record

Successful CI for the release commit.

NumForge 2.2.0

NumForge 2.2.0 adds arbitrary-precision complex mathematics to the public C library and the shared CLI/browser calculator. For example, sqrt(-1) returns i, and complex values work with variables, ans, history and HTTP snapshots.

Highlights

• Complex C APIs: owned BigComplex decimal components and exact BigRationalComplex fractions, arithmetic, powers, magnitude, argument and display formatting.
• Scientific functions: principal roots, exponentials, natural/custom-base logarithms, general powers, trigonometric and hyperbolic functions and their inverses. Supported dimensionless real inputs automatically promote to complex results when needed. Complex angles use radians.
• Exact calculations: integer powers and rational complex sum, product and mean retain exact components. Cartesian, trigonometric and exponential display forms are available.
• Numerical stability: exact exponent scaling, a bounded magnitude path, scaled tangent evaluation and input-sensitive working precision reduce selected overflow, cancellation and intermediate-growth problems.
• Sessions and HTTP: authoritative variable/history snapshots, pagination, reset/release and server-owned conversion history with ordered, retryable mutations.
• Calculator and mobile UX: more compact navigation and input, improved guide navigation and result placement, localized library aliases and constant search. Factorials accept inputs up to 100000 within resource limits.

Validation and limits

Local Windows validation passed 1284 independent complex reference cases, 584 isolated memory probes, 161 Chromium desktop/mobile and HTTP scenarios, numeric/application checks and external C/C++ SDK consumers. Final GitHub CI and Windows/Linux packaging runs are available in Actions.

Existing public numeric C signatures remain source compatible. Approximate transcendental functions do not provide universal correctly-rounded results or whole-expression error bounds; difficult cancellation, poles and exact intermediate growth remain subject to scale, time and memory limits. Functions return principal branches, not every possible root or logarithm branch. Lowercase i is reserved as the imaginary unit.

Downloads

Portable Windows/Linux x64 applications and C/C++ SDK archives, with matching SHA-256 files, are attached automatically after both platform packaging checks succeed. Extract the full application archive and run numforge_web.exe on Windows or ./numforge_web on Linux; the CLI is included. Windows applications use the static C runtime; the MSVC SDK uses /MD. Linux packages require a compatible glibc runtime recorded in their build information.

See the short changelog, full changelog and release record. Released under the MIT License.

NumForge 2.1.0

NumForge 2.1.0

Exact unit conversions and dimensional arithmetic join the C17 arbitrary-precision
library and its bilingual CLI/browser calculator.

Highlights

• Units: a sourced catalogue of 233 units and a Slovak/English browser converter
  with compatible categories, live previews, confirmation, swap, copy and history.
• Calculator expressions: convert(1; "km"; "m") returns 1000;
  qty(5; "m") * qty(5; "m") returns 25 m². Quantities retain their dimensions
  through compatible arithmetic, variables, ans and history.
• Variables: confirmed exact values, History/Variables tabs, capacity display
  and individual deletion through the UI or HTTP session command.
• Library: BigInt input/output in bases 2–36, faster short formatting of huge
  numbers and improved tangent reduction near poles.
• Structure and docs: separate numeric, calculation, application and HTTP
  layers; categorized documentation, concise changelog and refreshed screenshots.
• Distribution: portable Windows/Linux x64 downloads, build provenance and
  SHA-256 checksums, built and checked automatically from the release tag.

Run without a compiler

Download the Windows ZIP or Linux tar.gz and its .sha256 file. Verify the checksum,
extract the whole archive, then run numforge_web.exe (Windows) or ./numforge_web
(Linux). On Windows the browser opens automatically; on Linux open
http://127.0.0.1:8765. The archive also includes the calculator CLI.

No Node.js, Python, database or compiler is needed. Windows x64 binaries link the C
runtime statically and are unsigned. Linux x64 requires glibc; its minimum runtime
and the exact source commit are recorded in START_HERE.txt. These are portable
archives, not installers or automatic updates.

Developer SDK downloads

For C/C++ integration, choose NumForge-2.1.0-sdk-win-x64.zip or
NumForge-2.1.0-sdk-linux-x64.tar.gz and its matching SHA-256 file.
Each SDK contains public headers, a Release static numeric library, relocatable
CMake exports, a working exact-decimal C example, a short README, MIT license
and BUILDINFO.json. Use find_package(NumForge 2.1 CONFIG REQUIRED) and link
NumForge::numforge. Follow the included README to build the example.

Windows SDK: MSVC 19.44 x64 Release /MD; use a compatible MSVC toolchain and
matching dynamic CRT (not MinGW, /MT or Debug /MDd). Linux SDK: GCC 11.4 x64,
glibc 2.35 or newer supported baseline (not musl). Other toolchains should build
from source. These SDKs expose the public numeric C API; calculator/session/HTTP
internals remain application components.

SDK assets were added after publication from the unchanged v2.1.0 numeric
source. Both platforms passed the bundled example and relocated external C/C++
consumer checks; downloaded archives and checksums were verified. New releases
build application and SDK assets automatically.

Compatibility and scope

Existing public C numeric signatures remain source compatible with 2.0;
NumForge::numforge remains the installed CMake target. Calculator qty(...) and
session APIs belong to the optional application, not a new installed C Quantity ABI.

Sessions are in-memory and converter history is browser-tab state. Accounts,
graphs, equations, general compound unit input and full HTTP list/history/reset
coverage remain future work. The server listens on loopback and is not intended
for direct public hosting. Approximate scientific functions do not claim universal
correct rounding or whole-expression error bounds.

Local verification passed 37 GCC CTest checks, 94 Chromium scenarios on the MSVC
production server, external C/C++ consumers and extracted Windows package checks.
The final release also requires successful GitHub CI and Windows/Linux package
dry runs before publication.

See the short changelog,
full changelog and
release record.
Released under the MIT License.

NumForge 2.0.0

NumForge 2.0.0

A major expansion of the C17 arbitrary-precision library, with a redesigned bilingual calculator. This is one source release: the public numeric library is the main product, and the CLI and local web calculator remain optional clients.

Library

• New public BigRational API for reduced exact fractions, arithmetic, comparison and decimal conversion.
• BigDecimal gains output notation modes, signed integer powers, hyperbolic functions and sequence aggregation.
• Exact integers and fractions remain exact through calculator results, ans and history until an approximate operation requires BigDecimal.

Calculator and web

• New SK/EN local web interface with searchable functions, responsive controls, session history, result copying and clearer input/output.
• rand(), rand(x) and rand(x;y), fraction output, and inverse-function arc/arcus aliases.
• Editable HTML, CSS and JavaScript now live under web/ and are embedded into the local C server at build time.

Compatibility and installation

Existing BigInt and BigDecimal C signatures remain source compatible with 1.0. The CMake package uses major version 2; consumers requesting find_package(NumForge 1.0 ...) must update their requirement to find_package(NumForge 2.0 CONFIG REQUIRED).

To build and install only the library, configure with -DNUMFORGE_BUILD_APPS=OFF -DBUILD_TESTING=OFF. The source archive also includes the optional CLI and local web calculator.

Verification

CI passed on x64 Linux and Windows, 32-bit Linux, ARM64 Linux and macOS. It also passed Clang sanitizer/fuzz checks, 63 Chromium browser scenarios and installed-package tests with external C and C++ consumers. The independent high-precision oracle checks nearest rounding exactly; directed transcendental reference cases currently allow at most 1 ULP difference.

See the changelog, README and library guide for details. Released under the MIT License.

NumForge 1.0.0

NumForge 1.0.0

First stable release of NumForge — an arbitrary-precision mathematics library and exact-decimal calculator written in C.

Features

• Arbitrary-precision signed BigInt
• Exact base-10 BigDecimal
• Arithmetic, powers, factorial, number-theory and bitwise operations
• Expression parser with constants, implicit multiplication and scientific notation
• Configurable result precision and rounding
• Command-line calculator
• Bilingual local web calculator
• Local HTTP API
• Installable CMake package with NumForge::numforge

Quality

• Unit and deterministic property tests
• Allocation-failure testing
• HTTP end-to-end smoke testing
• Linux, Windows and 32-bit CI
• AddressSanitizer, UndefinedBehaviorSanitizer and LeakSanitizer checks
• Warnings treated as errors

Installation

Build instructions and API documentation are available in the project README.

Released under the MIT License.