react-native-nitro-zxing 0.1.0-alpha.0

package/cpp/zxing-core/core/src/librscpp/README.md

@@ -0,0 +1,65 @@
+# librscpp
+
+`librscpp` is a small header-only Reed-Solomon implementation in C++20.
+
+Pick a Galois field that matches your symbology or protocol, then call `encode()` or `decode()` on a codeword.
+
+## Example
+
+```cpp
+#include "librscpp/encode.h"
+#include "librscpp/decode.h"
+
+#include <string>
+#include <print>
+
+int main()
+{
+	// GF(256) used in QR Codes with polynomial = x^8 + x^4 + x^3 + x^2 + 1 and fcr = 0.
+	auto field = librscpp::GF2n<uint8_t>(0b1'0001'1101, 0);
+	std::println("Using field: GF({}) and fcr: {}", field.size(), field.fcr());
+
+	const std::string data = "Hello, World!";
+	constexpr int paritySize = 4;
+
+	auto codeword = librscpp::encode(field, data, paritySize);
+	std::println("Encoded codeword: '{}'", codeword);
+
+	// Simulate a couple of symbol errors.
+	codeword[3] = codeword[8] = '*';
+	std::println("Corrupt codeword: '{}'", codeword);
+
+	auto res = librscpp::decode(field, codeword, paritySize);
+	if (res)
+		std::println("Decoded codeword: '{}'\nUsed parity symbols: {}", codeword, *res);
+	else
+		std::println("Failed to decode codeword.");
+
+	return 0;
+}
+```
+
+Running this example program produces the following output:
+```
+Using field: GF(256) and fcr: 0
+Encoded codeword: 'Hello, World!??t'
+Corrupt codeword: 'Hel*o, W*rld!??t'
+Decoded codeword: 'Hello, World!??t'
+Used parity symbols: 4
+```
+
+## Configuration
+
+The PDF417 symbology uses the prime GF(929) with primitive root 3 and fcr 1: `librscpp::GFp<>(929, 3, 1)`.
+
+If you are low on memory, you can `#define LIBRSCPP_SAVE_MEMORY` before including the header to save 1/3 of runtime memory used by the GF internal lookup tables. Without that, each GF2n/GFp instance allocates 3 * field_size * sizeof(T) bytes. Also the default `value_type` of `GF2n<>` and `GFp<>` is `uint16_t`. If your field size is <=256 (like the one in the sample code), you can save 50% by using `uint8_t`.
+
+Other common/usable `GF2n` configurations are:
+```c++
+	GF2n<> gf_0x0013(0x0013, 1); // x^4 + x + 1
+	GF2n<> gf_0x0043(0x0043, 1); // x^6 + x + 1
+	GF2n<> gf_0x012D(0x012D, 1); // x^8 + x^5 + x^3 + x^2 + 1 : DataMatrix
+	GF2n<> gf_0x011D(0x011D, 0); // x^8 + x^4 + x^3 + x^2 + 1 : QRCode
+	GF2n<> gf_0x0409(0x0409, 1); // x^10 + x^3 + 1
+	GF2n<> gf_0x1069(0x1069, 1); // x^12 + x^6 + x^5 + x^3 + 1
+```

package/cpp/zxing-core/core/src/librscpp/decode.h

