Stowage/ladybird
2
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-11-04 15:20:58 +00:00
Code Issues Projects Releases Packages Wiki Activity
ladybird/Libraries/LibCrypto/BigInt/SignedBigInteger.h

118 lines
4.6 KiB
C
Raw Normal View History

LibCrypto: Add a simple SignedBigInteger This patchset adds a simple SignedBigInteger that is entirely defined in terms of UnsignedBigInteger. It also adds a NumberTheory::Power function, which is terribly inefficient, but since the use of exponentiation is very much discouraged for large inputs, no particular attempts were made to make it more performant.
2020-06-04 22:46:18 +04:30
/*
* Copyright (c) 2020, the SerenityOS developers.
LibCrypto: Add a rounding mode to UnsignedBigInteger::to_double This allows using different options for rounding, like IEEE roundTiesToEven, which is the mode that JS requires. Also fix that the last word read from the bigint for the mantissa could be shifted incorrectly leading to incorrect results.
2022-08-25 17:56:34 +02:00
* Copyright (c) 2022, David Tuin <davidot@serenityos.org>
LibCrypto: Replace {Unsigned,Signed}BigInteger impl with LibTomMath Replace the implementation of maths in `UnsignedBigInteger` and `SignedBigInteger` with LibTomMath. This gives benefits in terms of less code to maintain, correctness and speed. These changes also remove now-unsued methods and improve the error propagation for functions allocating lots of memory. Additionally, the new implementation is always trimmed and won't have dangling zeros when exporting it.
2025-04-25 20:54:45 +02:00
* Copyright (c) 2025, Altomani Gianluca <altomanigianluca@gmail.com>
LibCrypto: Add a simple SignedBigInteger This patchset adds a simple SignedBigInteger that is entirely defined in terms of UnsignedBigInteger. It also adds a NumberTheory::Power function, which is terribly inefficient, but since the use of exponentiation is very much discouraged for large inputs, no particular attempts were made to make it more performant.
2020-06-04 22:46:18 +04:30
*
Everything: Move to SPDX license identifiers in all files. SPDX License Identifiers are a more compact / standardized way of representing file license information. See: https://spdx.dev/resources/use/#identifiers This was done with the `ambr` search and replace tool. ambr --no-parent-ignore --key-from-file --rep-from-file key.txt rep.txt *
2021-04-22 01:24:48 -07:00
* SPDX-License-Identifier: BSD-2-Clause
LibCrypto: Add a simple SignedBigInteger This patchset adds a simple SignedBigInteger that is entirely defined in terms of UnsignedBigInteger. It also adds a NumberTheory::Power function, which is terribly inefficient, but since the use of exponentiation is very much discouraged for large inputs, no particular attempts were made to make it more performant.
2020-06-04 22:46:18 +04:30
*/
#pragma once
#include <LibCrypto/BigInt/UnsignedBigInteger.h>
namespace Crypto {
struct SignedDivisionResult;
class SignedBigInteger {
public:
Everywhere: Use C++ concepts instead of requires clauses
2022-11-14 18:20:59 +00:00
template<Signed T>
Everywhere: Run clang-format
2022-10-17 00:06:11 +02:00
SignedBigInteger(T value)
LibCrypto: Replace {Unsigned,Signed}BigInteger impl with LibTomMath Replace the implementation of maths in `UnsignedBigInteger` and `SignedBigInteger` with LibTomMath. This gives benefits in terms of less code to maintain, correctness and speed. These changes also remove now-unsued methods and improve the error propagation for functions allocating lots of memory. Additionally, the new implementation is always trimmed and won't have dangling zeros when exporting it.
2025-04-25 20:54:45 +02:00
: SignedBigInteger(static_cast<i64>(value))
LibCrypto: Add a simple SignedBigInteger This patchset adds a simple SignedBigInteger that is entirely defined in terms of UnsignedBigInteger. It also adds a NumberTheory::Power function, which is terribly inefficient, but since the use of exponentiation is very much discouraged for large inputs, no particular attempts were made to make it more performant.
2020-06-04 22:46:18 +04:30
{
}
LibCrypto: Replace {Unsigned,Signed}BigInteger impl with LibTomMath Replace the implementation of maths in `UnsignedBigInteger` and `SignedBigInteger` with LibTomMath. This gives benefits in terms of less code to maintain, correctness and speed. These changes also remove now-unsued methods and improve the error propagation for functions allocating lots of memory. Additionally, the new implementation is always trimmed and won't have dangling zeros when exporting it.
2025-04-25 20:54:45 +02:00
SignedBigInteger(UnsignedBigInteger&& unsigned_data, bool sign);
SignedBigInteger(u8 const* ptr, size_t length);
LibCrypto: Add a simple SignedBigInteger This patchset adds a simple SignedBigInteger that is entirely defined in terms of UnsignedBigInteger. It also adds a NumberTheory::Power function, which is terribly inefficient, but since the use of exponentiation is very much discouraged for large inputs, no particular attempts were made to make it more performant.
2020-06-04 22:46:18 +04:30
LibCrypto: Replace {Unsigned,Signed}BigInteger impl with LibTomMath Replace the implementation of maths in `UnsignedBigInteger` and `SignedBigInteger` with LibTomMath. This gives benefits in terms of less code to maintain, correctness and speed. These changes also remove now-unsued methods and improve the error propagation for functions allocating lots of memory. Additionally, the new implementation is always trimmed and won't have dangling zeros when exporting it.
2025-04-25 20:54:45 +02:00
explicit SignedBigInteger(UnsignedBigInteger const& unsigned_data);
LibCrypto: Add a constructor to (Un)SignedBigInteger taking a double For now this will assume that the double given is exactly representable as an integer, so no NaN, infinity or rounding.
2022-08-25 23:37:09 +02:00
explicit SignedBigInteger(double value);
LibCrypto: Replace {Unsigned,Signed}BigInteger impl with LibTomMath Replace the implementation of maths in `UnsignedBigInteger` and `SignedBigInteger` with LibTomMath. This gives benefits in terms of less code to maintain, correctness and speed. These changes also remove now-unsued methods and improve the error propagation for functions allocating lots of memory. Additionally, the new implementation is always trimmed and won't have dangling zeros when exporting it.
2025-04-25 20:54:45 +02:00
explicit SignedBigInteger(i64 value);
LibCrypto: Add a constructor to (Un)SignedBigInteger taking a double For now this will assume that the double given is exactly representable as an integer, so no NaN, infinity or rounding.
2022-08-25 23:37:09 +02:00
LibCrypto: Replace {Unsigned,Signed}BigInteger impl with LibTomMath Replace the implementation of maths in `UnsignedBigInteger` and `SignedBigInteger` with LibTomMath. This gives benefits in terms of less code to maintain, correctness and speed. These changes also remove now-unsued methods and improve the error propagation for functions allocating lots of memory. Additionally, the new implementation is always trimmed and won't have dangling zeros when exporting it.
2025-04-25 20:54:45 +02:00
SignedBigInteger(SignedBigInteger const&);
SignedBigInteger& operator=(SignedBigInteger const&);
LibCrypto+LibJS: Remove the create_from methods from BigInteger Instead we just use a specific constructor. With this set of constructors using curly braces for constructing is highly recommended. As then it will not do too many implicit conversions which could lead to unexpected loss of data or calling the much slower double constructor. Also to ensure we don't feed (Un)SignedBigInteger infinities we throw RangeError earlier for Durations.
2022-08-26 00:49:50 +02:00
LibCrypto: Replace {Unsigned,Signed}BigInteger impl with LibTomMath Replace the implementation of maths in `UnsignedBigInteger` and `SignedBigInteger` with LibTomMath. This gives benefits in terms of less code to maintain, correctness and speed. These changes also remove now-unsued methods and improve the error propagation for functions allocating lots of memory. Additionally, the new implementation is always trimmed and won't have dangling zeros when exporting it.
2025-04-25 20:54:45 +02:00
SignedBigInteger();
~SignedBigInteger();
LibCrypto: Add a simple SignedBigInteger This patchset adds a simple SignedBigInteger that is entirely defined in terms of UnsignedBigInteger. It also adds a NumberTheory::Power function, which is terribly inefficient, but since the use of exponentiation is very much discouraged for large inputs, no particular attempts were made to make it more performant.
2020-06-04 22:46:18 +04:30
LibCrypto: Replace {Unsigned,Signed}BigInteger impl with LibTomMath Replace the implementation of maths in `UnsignedBigInteger` and `SignedBigInteger` with LibTomMath. This gives benefits in terms of less code to maintain, correctness and speed. These changes also remove now-unsued methods and improve the error propagation for functions allocating lots of memory. Additionally, the new implementation is always trimmed and won't have dangling zeros when exporting it.
2025-04-25 20:54:45 +02:00
[[nodiscard]] static SignedBigInteger import_data(StringView data) { return import_data(reinterpret_cast<u8 const*>(data.characters_without_null_termination()), data.length()); }
[[nodiscard]] static SignedBigInteger import_data(u8 const* ptr, size_t length) { return SignedBigInteger(ptr, length); }
size_t export_data(Bytes) const;
LibCrypto: Add a simple SignedBigInteger This patchset adds a simple SignedBigInteger that is entirely defined in terms of UnsignedBigInteger. It also adds a NumberTheory::Power function, which is terribly inefficient, but since the use of exponentiation is very much discouraged for large inputs, no particular attempts were made to make it more performant.
2020-06-04 22:46:18 +04:30
LibCrypto: Make constructing a BigInteger from string fallible Previously, constructing a `UnsignedBigInteger::from_base()` could produce an incorrect result if the input string contained a valid Base36 digit that was out of range of the given base. The same method would also crash if the input string contained an invalid Base36 digit. An error is now returned in both these cases. Constructing a BigFraction from string is now also fallible, so that we can handle the case where we are given an input string with invalid digits.
2024-01-12 21:34:23 +00:00
[[nodiscard]] static ErrorOr<SignedBigInteger> from_base(u16 N, StringView str);
LibCrypto: Define *BigInteger::to_base to convert big integers to String
2023-01-13 11:40:04 -05:00
[[nodiscard]] ErrorOr<String> to_base(u16 N) const;
LibCrypto: Add a simple SignedBigInteger This patchset adds a simple SignedBigInteger that is entirely defined in terms of UnsignedBigInteger. It also adds a NumberTheory::Power function, which is terribly inefficient, but since the use of exponentiation is very much discouraged for large inputs, no particular attempts were made to make it more performant.
2020-06-04 22:46:18 +04:30
LibCrypto: Add the [[nodiscard]] qualifier in both BigInteger classes
2022-01-04 17:00:53 +01:00
[[nodiscard]] u64 to_u64() const;
LibCrypto: Add a rounding mode to UnsignedBigInteger::to_double This allows using different options for rounding, like IEEE roundTiesToEven, which is the mode that JS requires. Also fix that the last word read from the bigint for the mantissa could be shifted incorrectly leading to incorrect results.
2022-08-25 17:56:34 +02:00
[[nodiscard]] double to_double(UnsignedBigInteger::RoundingMode rounding_mode = UnsignedBigInteger::RoundingMode::IEEERoundAndTiesToEvenMantissa) const;
LibJS: Add all of the DataView.prototype.set* methods
2021-06-14 02:02:53 +03:00
LibCrypto: Replace {Unsigned,Signed}BigInteger impl with LibTomMath Replace the implementation of maths in `UnsignedBigInteger` and `SignedBigInteger` with LibTomMath. This gives benefits in terms of less code to maintain, correctness and speed. These changes also remove now-unsued methods and improve the error propagation for functions allocating lots of memory. Additionally, the new implementation is always trimmed and won't have dangling zeros when exporting it.
2025-04-25 20:54:45 +02:00
[[nodiscard]] UnsignedBigInteger unsigned_value() const;
LibCrypto: Add SignedBigInteger::is_positive()
2022-10-22 00:15:42 +01:00
[[nodiscard]] bool is_positive() const { return !is_negative() && !is_zero(); }
LibCrypto: Replace {Unsigned,Signed}BigInteger impl with LibTomMath Replace the implementation of maths in `UnsignedBigInteger` and `SignedBigInteger` with LibTomMath. This gives benefits in terms of less code to maintain, correctness and speed. These changes also remove now-unsued methods and improve the error propagation for functions allocating lots of memory. Additionally, the new implementation is always trimmed and won't have dangling zeros when exporting it.
2025-04-25 20:54:45 +02:00
[[nodiscard]] bool is_negative() const;
[[nodiscard]] bool is_zero() const;
LibCrypto: Add a simple SignedBigInteger This patchset adds a simple SignedBigInteger that is entirely defined in terms of UnsignedBigInteger. It also adds a NumberTheory::Power function, which is terribly inefficient, but since the use of exponentiation is very much discouraged for large inputs, no particular attempts were made to make it more performant.
2020-06-04 22:46:18 +04:30
LibCrypto: Replace {Unsigned,Signed}BigInteger impl with LibTomMath Replace the implementation of maths in `UnsignedBigInteger` and `SignedBigInteger` with LibTomMath. This gives benefits in terms of less code to maintain, correctness and speed. These changes also remove now-unsued methods and improve the error propagation for functions allocating lots of memory. Additionally, the new implementation is always trimmed and won't have dangling zeros when exporting it.
2025-04-25 20:54:45 +02:00
void negate();
void set_to_0();
void set_to(i64 other);
void set_to(SignedBigInteger const& other);
LibCrypto: Do not allow signed big integers to be negative zero If a big integer were to become negative zero, set the sign to instead be positive. This prevents odd scenarios where users of signed big ints would falsely think the result of some big int arithmetic is negative.
2022-02-06 13:17:34 +00:00
LibCrypto: Replace {Unsigned,Signed}BigInteger impl with LibTomMath Replace the implementation of maths in `UnsignedBigInteger` and `SignedBigInteger` with LibTomMath. This gives benefits in terms of less code to maintain, correctness and speed. These changes also remove now-unsued methods and improve the error propagation for functions allocating lots of memory. Additionally, the new implementation is always trimmed and won't have dangling zeros when exporting it.
2025-04-25 20:54:45 +02:00
[[nodiscard]] size_t byte_length() const;
LibCrypto: Add the [[nodiscard]] qualifier in both BigInteger classes
2022-01-04 17:00:53 +01:00
[[nodiscard]] SignedBigInteger plus(SignedBigInteger const& other) const;
[[nodiscard]] SignedBigInteger minus(SignedBigInteger const& other) const;
[[nodiscard]] SignedBigInteger bitwise_or(SignedBigInteger const& other) const;
[[nodiscard]] SignedBigInteger bitwise_and(SignedBigInteger const& other) const;
[[nodiscard]] SignedBigInteger bitwise_xor(SignedBigInteger const& other) const;
[[nodiscard]] SignedBigInteger bitwise_not() const;
LibCrypto: Replace {Unsigned,Signed}BigInteger impl with LibTomMath Replace the implementation of maths in `UnsignedBigInteger` and `SignedBigInteger` with LibTomMath. This gives benefits in terms of less code to maintain, correctness and speed. These changes also remove now-unsued methods and improve the error propagation for functions allocating lots of memory. Additionally, the new implementation is always trimmed and won't have dangling zeros when exporting it.
2025-04-25 20:54:45 +02:00
[[nodiscard]] ErrorOr<SignedBigInteger> shift_left(size_t num_bits) const;
LibCrypto: Implement arbitrarily sized right shifts Previously we could only shift by words at a time
2024-03-18 00:40:03 +01:00
[[nodiscard]] SignedBigInteger shift_right(size_t num_bits) const;
LibCrypto: Add the [[nodiscard]] qualifier in both BigInteger classes
2022-01-04 17:00:53 +01:00
[[nodiscard]] SignedBigInteger multiplied_by(SignedBigInteger const& other) const;
[[nodiscard]] SignedDivisionResult divided_by(SignedBigInteger const& divisor) const;
LibCrypto+LibJS: Move `Power` to method of `{Unsigned,Signed}BigInteger` Having it as a method instead of a free function is necessary for the next commits and generally allows for optimizations that require deeper access into the `UnsignedBigInteger` / `SignedBigInteger`. Also restrict the exponent to 32 bits to avoid huge memory allocations.
2025-04-26 11:17:32 +02:00
[[nodiscard]] SignedBigInteger pow(u32 exponent) const;
LibJS+LibCrypto: Use a bitwise approach for BigInt's as*IntN methods This speeds up expressions such as `BigInt.asIntN(0x4000000000000, 1n)` (#3615). And those involving very large bigints.
2025-03-19 10:31:39 +13:00
[[nodiscard]] ErrorOr<SignedBigInteger> mod_power_of_two(size_t power_of_two) const;
LibCrypto: Introduce a falible API for `SignedBigInteger::shift_left`
2025-02-19 02:20:30 +13:00
LibCrypto: Add the [[nodiscard]] qualifier in both BigInteger classes
2022-01-04 17:00:53 +01:00
[[nodiscard]] SignedBigInteger plus(UnsignedBigInteger const& other) const;
[[nodiscard]] SignedBigInteger minus(UnsignedBigInteger const& other) const;
[[nodiscard]] SignedBigInteger multiplied_by(UnsignedBigInteger const& other) const;
[[nodiscard]] SignedDivisionResult divided_by(UnsignedBigInteger const& divisor) const;
LibCrypto: Add SignedBigInteger::negated_value() Return the negated value of the current number.
2022-01-04 16:33:33 +01:00
[[nodiscard]] SignedBigInteger negated_value() const;
LibCrypto: Add the [[nodiscard]] qualifier in both BigInteger classes
2022-01-04 17:00:53 +01:00
[[nodiscard]] u32 hash() const;
LibCrypto: Add hash methods to {Signed, Unsigned}BigInteger These just use hash the underlying bytes that make up the integer words
2021-06-08 23:43:44 +03:00
LibCrypto: Add the [[nodiscard]] qualifier in both BigInteger classes
2022-01-04 17:00:53 +01:00
[[nodiscard]] bool operator==(SignedBigInteger const& other) const;
[[nodiscard]] bool operator!=(SignedBigInteger const& other) const;
[[nodiscard]] bool operator<(SignedBigInteger const& other) const;
[[nodiscard]] bool operator<=(SignedBigInteger const& other) const;
[[nodiscard]] bool operator>(SignedBigInteger const& other) const;
[[nodiscard]] bool operator>=(SignedBigInteger const& other) const;
[[nodiscard]] bool operator==(UnsignedBigInteger const& other) const;
[[nodiscard]] bool operator!=(UnsignedBigInteger const& other) const;
[[nodiscard]] bool operator<(UnsignedBigInteger const& other) const;
[[nodiscard]] bool operator>(UnsignedBigInteger const& other) const;
LibCrypto: Add a simple SignedBigInteger This patchset adds a simple SignedBigInteger that is entirely defined in terms of UnsignedBigInteger. It also adds a NumberTheory::Power function, which is terribly inefficient, but since the use of exponentiation is very much discouraged for large inputs, no particular attempts were made to make it more performant.
2020-06-04 22:46:18 +04:30
LibCrypto: Add a way to compare UnsignedBigInteger with double This patch also make SignedBigInteger::compare_to_double make use of the new function.
2022-10-23 16:46:35 +01:00
[[nodiscard]] UnsignedBigInteger::CompareResult compare_to_double(double) const;
LibCrypto: Add a way to compare a SignedBigInteger with a double This supports any double value (except for NaNs) instead of having to cast the double to some smaller type which doesn't work for very large values.
2022-08-19 23:45:36 +02:00
LibCrypto: Add a simple SignedBigInteger This patchset adds a simple SignedBigInteger that is entirely defined in terms of UnsignedBigInteger. It also adds a NumberTheory::Power function, which is terribly inefficient, but since the use of exponentiation is very much discouraged for large inputs, no particular attempts were made to make it more performant.
2020-06-04 22:46:18 +04:30
private:
LibCrypto: Replace {Unsigned,Signed}BigInteger impl with LibTomMath Replace the implementation of maths in `UnsignedBigInteger` and `SignedBigInteger` with LibTomMath. This gives benefits in terms of less code to maintain, correctness and speed. These changes also remove now-unsued methods and improve the error propagation for functions allocating lots of memory. Additionally, the new implementation is always trimmed and won't have dangling zeros when exporting it.
2025-04-25 20:54:45 +02:00
mp_int m_mp {};
mutable Optional<u32> m_hash {};
LibCrypto: Add a simple SignedBigInteger This patchset adds a simple SignedBigInteger that is entirely defined in terms of UnsignedBigInteger. It also adds a NumberTheory::Power function, which is terribly inefficient, but since the use of exponentiation is very much discouraged for large inputs, no particular attempts were made to make it more performant.
2020-06-04 22:46:18 +04:30
};
struct SignedDivisionResult {
Crypto::SignedBigInteger quotient;
Crypto::SignedBigInteger remainder;
};
}
LibCrypto: Add Formatter<SignedBigInteger> Useful for seeing SignedBigInteger values in test failure messages.
2022-01-17 12:17:40 -05:00
template<>
struct AK::Formatter<Crypto::SignedBigInteger> : AK::Formatter<Crypto::UnsignedBigInteger> {
ErrorOr<void> format(FormatBuilder&, Crypto::SignedBigInteger const&);
};
LibCrypto: Add a simple SignedBigInteger This patchset adds a simple SignedBigInteger that is entirely defined in terms of UnsignedBigInteger. It also adds a NumberTheory::Power function, which is terribly inefficient, but since the use of exponentiation is very much discouraged for large inputs, no particular attempts were made to make it more performant.
2020-06-04 22:46:18 +04:30
inline Crypto::SignedBigInteger
Everywhere: Run clang-format
2022-04-01 20:58:27 +03:00
operator""_sbigint(char const* string, size_t length)
LibCrypto: Add a simple SignedBigInteger This patchset adds a simple SignedBigInteger that is entirely defined in terms of UnsignedBigInteger. It also adds a NumberTheory::Power function, which is terribly inefficient, but since the use of exponentiation is very much discouraged for large inputs, no particular attempts were made to make it more performant.
2020-06-04 22:46:18 +04:30
{
LibCrypto: Make constructing a BigInteger from string fallible Previously, constructing a `UnsignedBigInteger::from_base()` could produce an incorrect result if the input string contained a valid Base36 digit that was out of range of the given base. The same method would also crash if the input string contained an invalid Base36 digit. An error is now returned in both these cases. Constructing a BigFraction from string is now also fallible, so that we can handle the case where we are given an input string with invalid digits.
2024-01-12 21:34:23 +00:00
return MUST(Crypto::SignedBigInteger::from_base(10, { string, length }));
LibCrypto: Add a simple SignedBigInteger This patchset adds a simple SignedBigInteger that is entirely defined in terms of UnsignedBigInteger. It also adds a NumberTheory::Power function, which is terribly inefficient, but since the use of exponentiation is very much discouraged for large inputs, no particular attempts were made to make it more performant.
2020-06-04 22:46:18 +04:30
}
Reference in a new issue Copy permalink