V3.98: posit v1 to posit v2 transition and adding arm64, PPC, and MINGW as cross-platform targets (#508)

* Incrementing SEMVER v3.98

* Rename posit → posit1, posit2 → posit: make BlockType-based posit the default

Move the old bitset-based posit (2-param template) to posit1/ for backward
compatibility, and promote the new BlockType-based posit2 (3-param template)
to posit/ so that #include <universal/number/posit/posit.hpp> gives consumers
the modern implementation.

Key changes:
- include/sw/universal/number/posit/ now contains the new 3-param posit
- include/sw/universal/number/posit1/ preserves the old 2-param posit
- Math library copied from posit1 into new posit with 3-param signatures
- posit_traits.hpp updated for 3-param, new posit1_traits.hpp for 2-param
- Test directories: static/posit/ (new), static/posit1/ (old)
- sqrt.hpp fixed for blockbinary::bits() → unsigned cast in table lookups
- Verification header decoupled from direct mathlib include

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* Fix quire tests to include posit1 (quire requires old posit)

The quire super-accumulator is only implemented for the old 2-param
posit (now posit1). Update the two quire test files to include
posit1/posit1.hpp instead of posit/posit.hpp.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* Fix posito to use posit1 (depends on old posit internal classes)

posito uses positRegime, positExponent, and positFraction from the old
posit implementation. Update posito.hpp and posito_impl.hpp to include
from posit1/ instead of posit/. Also fix number_system.cpp which
explicitly included posit/posit.hpp alongside posito.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* Fix remaining posit→posit1 include paths for CI

- valid_impl.hpp: use posit1/posit_impl.hpp (valid depends on bitblock)
- exceptions.hpp: add shared include guard to prevent redefinition when
  both posit/ and posit1/ exceptions are included in the same TU
- takum, posito conversion tests: use posit1 (they also include posito
  which transitively includes posit1, can't mix with new 3-param posit)
- C API: all files updated to use posit1/ paths (posit_c_api.h,
  posit_c_macros.h, specialized headers, posit.hpp)
- Conversion tests: rounding, to_integer, to_posit, adapt_integer use
  old posit internals (bitblock, value) so need posit1
- BLAS fused solvers: use quire/fdp which only exists in posit1
- Education/tools: quire demos and posit property tools use posit1

CI_LITE: 397/397 tests pass.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* Fix utility headers and mixed-precision for 3-param posit

- error_tracking_traits.hpp: update posit forward declaration and
  partial specialization from 2-param to 3-param template
- tracked_shadow.hpp: update posit forward declaration and TrackedPosit
  alias to 3-param template
- Tensor CG/DNN files: switch to posit1 (they use quire/fdp solvers)
- Simple mixed-precision files: remove boilerplate quire_exception catch
  blocks (std::runtime_error catch covers them)

CI_LITE: 397/397 tests pass.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* Fix benchmark files for posit rename

- gemm.cpp (5 variants): switch to posit1 (uses sw::universal::fdp)
- dot/matvec/posit perf benchmarks (19 files): remove boilerplate
  quire_exception catch blocks (std::runtime_error covers them)

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* Fix remaining BUILD_ALL failures for posit rename

- education/number/posit/ (15 files): switch to posit1 (use old posit
  internals like positRegime, positExponent, positFraction, pretty_print)
- tools/cmd/posit.cpp, float2posit.cpp: switch to posit1 (use bitblock,
  internal::value, pretty_print)
- benchmark/performance/posit/performance.cpp: fix POSIT_OLD_GENERATION
  include path to posit1, update #else to new posit path

BUILD_ALL: 0 errors. CI_LITE: 397/397 tests pass.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* Fix all BUILD_ALL compilation failures for posit rename

- Switch files using old posit internals (value<>, bitblock, quire, fdp,
  pretty_print, info_print, .get(), useed<nbits,es>, positRegime,
  positExponent, positFraction, setBitblock) to posit1
- Remove boilerplate quire_exception catch blocks from files using new posit
- Fix posit/posito coexistence: files including posito must use posit1
- Fix posit/valid coexistence: files including valid must use posit1
- Update number_systems.hpp aggregator to use posit1 (full-featured)
- Update datafile.hpp is_posit trait to is_posit1
- Fix enable_if_posit -> enable_if_posit1 in error_vs_cost.cpp
- Fix attention.cpp posit2->posit path

Files affected: 50 across applications/, education/, linalg/,
numeric/, playground/, and include/sw/blas/

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* Disable POSIT_THROW_ARITHMETIC_EXCEPTION in benchmarks and CG solver

Performance benchmarks exercise all values including division by zero,
and the CG solver can encounter divide-by-zero when low-precision posits
cause stalling. Both need arithmetic exceptions disabled.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* original posit applications that have a trivial migration to new posit implementation

* adding missing manipulators to new posit

* completing attribute functions for new posit

* Port quire, FDP, and fused BLAS to new posit

Add bridge functions (convert, posit_to_value, posit_normalize_to) to
posit_impl.hpp that convert between internal::value<>/bitblock<> and
blocktriple<>/blocksignificand<> type systems. Create posit/quire.hpp
and posit/fdp.hpp adapted from posit1 with bt-templated posit-facing
methods. Migrate 19 consumer files from posit1 to new posit. Make fused
solver headers posit-agnostic so IR apps using posito can stay on posit1.
934/934 tests pass on both gcc and clang.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* Migrate remaining posit1 consumer files to new posit

Migrate two_sum.cpp (.get() -> .bits(), minpos free fn -> member fn),
values.cpp, extract.cpp (add using namespace internal), and propq.cpp
to use posit/posit.hpp. Create posit/twoSum.hpp adapted from posit1
with bt-templated signature. 934/934 tests pass on gcc and clang.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* Rewrite education files to use blocktriple instead of internal::value

Replace internal::value<> and internal::bitblock<> with blocktriple<> in
values.cpp and extract.cpp. The blocktriple type is the modern replacement
for the legacy value<> type system.

- values.cpp: ValidateValue -> ValidateBlocktriple, replace round_to<>
  demo with precision-across-sizes demo showing significand degradation
- extract.cpp: replace extract_fp_components/bitblock/value chain with
  blocktriple for IEEE display and direct posit assignment for conversion

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* quire and fdp migration plan

* change and session log for Feb 12, 2026

* WIP: fixing up the posit API

* Fix inverted operator>(literal, posit) and missing bt template args

All 13 operator>(literal_type lhs, posit rhs) free functions had an
inverted comparison: returned lhs < rhs instead of rhs < lhs. Also
fix check_inward_projection_range calls missing the bt template arg
in float2posit.cpp and conversion.cpp.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* Rewrite atomic fused operators to blocktriple and extract quire from posit.hpp

Eliminates the last value<> dependency from the posit arithmetic pipeline.
fma/fam/fmma now use blocktriple<> exclusively with extract-and-reconstruct
helpers for chaining operations across operator types. Quire/fdp moved to
standalone opt-in headers; 25+ consumer files updated with explicit includes.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* code hygiene

* Add ARM64 and MinGW-w64 cross-compilation CI targets

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* Fix long double decoder and manipulators for ARM64 128-bit quad precision

On aarch64-linux-gnu-g++, long double is IEEE 754 binary128 (same as
POWER), not 80-bit x87 extended. The long_double_decoder union lacked
the upper/fraction split fields, and gcc_long_double.hpp fell through
to the x86 code path referencing the nonexistent bit63 member.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* Fix extract_fp_components redefinition on MinGW where uint64_t is unsigned long long

On MinGW-w64, uint64_t and unsigned long long are the same type, so
the overload in gcc_long_double.hpp clashes with the one already
provided by extract_fp_components.hpp. Guard with !_WIN32.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* Fix C API test linking for MinGW cross-compilation

The posit_c_api_pure library was only linked under if(UNIX) or
if(MSVC). MinGW cross-compilation sets CMAKE_SYSTEM_NAME=Windows,
so neither condition matched and the library was never linked.
Always link the library; only add -lm on UNIX.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* Use target-based add_test() for cross-compilation compatibility

The old add_test() calls used a manual path via RUNTIME_OUTPUT_DIRECTORY
which was never set, and didn't include .exe suffix for Windows targets.
Switch to add_test(NAME ... COMMAND ...) which lets CMake resolve the
correct executable path and automatically prepend the crosscompiling
emulator (wine for MinGW, qemu for ARM/RISC-V/POWER).

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* Static link GCC/C++ runtime in MinGW toolchain for Wine compatibility

Wine can't find libgcc_s_seh-1.dll and libstdc++-6.dll at runtime.
Adding -static to linker flags embeds the runtime into each executable.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* Fix MinGW GCC optimizer bugs causing lns and floatcascade test failures

Two MinGW-specific GCC bugs caused 5 test failures in the CI:

1. LNS sign bit loss (4 tests): GCC's IPA ICF incorrectly folds
   different lns<nbits> setbit template instantiation fragments after
   function splitting. When lns<4> and lns<8> are in the same TU,
   the 8-bit version loses all sign bits. Fix: -fno-ipa-icf

2. floatcascade multiplication precision (1 test): MinGW's software
   std::fma() has subtle precision errors for some inputs (off by
   1-2 ULPs), breaking the error-free transformations that
   floatcascade relies on for quad-double precision. Fix: -mfma
   to use hardware FMA3 instructions instead.

Both workarounds are applied via CMAKE_CXX_FLAGS_INIT in the MinGW
toolchain file. All 390 CI_LITE tests now pass under MinGW+Wine.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* changelog and session log for ARM64/MinGW cross-compilation CI

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* blocktriple and quire conversion plan

---------

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>

Author: Ravenwater

.github/workflows/cmake.yml

@@ -2,7 +2,7 @@ name: CMake
 
 on:
   push:
-    branches: [ v3.97, main ]
+    branches: [ v3.98, main ]
   pull_request:
     branches: [ main ]
 
@@ -63,6 +63,20 @@ jobs:
             cross: ppc64le
             toolchain: cmake/toolchains/ppc64le-linux-gnu.cmake
             cmake_flags: -DUNIVERSAL_BUILD_CI_LITE=ON
+          # ARM64 cross-compilation with QEMU emulation
+          - os: ubuntu-latest
+            name: Linux ARM64 (GCC cross)
+            artifact: linux-aarch64-gcc
+            cross: aarch64
+            toolchain: cmake/toolchains/aarch64-linux-gnu.cmake
+            cmake_flags: -DUNIVERSAL_BUILD_CI_LITE=ON
+          # Windows cross-compilation with MinGW-w64
+          - os: ubuntu-latest
+            name: Windows x64 (MinGW GCC cross)
+            artifact: windows-x64-mingw
+            cross: mingw
+            toolchain: cmake/toolchains/x86_64-w64-mingw32.cmake
+            cmake_flags: -DUNIVERSAL_BUILD_CI_LITE=ON
 
     steps:
       - name: Checkout
@@ -90,6 +104,20 @@ jobs:
           sudo apt-get install -y g++-powerpc64le-linux-gnu qemu-user-static
           echo "QEMU_LD_PREFIX=/usr/powerpc64le-linux-gnu" >> $GITHUB_ENV
 
+      - name: Install ARM64 cross-compiler and QEMU
+        if: matrix.cross == 'aarch64'
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y g++-aarch64-linux-gnu qemu-user-static
+          echo "QEMU_LD_PREFIX=/usr/aarch64-linux-gnu" >> $GITHUB_ENV
+
+      - name: Install MinGW-w64 cross-compiler and Wine
+        if: matrix.cross == 'mingw'
+        run: |
+          sudo dpkg --add-architecture i386
+          sudo apt-get update
+          sudo apt-get install -y g++-mingw-w64-x86-64 wine wine64
+
       # ccache for Linux and macOS
       - name: Install and configure ccache
         if: runner.os != 'Windows'

CHANGELOG.md

@@ -9,6 +9,67 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 
+#### 2026-02-13 - ARM64 and MinGW Cross-Compilation CI with Bug Fixes
+
+- **Two new cross-compilation CI targets** added to `cmake.yml` matrix:
+  - **ARM64 Linux** — `aarch64-linux-gnu-g++` cross-compiler with QEMU user-mode emulation
+  - **Windows x64 (MinGW-w64)** — `x86_64-w64-mingw32-g++` cross-compiler with Wine emulation
+
+- **CMake toolchain files** created:
+  - `cmake/toolchains/aarch64-linux-gnu.cmake` — ARM64 cross-compilation with `qemu-aarch64-static` emulator
+  - `cmake/toolchains/x86_64-w64-mingw32.cmake` — MinGW-w64 cross-compilation with Wine, static linking, `-fno-ipa-icf -mfma` workarounds
+
+- **Platform portability fixes** (7 commits):
+  - ARM64 `long double` 128-bit quad precision: `bit63` member not available in `long_double_decoder` — use `limb()` for quad format
+  - MinGW `extract_fp_components` redefinition: `uint64_t` is `unsigned long long` on MinGW (not `unsigned long`) — guarded with `#if !defined(_WIN32)`
+  - MinGW C API linking: added `ws2_32` dependency and static linking for cross-compiled targets
+  - MinGW ctest: switched C API tests from `compile_and_link_all` to target-based `add_test(NAME ... COMMAND ...)` for cross-compilation compatibility
+  - MinGW Wine DLL resolution: static-linked GCC/C++ runtime via `CMAKE_EXE_LINKER_FLAGS_INIT "-static"`
+  - **MinGW GCC IPA ICF bug**: function splitting + Identical Code Folding incorrectly merges `lns<4>::setbit.part.0` with `lns<8>::setbit.part.0`, causing all negative LNS values to lose their sign bit when multiple `lns<nbits>` instantiations exist in the same translation unit. Fix: `-fno-ipa-icf`
+  - **MinGW software `std::fma()` precision bug**: off by 1-2 ULPs for some inputs, breaking error-free transformations (`two_prod`) in `floatcascade`. Fix: `-mfma` to use hardware FMA3 instructions
+
+- **All 390 CI_LITE tests pass** on MinGW+Wine after fixes
+
+#### 2026-02-13 - Rewrite Atomic Fused Operators to blocktriple and Extract Quire from posit.hpp
+
+- **Atomic fused operators rewritten to use blocktriple<> exclusively** — zero dependency on `internal::value<>`, `bitblock<>`, `module_multiply`, or `module_add`
+  - `fma(a, b, c)`: MUL → ADD → convert pattern (single rounding)
+  - `fam(a, b, c)`: ADD → MUL → convert pattern with wider MUL type (`wfbits = fbits + 3`) to preserve ADD precision
+  - `fmma(a, b, c, d)`: MUL → MUL → ADD → convert pattern (single rounding)
+  - Helper functions: `extractToAdd()`, `extractToMul()`, `normalizeMultiplicationWide()` for chaining blocktriple operations across operator types
+
+- **Quire/FDP extracted from posit.hpp** — base posit header no longer pulls in quire or value<> dependency
+  - `quire.hpp` made standalone (includes `posit.hpp` instead of being included by it)
+  - `fdp.hpp` includes `quire.hpp` for self-contained usage
+  - `posit_fwd.hpp` cleaned of `value<>`, `quire`, and `quire_mul` forward declarations
+  - `math/sqrt.hpp`: `fast_sqrt` guarded behind `POSIT_NATIVE_SQRT` to avoid value<> dependency
+
+- **25+ consumer files updated** to explicitly include quire/fdp headers
+  - BLAS ext headers (`posit_fused_blas.hpp`, `posit_fused_lu.hpp`, `posit_fused_backsub.hpp`, `posit_fused_forwsub.hpp`) converted to "consumer must include" pattern — avoids 2-param vs 3-param posit template conflicts when posit1 consumers include them
+  - All fma/fam/fmma tests pass exhaustively on both gcc and clang
+  - Full BUILD_ALL builds clean on both compilers
+
+#### 2026-02-12 - Port Quire, FDP, and Fused BLAS to New Posit
+
+- **Quire and FDP ported to new 3-param posit** (`posit<nbits, es, bt>`)
+  - `include/sw/universal/number/posit/quire.hpp` — new file, adapted from posit1 with bt-templated posit-facing methods and `posit_to_value()`/`convert(value<>, posit<>)` bridge functions
+  - `include/sw/universal/number/posit/fdp.hpp` — new file, fused dot product using `enable_if_posit` traits
+  - `include/sw/universal/number/posit/twoSum.hpp` — new file, TwoSum algorithm for new posit
+  - Bridge functions in `posit_impl.hpp`: `convert(internal::value<>, posit<>)`, `posit_to_value()`, `posit_normalize_to()` connect blocktriple-based posit with value-based quire internals
+
+- **23 consumer files migrated from posit1 to new posit** — quire tests, BLAS reproducibility, benchmarks, education, tools
+  - BLAS fused solver headers made posit-agnostic (removed posit include) to allow coexistence with posit1 consumers
+  - `posit_range()` function added to manipulators.hpp
+  - `extract_fraction()` in attributes.hpp fixed for blockbinary (`.get()` → `.bits()`)
+
+- **Education files rewritten to use blocktriple** instead of `internal::value<>`
+  - `education/number/posit/values.cpp` — `ValidateBlocktriple<>`, precision-across-sizes demo replacing `round_to<>` demo
+  - `education/number/posit/extract.cpp` — blocktriple for IEEE-754 decomposition display, direct posit assignment for conversion
+
+- **posito preserved as reference** — posito and its `value<>`-based engine kept intentionally as comparison implementation for the posit2 transformation
+
+- **934/934 tests pass** on both gcc and clang after all changes
+
 #### 2026-02-10 - posit2 Conversion, Assignment, and Logic Test Suites
 
 - **posit2 conversion/assignment/logic test suites** — ported from original posit, all passing

CMakeLists.txt

@@ -20,7 +20,7 @@ if(NOT DEFINED UNIVERSAL_VERSION_MAJOR)
   set(UNIVERSAL_VERSION_MAJOR 3)
 endif()
 if(NOT DEFINED UNIVERSAL_VERSION_MINOR)
-  set(UNIVERSAL_VERSION_MINOR 97)
+  set(UNIVERSAL_VERSION_MINOR 98)
 endif()
 if(NOT DEFINED UNIVERSAL_VERSION_PATCH)
   set(UNIVERSAL_VERSION_PATCH 1)
@@ -521,9 +521,9 @@ macro (compile_all testing prefix folder)
         set_target_properties(${test_name} PROPERTIES FOLDER ${folder})
         if (${testing} STREQUAL "true")
             if (UNIVERSAL_CMAKE_TRACE)
-                message(STATUS "testing: ${test_name} ${RUNTIME_OUTPUT_DIRECTORY}/${test_name}")
+                message(STATUS "testing: ${test_name}")
             endif()
-            add_test(${test_name} ${RUNTIME_OUTPUT_DIRECTORY}/${test_name})
+            add_test(NAME ${test_name} COMMAND ${test_name})
         endif()
     endforeach (source)
 endmacro (compile_all)
@@ -539,9 +539,9 @@ macro (compile_multifile_target testing test_name folder)
     set_target_properties(${test_name} PROPERTIES FOLDER ${folder})
     if (${testing} STREQUAL "true")
         if (UNIVERSAL_CMAKE_TRACE)
-            message(STATUS "testing: ${test_name} ${RUNTIME_OUTPUT_DIRECTORY}/${test_name}")
+            message(STATUS "testing: ${test_name}")
         endif()
-        add_test(${test_name} ${RUNTIME_OUTPUT_DIRECTORY}/${test_name})
+        add_test(NAME ${test_name} COMMAND ${test_name})
     endif()
 endmacro (compile_multifile_target)
 
@@ -958,8 +958,8 @@ endif(UNIVERSAL_BUILD_NUMBER_UNUM2S)
 
 if(UNIVERSAL_BUILD_NUMBER_POSITS)
 add_subdirectory("static/posit")
-add_subdirectory("static/posit/specialized")
-add_subdirectory("static/posit2")
+add_subdirectory("static/posit1")
+add_subdirectory("static/posit1/specialized")
 add_subdirectory("static/quire")
 endif(UNIVERSAL_BUILD_NUMBER_POSITS)
 

applications/accuracy/optimization/error_vs_cost.cpp

@@ -8,6 +8,7 @@
 #include <iostream>
 #include <universal/number/fixpnt/fixpnt.hpp>
 #include <universal/number/posit/posit.hpp>
+#include <universal/number/posit/fdp.hpp>
 // Stillwater BLAS library
 #include <blas/blas.hpp>
 #include <blas/solvers.hpp>

applications/accuracy/pde/cg.cpp

@@ -10,8 +10,9 @@
 // standard library
 #include <limits>
 // Configure the posit library with arithmetic exceptions
-// enable posit arithmetic exceptions
-#define POSIT_THROW_ARITHMETIC_EXCEPTION 1
+// disable posit arithmetic exceptions: CG solver may encounter
+// divide-by-zero when low-precision posits cause stalling
+//#define POSIT_THROW_ARITHMETIC_EXCEPTION 1
 // and fast posits
 //#define POSIT_FAST_SPECIALIZATION 1
 #define POSIT_FAST_POSIT_32_2 1

applications/accuracy/science/physics_constants.cpp

@@ -7,7 +7,9 @@
 #include <universal/utility/directives.hpp>
 #include <universal/utility/compiler.hpp>
 #include <universal/traits/arithmetic_traits.hpp>
+//#include <universal/number/posit1/posit1.hpp>
 #include <universal/number/posit/posit.hpp>
+#include <universal/internal/value/value.hpp>
 #include <universal/number/integer/integer.hpp>
 
 /*

applications/approximation/chebyshev/chebtests.cpp

@@ -166,10 +166,6 @@ catch (const sw::universal::posit_arithmetic_exception& err) {
 	std::cerr << "Uncaught posit arithmetic exception: " << err.what() << std::endl;
 	return EXIT_FAILURE;
 }
-catch (const sw::universal::quire_exception& err) {
-	std::cerr << "Uncaught quire exception: " << err.what() << std::endl;
-	return EXIT_FAILURE;
-}
 catch (const sw::universal::posit_internal_exception& err) {
 	std::cerr << "Uncaught posit internal exception: " << err.what() << std::endl;
 	return EXIT_FAILURE;

applications/approximation/chebyshev/lambdas.cpp

@@ -66,10 +66,6 @@ catch (const sw::universal::posit_arithmetic_exception& err) {
 	std::cerr << "Uncaught posit arithmetic exception: " << err.what() << std::endl;
 	return EXIT_FAILURE;
 }
-catch (const sw::universal::quire_exception& err) {
-	std::cerr << "Uncaught quire exception: " << err.what() << std::endl;
-	return EXIT_FAILURE;
-}
 catch (const sw::universal::posit_internal_exception& err) {
 	std::cerr << "Uncaught posit internal exception: " << err.what() << std::endl;
 	return EXIT_FAILURE;

applications/approximation/chebyshev/nodes.cpp

@@ -49,10 +49,6 @@ catch (const sw::universal::posit_arithmetic_exception& err) {
 	std::cerr << "Uncaught posit arithmetic exception: " << err.what() << std::endl;
 	return EXIT_FAILURE;
 }
-catch (const sw::universal::quire_exception& err) {
-	std::cerr << "Uncaught quire exception: " << err.what() << std::endl;
-	return EXIT_FAILURE;
-}
 catch (const sw::universal::posit_internal_exception& err) {
 	std::cerr << "Uncaught posit internal exception: " << err.what() << std::endl;
 	return EXIT_FAILURE;

applications/approximation/chebyshev/playground.cpp

@@ -44,10 +44,6 @@ catch (const sw::universal::posit_arithmetic_exception& err) {
 	std::cerr << "Uncaught posit arithmetic exception: " << err.what() << std::endl;
 	return EXIT_FAILURE;
 }
-catch (const sw::universal::quire_exception& err) {
-	std::cerr << "Uncaught quire exception: " << err.what() << std::endl;
-	return EXIT_FAILURE;
-}
 catch (const sw::universal::posit_internal_exception& err) {
 	std::cerr << "Uncaught posit internal exception: " << err.what() << std::endl;
 	return EXIT_FAILURE;