@@ -0,0 +1,258 @@
+// Copyright 2016 ZXing authors
+// Copyright 2017-2026 Axel Waggershauser
+// SPDX-License-Identifier: Apache-2.0
+
+#include "field.h"
+#include "poly.h"
+
+#include <algorithm>
+#include <optional>
+#include <stdexcept>
+#include <type_traits>
+#include <utility>
+
+namespace librscpp {
+
+namespace {
+
+template <typename Field>
+std::optional<std::tuple<Poly<Field>, Poly<Field>>> sugiyama_algorithm(Poly<Field>&& syndromes)
+{
+	// See https://en.wikipedia.org/wiki/Reed–Solomon_error_correction#Sugiyama_decoder
+	auto& field = syndromes.field;
+	int R = syndromes.size();
+	syndromes.normalize();
+	size_t fullSize = R + 1;
+	size_t halfSize = (R + 1) / 2 + 1; // ceil(R / 2) + 1
+	Poly<Field> r(field, std::move(syndromes), fullSize), rLast(field, fullSize);
+	Poly<Field> tLast(field, halfSize), t(field, halfSize), q(field, halfSize);
+
+	rLast.set(1, R);
+	tLast.set(0);
+	t.set(1);
+
+	// Run extended Euclidean algorithm until r's degree is less than R/2
+	while (r.deg() >= R / 2) {
+		swap(tLast, t);
+		swap(rLast, r);
+
+		// Divide r by rLast, with quotient in q and remainder in r
+		r.div(rLast, q);
+		assert(r.deg() < rLast.deg());
+
+		q.mul(tLast);
+		t.sub(q);
+	}
+
+	if (t.coef(0) == 0)
+		return {};
+
+	int inv_t0 = field.inv(t.coef(0));
+	t.mul(inv_t0);
+	r.mul(inv_t0);
+
+	// locator/lamda is t, evaluator/omega is r
+	return std::tuple{std::move(t), std::move(r)};
+}
+
+template <typename Field>
+static std::vector<int> find_locations(const Poly<Field>& locator)
+{
+	// This is a brute force search for roots of locator (not Chien's search)
+	std::vector<int> res;
+	res.reserve(locator.deg());
+
+	for (int i = 1; i < locator.field.size() && res.size() < res.capacity(); i++)
+		if (locator.evaluate(i) == 0)
+			res.push_back(locator.field.inv(i));
+
+	return res;
+}
+
+template <typename Field>
+static std::vector<int> find_magnitudes(const Poly<Field>& evaluator, const Poly<Field>& locator [[maybe_unused]],
+										const std::vector<int>& locations)
+{
+	// This is directly applying Forney's Formula
+	auto& field = evaluator.field;
+	int numErrors = std::ssize(locations);
+	std::vector<int> res(numErrors);
+	for (int i = 0; i < numErrors; ++i) {
+		int xiInverse = field.inv(locations[i]);
+		int denom = 1;
+		for (int j = 0; j < numErrors; ++j)
+			if (i != j)
+				denom = field.mul(denom, field.sub(1, field.mul(locations[j], xiInverse)));
+		res[i] = field.mul(evaluator.evaluate(xiInverse), field.inv(denom));
+		if (field.fcr() != 0)
+			res[i] = field.mul(res[i], xiInverse);
+	}
+	return res;
+}
+
+#if 0
+template <>
+std::vector<int> find_magnitudes(const Poly<GFpPDF417>& evaluator, const Poly<GFpPDF417>& locator,
+								 const std::vector<int>& locations)
+{
+	const auto& field = evaluator.field;
+
+	Poly<GFpPDF417> formalDerivative(field, locator.size());
+	formalDerivative.resize(locator.deg());
+	for (int i = 1; i <= locator.deg(); i++)
+		formalDerivative.coef(i - 1) = field.mul(i, locator.coef(i));
+
+	// This is directly applying Forney's Formula
+	std::vector<int> result(locations.size());
+	for (size_t i = 0; i < result.size(); i++) {
+		int xiInverse = field.inv(locations[i]);
+		int numerator = field.sub(0, evaluator.evaluate(xiInverse));
+		int denominator = field.inv(formalDerivative.evaluate(xiInverse));
+		result[i] = field.mul(numerator, denominator);
+	}
+	return result;
+}
+#endif
+
+// Compute the Reed-Solomon syndrome polynomial for the given codeword.
+// The returned polynomial has degree < numECC and is zero iff the codeword is valid.
+template <typename Field, typename T>
+Poly<Field> compute_syndromes(const Field& field, std::span<const T> codeword, int numECC)
+{
+#if 0
+	Poly<Field> syndromes(field, numECC + 1);
+	for (int i = 0; i < numECC; i++)
+		syndromes.push_back(Poly<Field>::evaluate(field, codeword, field.exp(numECC - 1 - i + field.fcr())));
+	return syndromes;
+#else
+	// The following cache friendlier version is 2x to 5x faster than the straightforward one above
+	std::vector<typename Field::value_type> roots(numECC);
+	for (int i = 0; i < numECC; ++i)
+		roots[i] = field.exp(numECC - 1 - i + field.fcr());
+
+	std::vector<typename Field::value_type> res(numECC + 1, 0);
+	for (auto coeff : codeword)
+		for (int i = 0; i < numECC; ++i)
+			res[i] = field.add(field.mul(roots[i], res[i]), static_cast<std::make_unsigned_t<T>>(coeff));
+	res.resize(numECC);
+
+	return Poly<Field>(field, std::move(res));
+#endif
+}
+
+}
+
+/**
+ * Decode and correct a Reed-Solomon codeword in place.
+ *
+ * @param field Finite field instance used by the RS code.
+ * @param codeword Input/output codeword symbols; corrected in place on success.
+ * @param numECC Number of ECC/parity symbols in the codeword.
+ * @param erasures Optional symbol indices known to be erased.
+ * @return Number of parity symbols consumed for correction (2*errors + erasures),
+ *         0 if no correction was needed, or std::nullopt if decoding failed.
+ * @throws std::invalid_argument If erasure count exceeds numECC or an erasure index is out of range.
+ */
+template <typename Field, std::integral T>
+[[nodiscard]] std::optional<int> decode(const Field& field, std::span<T> codeword, int numECC, std::span<const int> erasures = {})
+{
+	// See https://en.wikipedia.org/wiki/Reed%E2%80%93Solomon_error_correction and
+	// https://en.wikiversity.org/wiki/Reed%E2%80%93Solomon_codes_for_coders for details on how RS works. See
+	// https://mthsc.clemson.edu/misc/MAM_2014/bmj9b.pdf for details on how to handle erasures and potential optimizations.
+
+	int cwLen = std::ssize(codeword);
+	int numErasures = std::ssize(erasures);
+
+	if (numErasures > numECC)
+		throw std::invalid_argument("Too many erasures to correct");
+	if (std::ranges::any_of(erasures, [cwLen](int e) { return e < 0 || e >= cwLen; }))
+		throw std::invalid_argument("Erasure position out of range");
+
+	if constexpr (std::is_same_v<Field, GFp<typename Field::value_type>>) {
+		// prevent potentially out-of-range values from causing out-of-bounds access in GFp's exp/log tables
+		for (auto& symbol : codeword)
+			symbol = std::clamp(symbol, 0, field.size() - 1);
+	}
+
+	auto syndromes = compute_syndromes<Field, T>(field, codeword, numECC);
+
+	if (std::ranges::all_of(syndromes, [](auto c) { return c == 0; }))
+		return 0;
+
+	Poly<Field> oriSyndromes(field), erasureLocator(field, numErasures + 1);
+
+	// If there are erasures, we modify the syndromes to "remove" the effect of those...
+	if (!erasures.empty()) {
+		// Keep a copy of the original syndromes for later use in Forney's formula
+		oriSyndromes = syndromes.copy();
+
+		// Erasure locator: Λe(x) = ∏ (1 - Xi x), Xi = α^(cwLen - 1 - pos)
+		erasureLocator.set(1);
+		Poly<Field> term(field, {0, 1});
+		for (int pos : erasures) {
+			term.coef(1) = field.neg(field.exp((cwLen - 1 - pos)));
+			erasureLocator.mul(term);
+		}
+
+		// S'(x) = Λe(x) * S(x)
+		syndromes.mul(erasureLocator, numECC); // keep only the hightest numECC coefficients
+		syndromes.trimLeft(numErasures); // remove the highest numErasures coefficients, equivalent to dividing by x^(numECC - numErasures)
+		// syndromes now only contains the "error syndromes"
+	}
+
+	auto result = sugiyama_algorithm(std::move(syndromes));
+	if (!result)
+		return {};
+
+	auto [locator, evaluator] = std::move(*result); // Λ is error locator, Ω is error evaluator
+
+	int numErrors = locator.deg();
+	if (2 * numErrors + numErasures > numECC)
+		return {};
+
+	if (!erasures.empty()) {
+		// Λ'(x) = Λ(x) * Λe(x), i.e. merge erasure locator into error locator
+		locator.reserve(locator.size() + erasureLocator.size());
+		locator.mul(erasureLocator);
+
+		// Recompute evaluator/Ω so it matches the final combined locator/Λ'.
+		evaluator = std::move(oriSyndromes);
+		evaluator.mul(locator, -numECC); // keep only the lowest numECC coefficients
+	}
+
+	auto locations = find_locations(locator);
+	if (std::ssize(locations) != numErrors + numErasures)
+		return {}; // Error locator degree does not match number of roots, most likely there are more errors than can be recovered
+
+	auto magnitudes = find_magnitudes(evaluator, locator, locations);
+
+	for (int i = 0; i < numErrors + numErasures; ++i) {
+		int pos = cwLen - 1 - field.log(locations[i]);
+		if (pos < 0)
+			return {};
+		codeword[pos] = field.sub(codeword[pos], magnitudes[i]);
+	}
+
+#if 1
+	// re-evaluate the syndromes of the recovered codeword to make sure it is a valid codeword now (see #940-3)
+	syndromes = compute_syndromes<Field, T>(field, codeword, numECC);
+	if (std::ranges::any_of(syndromes, [](auto c) { return c != 0; }))
+		return {};
+#endif
+
+	// if (numErasures)
+	// 	printf("erasures: %d, errors: %d, ecc: %d\n", numErasures, numErrors, numECC);
+
+	// Correcting 1 error consumes 2 parity symbols, correcting 1 erasure consumes 1 parity symbol.
+	return 2 * numErrors + numErasures;
+}
+
+template <typename Field, std::ranges::contiguous_range R>
+	requires std::integral<std::ranges::range_value_t<R>>
+[[nodiscard]] std::optional<int> decode(const Field& field, R&& codeword, int numECC, std::span<const int> erasures = {})
+{
+	using T = std::ranges::range_value_t<R>;
+	return decode<Field, T>(field, std::span(codeword), numECC, erasures);
+}
+
+} // namespace librscpp

package/cpp/zxing-core/core/src/librscpp/encode.h

@@ -0,0 +1,124 @@
+// Copyright 2016 ZXing authors
+// Copyright 2017-2026 Axel Waggershauser
+// SPDX-License-Identifier: Apache-2.0
+
+#include "field.h"
+#include "poly.h"
+
+#include <algorithm>
+#include <stdexcept>
+#include <type_traits>
+#include <utility>
+
+namespace librscpp {
+
+namespace {
+
+template <typename Field>
+Poly<Field> build_generator(const Field& field, int degree)
+{
+	Poly<Field> generator(field, degree + 1);
+	generator.set(1);
+	Poly<Field> term(field, {1, 0});
+	for (int d = 1; d <= degree; d++) {
+		term.coef(0) = field.neg(field.exp(d - 1 + field.fcr()));
+		generator.mul(term);
+	}
+	return generator;
+}
+
+}
+
+/**
+ * @brief Reed-Solomon systematic encoder.
+ *
+ * Computes parity symbols for @p data in the given Galois field and writes them to @p parity.
+ *
+ * @param field Galois field instance used for generator construction and arithmetic.
+ * @param data Data symbols.
+ * @param parity Output buffer for parity symbols. It's size determines the number of parity symbols.
+ */
+template <typename Field, std::integral T>
+void encode(const Field& field, std::span<const T> data, std::span<T> parity)
+{
+	if (data.empty() || parity.empty())
+		throw std::invalid_argument("Invalid number of data or parity symbols");
+
+	using FT = typename Field::value_type;
+	std::vector<FT> tmp;
+	std::span<FT const> data_;
+	if constexpr (!std::is_same_v<T, FT>) {
+		// If the message type is different from the field's value type, we need to copy it into a temporary buffer of the right type.
+		tmp.resize(data.size());
+		std::ranges::transform(data, tmp.begin(), [](T sym) { return static_cast<FT>(static_cast<std::make_unsigned_t<T>>(sym)); });
+		data_ = tmp;
+	} else {
+		data_ = std::span(data);
+	}
+
+	// See https://en.wikipedia.org/wiki/Reed–Solomon_error_correction#Systematic_encoding_procedure
+
+	auto generator = build_generator(field, parity.size());
+
+	Poly<Field> C(field, data_, data_.size() + parity.size());
+	Poly<Field> _(field, data_.size() + 1);
+	C.resize(data_.size() + parity.size()); // left-shift == multiply by x^(parity.size())
+	C.div(generator, _);
+	C.neg();
+	auto out = std::fill_n(parity.begin(), parity.size() - C.size(), 0);
+	std::ranges::transform(C, out, [](FT symbol) { return static_cast<T>(symbol); });
+}
+
+template <typename Field, std::ranges::contiguous_range R, std::ranges::contiguous_range S>
+	requires std::same_as<std::ranges::range_value_t<R>, std::ranges::range_value_t<S>>
+void encode(const Field& field, R&& data, S&& parity)
+{
+	using T = std::ranges::range_value_t<R>;
+	encode<Field, T>(field, std::span<const T>(data), std::span<T>(parity));
+}
+
+/**
+ * @brief Reed-Solomon in-place systematic encoder.
+ *
+ * Computes parity symbols for the data prefix in @p codeword and stores them
+ * in the last @p num_parity elements of the same buffer.
+ *
+ * @param field Galois field instance used for generator construction and arithmetic.
+ * @param codeword Buffer containing data symbols followed by parity storage.
+ * @param num_parity Number of parity symbols to compute and write at the end of @p codeword.
+ */
+template <typename Field, std::ranges::contiguous_range R>
+void encode_inplace(const Field& field, R&& codeword, int num_parity)
+{
+	std::span cw(codeword);
+	auto data_size = std::ranges::ssize(codeword) - num_parity;
+	if (data_size <= 0 || num_parity <= 0)
+		throw std::invalid_argument("Invalid number of data or parity symbols");
+	encode(field, cw.subspan(0, data_size), cw.subspan(data_size));
+}
+
+/**
+ * @brief Reed-Solomon systematic encoder returning a full codeword.
+ *
+ * Appends @p num_parity parity symbols to @p data and returns the combined
+ * codeword in a container of type @p Result.
+ *
+ * @param field Galois field instance used for generator construction and arithmetic.
+ * @param data Input data symbols.
+ * @param num_parity Number of parity symbols to append.
+ * @return Result Codeword consisting of input data followed by parity symbols.
+ */
+template <typename Out = void, typename Field, std::ranges::contiguous_range In>
+[[nodiscard]]
+auto encode(const Field& field, In&& data, int num_parity)
+{
+	using T = std::conditional_t<std::is_void_v<Out>, std::remove_cvref_t<In>, Out>;
+	T res;
+	res.reserve(std::ranges::size(data) + num_parity);
+	res.insert(res.end(), std::ranges::begin(data), std::ranges::end(data));
+	res.resize(res.size() + num_parity);
+	encode_inplace(field, res, num_parity);
+	return res;
+}
+
+} // namespace librscpp

package/cpp/zxing-core/core/src/librscpp/field.h

@@ -0,0 +1,158 @@
+// Copyright 2016 ZXing authors
+// Copyright 2017-2026 Axel Waggershauser
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <cassert>
+#include <concepts>
+#include <cstdint>
+#include <bit>
+#include <functional>
+#include <stdexcept>
+#include <vector>
+
+// #define LIBRSCPP_SAVE_MEMORY
+
+namespace librscpp {
+
+template <std::unsigned_integral T, std::integral HP>
+class GFBase
+{
+	static_assert(sizeof(T) <= sizeof(HP) && sizeof(HP) >= 2,
+				  "HP must be able to hold values of type T and the result of their addition");
+
+protected:
+	const int _size;
+	const int _fcr;
+	std::vector<T> _expTable, _logTable;
+
+	// avoid using the '%' modulo operator => decode computation can be more than twice as fast (depending on architecture)
+	// see also https://stackoverflow.com/a/33333636/2088798
+	inline static T fast_mod(HP input, HP mod) { return input < mod ? input : input - mod; }
+
+	GFBase(int size, int fcr, std::function<T(T)> next) : _size(size), _fcr(fcr)
+	{
+		if (size <= 0 || size > (1 << (sizeof(T) * 8)))
+			throw std::invalid_argument("Invalid field size " + std::to_string(size));
+		if (fcr < 0 || fcr >= size)
+			throw std::invalid_argument("Invalid first consecutive root " + std::to_string(fcr) + " for field of size "
+										+ std::to_string(size));
+
+#ifdef LIBRSCPP_SAVE_MEMORY
+		_expTable.resize(size, 0);
+#else
+		_expTable.resize(size * 2, 0);
+#endif
+		_logTable.resize(size, 0);
+		int x = 1;
+		for (int i = 0; i < size; ++i) {
+			_expTable[i] = x;
+			x = next(x);
+		}
+
+#ifndef LIBRSCPP_SAVE_MEMORY
+		for (int i = size - 1; i < size * 2; ++i)
+			_expTable[i] = _expTable[i - (size - 1)];
+#endif
+
+		for (int i = 0; i < size - 1; ++i)
+			_logTable[_expTable[i]] = i;
+		// logTable[0] == 0 but this should never be used
+	}
+
+public:
+	using value_type = T;
+
+	// 2 to the power of a
+	T exp(T a) const { return _expTable.at((a)); }
+
+	// base 2 log of a
+	T log(T a) const
+	{
+		assert(a != 0);
+		return _logTable.at((a));
+	}
+
+	// multiplicative inverse of a (== 1/a)
+	T inv(T a) const { return _expTable[_size - 1 - log(a)]; }
+
+	// product of a and b
+	T mul(T a, T b) const noexcept
+	{
+		if (a == 0 || b == 0)
+			return 0;
+
+		// this is in the hot path, operator[] is around 20% faster than at() for the unit tests
+#ifdef LIBRSCPP_SAVE_MEMORY
+		return _expTable[fast_mod(HP(_logTable[a]) + HP(_logTable[b]), _size - 1)];
+#else
+		return _expTable[HP(_logTable[a]) + HP(_logTable[b])];
+#endif
+	}
+
+	int size() const noexcept { return _size; }
+
+	// first consecutive root of the RS generator polynomial, sometimes also called "b" or "base"
+	int fcr() const noexcept { return _fcr; }
+};
+
+/**
+ * @brief Represents an extension Galois Field GF(2^n).
+ */
+template <std::unsigned_integral T = uint16_t, std::integral HP = uint32_t>
+class GF2n : public GFBase<T, HP>
+{
+public:
+	/**
+	 * @brief Create a Galois Field GF(2^n) using the given primitive polynomial.
+	 *
+	 * @param poly irreducible polynomial whose coefficients are represented by
+	 *  the bits of an int, where the least-significant bit represents the constant
+	 *  coefficient and the most-significant bit represents the x^n coefficient and defines the size of the field.
+	 *  For example, 0b1'0001'1101 represents the primitive polynomial x^8 + x^4 + x^3 + x^2 + 1.
+	 * @param fcr the first consecutive root of the RS generator polynomial, sometimes also called "b" or "base"
+	 *  (g(x) = (x+a^b)(x+a^(b+1))...(x+a^(b+2t-1))). This is typically 1, but for e.g. QR Code it is 0.
+	 *  It is technially not a property of the field but instead a property of the RS code defined over the field.
+	 */
+	GF2n(uint32_t poly, int fcr)
+		: GFBase<T, HP>(1 << (std::bit_width(poly) - 1), fcr, [poly, size = HP(1 << (std::bit_width(poly) - 1))](T x) {
+			  HP ix = x;
+			  ix *= 2; // multiply by the primitive element / generator α (== x^1)
+			  if (ix >= size) // if deg(ix) == deg(poly), reduce modulo poly by subtracting it (== XOR)
+				  ix ^= poly;
+			  return ix;
+		  })
+	{}
+
+	T add(T a, T b) const { return a ^ b; }
+	T sub(T a, T b) const { return a ^ b; } // a - b == a + b in GF(2^n)
+	T neg(T a) const { return a; }          // -a == a in GF(2^n)
+};
+
+/**
+ * @brief Represents a prime Galois Field GF(p).
+ */
+template <std::unsigned_integral T = uint16_t, std::integral HP = uint32_t>
+class GFp : public GFBase<T, HP>
+{
+	using Base = GFBase<T, HP>;
+
+public:
+	/**
+	 * @brief Create a Galois Field GF(p) using the given prime.
+	 *
+	 * @param prime a prime number representing the size of the field
+	 * @param generator a primitive root modulo prime, used as the generator α of GF(p)
+	 * @param fcr the first consecutive root of the RS generator polynomial, sometimes also called "b" or "base"
+	 */
+	GFp(uint32_t prime, uint32_t generator, int fcr)
+		: GFBase<T, HP>(prime, fcr, [prime, generator](T x) { return (x * generator) % prime; })
+	{}
+
+	T add(T a, T b) const { return Base::fast_mod(HP(a) + HP(b), Base::size()); }
+	T sub(T a, T b) const { return Base::fast_mod(Base::size() + HP(a) - HP(b), Base::size()); }
+	T neg(T a) const { return sub(0, a); }
+};
+
+} // namespace librscpp