mirrors/Odin
1
0
Fork 0
mirror of https://github.com/odin-lang/Odin.git synced 2026-04-19 21:10:30 +00:00
Code Issues Packages Projects Releases Wiki Activity

Replace err != nil with or_return where appropriate

Browse Source
This commit is contained in:
gingerBill
2021-08-15 17:52:10 +01:00
parent b8661e0ae0
commit c27b8a71fd
8 changed files with 450 additions and 427 deletions
Download Patch File Download Diff File Expand all files Collapse all files

96
core/math/big/helpers.odin
View File

@@ -42,7 +42,7 @@ int_set_from_integer :: proc(dest: ^Int, src: $T, minimize := false, allocator :
Check that `src` is usable and `dest` isn't immutable.
*/
assert_if_nil(dest);
if err = #force_inline internal_error_if_immutable(dest); err != nil { return err; }
(#force_inline internal_error_if_immutable(dest)) or_return;
return #force_inline internal_int_set_from_integer(dest, src, minimize);
}
@@ -64,8 +64,8 @@ int_copy :: proc(dest, src: ^Int, minimize := false, allocator := context.alloca
assert_if_nil(dest, src);
context.allocator = allocator;
if err = #force_inline internal_clear_if_uninitialized(src); err != nil { return err; }
if err = #force_inline internal_error_if_immutable(dest); err != nil { return err; }
(#force_inline internal_clear_if_uninitialized(src)) or_return;
(#force_inline internal_error_if_immutable(dest)) or_return;
return #force_inline internal_int_copy(dest, src, minimize);
}
@@ -92,8 +92,8 @@ int_abs :: proc(dest, src: ^Int, allocator := context.allocator) -> (err: Error)
assert_if_nil(dest, src);
context.allocator = allocator;
if err = #force_inline internal_clear_if_uninitialized(src); err != nil { return err; }
if err = #force_inline internal_error_if_immutable(dest); err != nil { return err; }
(#force_inline internal_clear_if_uninitialized(src)) or_return;
(#force_inline internal_error_if_immutable(dest)) or_return;
return #force_inline internal_int_abs(dest, src);
}
@@ -113,8 +113,8 @@ int_neg :: proc(dest, src: ^Int, allocator := context.allocator) -> (err: Error)
assert_if_nil(dest, src);
context.allocator = allocator;
if err = #force_inline internal_clear_if_uninitialized(src); err != nil { return err; }
if err = #force_inline internal_error_if_immutable(dest); err != nil { return err; }
(#force_inline internal_clear_if_uninitialized(src)) or_return;
(#force_inline internal_error_if_immutable(dest)) or_return;
return #force_inline internal_int_neg(dest, src);
}
@@ -134,8 +134,8 @@ int_bitfield_extract :: proc(a: ^Int, offset, count: int, allocator := context.a
assert_if_nil(a);
context.allocator = allocator;
if err = #force_inline internal_clear_if_uninitialized(a); err != nil { return {}, err; }
return #force_inline internal_int_bitfield_extract(a, offset, count);
(#force_inline internal_clear_if_uninitialized(a)) or_return;
return #force_inline internal_int_bitfield_extract(a, offset, count);
}
/*
@@ -148,8 +148,8 @@ shrink :: proc(a: ^Int, allocator := context.allocator) -> (err: Error) {
assert_if_nil(a);
context.allocator = allocator;
if err = #force_inline internal_clear_if_uninitialized(a); err != nil { return err; }
return #force_inline internal_shrink(a);
(#force_inline internal_clear_if_uninitialized(a)) or_return;
return #force_inline internal_shrink(a);
}
int_grow :: proc(a: ^Int, digits: int, allow_shrink := false, allocator := context.allocator) -> (err: Error) {
@@ -305,8 +305,8 @@ int_get :: proc(a: ^Int, $T: typeid, allocator := context.allocator) -> (res: T,
Check that `a` is usable.
*/
assert_if_nil(a);
if err = #force_inline internal_clear_if_uninitialized(a, allocator); err != nil { return T{}, err; }
return #force_inline internal_int_get(a, T);
(#force_inline internal_clear_if_uninitialized(a, allocator)) or_return;
return #force_inline internal_int_get(a, T);
}
get :: proc { int_get, };
@@ -315,8 +315,8 @@ int_get_float :: proc(a: ^Int, allocator := context.allocator) -> (res: f64, err
Check that `a` is usable.
*/
assert_if_nil(a);
if err = #force_inline internal_clear_if_uninitialized(a, allocator); err != nil { return 0, err; }
return #force_inline internal_int_get_float(a);
(#force_inline internal_clear_if_uninitialized(a, allocator)) or_return;
return #force_inline internal_int_get_float(a);
}
/*
@@ -327,8 +327,8 @@ count_bits :: proc(a: ^Int, allocator := context.allocator) -> (count: int, err:
Check that `a` is usable.
*/
assert_if_nil(a);
if err = #force_inline internal_clear_if_uninitialized(a, allocator); err != nil { return 0, err; }
return #force_inline internal_count_bits(a), nil;
(#force_inline internal_clear_if_uninitialized(a, allocator)) or_return;
return #force_inline internal_count_bits(a), nil;
}
/*
@@ -340,8 +340,8 @@ int_count_lsb :: proc(a: ^Int, allocator := context.allocator) -> (count: int, e
Check that `a` is usable.
*/
assert_if_nil(a);
if err = #force_inline internal_clear_if_uninitialized(a, allocator); err != nil { return 0, err; }
return #force_inline internal_int_count_lsb(a);
(#force_inline internal_clear_if_uninitialized(a, allocator)) or_return;
return #force_inline internal_int_count_lsb(a);
}
platform_count_lsb :: #force_inline proc(a: $T) -> (count: int)
@@ -398,7 +398,7 @@ clear_if_uninitialized_multi :: proc(args: ..^Int, allocator := context.allocato
assert_if_nil(..args);
for i in &args {
if err = #force_inline internal_clear_if_uninitialized_single(i, allocator); err != nil { return nil; }
(#force_inline internal_clear_if_uninitialized_single(i, allocator)) or_return;
}
return err;
}
@@ -425,7 +425,7 @@ int_init_multi :: proc(integers: ..^Int, allocator := context.allocator) -> (err
integers := integers;
for a in &integers {
if err = #force_inline internal_clear(a, true, allocator); err != nil { return err; }
(#force_inline internal_clear(a, true, allocator)) or_return;
}
return nil;
}
@@ -440,7 +440,7 @@ copy_digits :: proc(dest, src: ^Int, digits: int, allocator := context.allocator
Check that `src` is usable and `dest` isn't immutable.
*/
assert_if_nil(dest, src);
if err = #force_inline internal_clear_if_uninitialized(src); err != nil { return err; }
(#force_inline internal_clear_if_uninitialized(src)) or_return;
digits = min(digits, len(src.digit), len(dest.digit));
return #force_inline internal_copy_digits(dest, src, digits);
@@ -454,7 +454,7 @@ copy_digits :: proc(dest, src: ^Int, digits: int, allocator := context.allocator
*/
clamp :: proc(a: ^Int, allocator := context.allocator) -> (err: Error) {
assert_if_nil(a);
if err = #force_inline internal_clear_if_uninitialized(a, allocator); err != nil { return err; }
(#force_inline internal_clear_if_uninitialized(a, allocator)) or_return;
for a.used > 0 && a.digit[a.used - 1] == 0 {
a.used -= 1;
@@ -472,7 +472,7 @@ clamp :: proc(a: ^Int, allocator := context.allocator) -> (err: Error) {
*/
int_to_bytes_size :: proc(a: ^Int, signed := false, allocator := context.allocator) -> (size_in_bytes: int, err: Error) {
assert_if_nil(a);
if err = #force_inline internal_clear_if_uninitialized(a, allocator); err != nil { return {}, err; }
(#force_inline internal_clear_if_uninitialized(a, allocator)) or_return;
size_in_bits := internal_count_bits(a);
@@ -488,9 +488,8 @@ int_to_bytes_size :: proc(a: ^Int, signed := false, allocator := context.allocat
*/
int_to_bytes_little :: proc(a: ^Int, buf: []u8, signed := false, allocator := context.allocator) -> (err: Error) {
assert_if_nil(a);
size_in_bytes: int;
if size_in_bytes, err = int_to_bytes_size(a, signed, allocator); err != nil { return err; }
size_in_bytes := int_to_bytes_size(a, signed, allocator) or_return;
l := len(buf);
if size_in_bytes > l { return .Buffer_Overflow; }
@@ -512,9 +511,8 @@ int_to_bytes_little :: proc(a: ^Int, buf: []u8, signed := false, allocator := co
*/
int_to_bytes_big :: proc(a: ^Int, buf: []u8, signed := false, allocator := context.allocator) -> (err: Error) {
assert_if_nil(a);
size_in_bytes: int;
if size_in_bytes, err = int_to_bytes_size(a, signed, allocator); err != nil { return err; }
size_in_bytes := int_to_bytes_size(a, signed, allocator) or_return;
l := len(buf);
if size_in_bytes > l { return .Buffer_Overflow; }
@@ -537,18 +535,17 @@ int_to_bytes_big :: proc(a: ^Int, buf: []u8, signed := false, allocator := conte
*/
int_to_bytes_little_python :: proc(a: ^Int, buf: []u8, signed := false, allocator := context.allocator) -> (err: Error) {
assert_if_nil(a);
size_in_bytes: int;
if !signed && a.sign == .Negative { return .Invalid_Argument; }
l := len(buf);
if size_in_bytes, err = int_to_bytes_size(a, signed, allocator); err != nil { return err; }
if size_in_bytes > l { return .Buffer_Overflow; }
size_in_bytes := int_to_bytes_size(a, signed, allocator) or_return;
if size_in_bytes > l { return .Buffer_Overflow; }
if a.sign == .Negative {
t := &Int{};
defer destroy(t);
if err = internal_complement(t, a, allocator); err != nil { return err; }
internal_complement(t, a, allocator) or_return;
size_in_bits := internal_count_bits(t);
i := 0;
@@ -574,19 +571,18 @@ int_to_bytes_little_python :: proc(a: ^Int, buf: []u8, signed := false, allocato
*/
int_to_bytes_big_python :: proc(a: ^Int, buf: []u8, signed := false, allocator := context.allocator) -> (err: Error) {
assert_if_nil(a);
size_in_bytes: int;
if !signed && a.sign == .Negative { return .Invalid_Argument; }
if a.sign == .Zero_or_Positive { return int_to_bytes_big(a, buf, signed, allocator); }
l := len(buf);
if size_in_bytes, err = int_to_bytes_size(a, signed, allocator); err != nil { return err; }
if size_in_bytes > l { return .Buffer_Overflow; }
size_in_bytes := int_to_bytes_size(a, signed, allocator) or_return;
if size_in_bytes > l { return .Buffer_Overflow; }
t := &Int{};
defer destroy(t);
if err = internal_complement(t, a, allocator); err != nil { return err; }
internal_complement(t, a, allocator) or_return;
size_in_bits := internal_count_bits(t);
i := l - 1;
@@ -619,8 +615,8 @@ int_from_bytes_big :: proc(a: ^Int, buf: []u8, signed := false, allocator := con
}
size_in_digits := (size_in_bits + _DIGIT_BITS - 1) / _DIGIT_BITS;
size_in_digits += 0 if size_in_bits % 8 == 0 else 1;
if err = internal_zero(a, false, allocator); err != nil { return err; }
if err = internal_grow(a, size_in_digits, false, allocator); err != nil { return err; }
internal_zero(a, false, allocator) or_return;
internal_grow(a, size_in_digits, false, allocator) or_return;
if signed {
sign = .Zero_or_Positive if buf[0] == 0 else .Negative;
@@ -628,7 +624,7 @@ int_from_bytes_big :: proc(a: ^Int, buf: []u8, signed := false, allocator := con
}
for v in buf {
if err = internal_shl(a, a, 8); err != nil { return err; }
internal_shl(a, a, 8) or_return;
a.digit[0] |= DIGIT(v);
}
a.sign = sign;
@@ -656,8 +652,8 @@ int_from_bytes_big_python :: proc(a: ^Int, buf: []u8, signed := false, allocator
}
size_in_digits := (size_in_bits + _DIGIT_BITS - 1) / _DIGIT_BITS;
size_in_digits += 0 if size_in_bits % 8 == 0 else 1;
if err = internal_zero(a, false, allocator); err != nil { return err; }
if err = internal_grow(a, size_in_digits, false, allocator); err != nil { return err; }
internal_zero(a, false, allocator) or_return;
internal_grow(a, size_in_digits, false, allocator) or_return;
if signed {
sign = .Zero_or_Positive if buf[0] == 0 else .Negative;
@@ -665,7 +661,7 @@ int_from_bytes_big_python :: proc(a: ^Int, buf: []u8, signed := false, allocator
}
for v in buf {
if err = internal_shl(a, a, 8); err != nil { return err; }
internal_shl(a, a, 8) or_return;
if signed && sign == .Negative {
a.digit[0] |= DIGIT(255 - v);
} else {
@@ -674,7 +670,7 @@ int_from_bytes_big_python :: proc(a: ^Int, buf: []u8, signed := false, allocator
}
a.sign = sign;
a.used = size_in_digits;
if err = internal_clamp(a); err != nil { return err; }
internal_clamp(a) or_return;
if signed && sign == .Negative {
return internal_sub(a, a, 1);
@@ -702,8 +698,8 @@ int_from_bytes_little :: proc(a: ^Int, buf: []u8, signed := false, allocator :=
}
size_in_digits := (size_in_bits + _DIGIT_BITS - 1) / _DIGIT_BITS;
size_in_digits += 0 if size_in_bits % 8 == 0 else 1;
if err = internal_zero(a, false, allocator); err != nil { return err; }
if err = internal_grow(a, size_in_digits, false, allocator); err != nil { return err; }
internal_zero(a, false, allocator) or_return;
internal_grow(a, size_in_digits, false, allocator) or_return;
if signed {
sign = .Zero_or_Positive if buf[l-1] == 0 else .Negative;
@@ -712,7 +708,7 @@ int_from_bytes_little :: proc(a: ^Int, buf: []u8, signed := false, allocator :=
}
for _, i in buf {
if err = internal_shl(a, a, 8); err != nil { return err; }
internal_shl(a, a, 8) or_return;
a.digit[0] |= DIGIT(buf[l-i-1]);
}
a.sign = sign;
@@ -740,8 +736,8 @@ int_from_bytes_little_python :: proc(a: ^Int, buf: []u8, signed := false, alloca
}
size_in_digits := (size_in_bits + _DIGIT_BITS - 1) / _DIGIT_BITS;
size_in_digits += 0 if size_in_bits % 8 == 0 else 1;
if err = internal_zero(a, false, allocator); err != nil { return err; }
if err = internal_grow(a, size_in_digits, false, allocator); err != nil { return err; }
internal_zero(a, false, allocator) or_return;
internal_grow(a, size_in_digits, false, allocator) or_return;
if signed {
sign = .Zero_or_Positive if buf[l-1] == 0 else .Negative;
@@ -750,7 +746,7 @@ int_from_bytes_little_python :: proc(a: ^Int, buf: []u8, signed := false, alloca
}
for _, i in buf {
if err = internal_shl(a, a, 8); err != nil { return err; }
internal_shl(a, a, 8) or_return;
if signed && sign == .Negative {
a.digit[0] |= DIGIT(255 - buf[l-i-1]);
} else {
@@ -759,7 +755,7 @@ int_from_bytes_little_python :: proc(a: ^Int, buf: []u8, signed := false, alloca
}
a.sign = sign;
a.used = size_in_digits;
if err = internal_clamp(a); err != nil { return err; }
internal_clamp(a) or_return;
if signed && sign == .Negative {
return internal_sub(a, a, 1);

147
core/math/big/internal.odin
View File

@@ -58,7 +58,7 @@ internal_int_add_unsigned :: proc(dest, a, b: ^Int, allocator := context.allocat
max_used = x.used;
old_used = dest.used;
if err = internal_grow(dest, max(max_used + 1, _DEFAULT_DIGIT_COUNT)); err != nil { return err; }
internal_grow(dest, max(max_used + 1, _DEFAULT_DIGIT_COUNT)) or_return;
dest.used = max_used + 1;
/*
All parameters have been initialized.
@@ -158,7 +158,7 @@ internal_add_signed :: proc { internal_int_add_signed, };
internal_int_add_digit :: proc(dest, a: ^Int, digit: DIGIT, allocator := context.allocator) -> (err: Error) {
context.allocator = allocator;
if err = internal_grow(dest, a.used + 1); err != nil { return err; }
internal_grow(dest, a.used + 1) or_return;
/*
Fast paths for destination and input Int being the same.
*/
@@ -284,7 +284,7 @@ internal_int_sub_unsigned :: proc(dest, number, decrease: ^Int, allocator := con
max_used := x.used;
i: int;
if err = grow(dest, max(max_used, _DEFAULT_DIGIT_COUNT)); err != nil { return err; }
grow(dest, max(max_used, _DEFAULT_DIGIT_COUNT)) or_return;
dest.used = max_used;
/*
All parameters have been initialized.
@@ -389,7 +389,7 @@ internal_int_sub_signed :: proc(dest, number, decrease: ^Int, allocator := conte
internal_int_sub_digit :: proc(dest, number: ^Int, digit: DIGIT, allocator := context.allocator) -> (err: Error) {
context.allocator = allocator;
if err = internal_grow(dest, number.used + 1); err != nil { return err; }
internal_grow(dest, number.used + 1) or_return;
dest := dest; digit := digit;
/*
@@ -520,12 +520,12 @@ internal_int_shr1 :: proc(dest, src: ^Int) -> (err: Error) {
internal_int_shl1 :: proc(dest, src: ^Int, allocator := context.allocator) -> (err: Error) {
context.allocator = allocator;
if err = internal_copy(dest, src); err != nil { return err; }
internal_copy(dest, src) or_return;
/*
Grow `dest` to accommodate the additional bits.
*/
digits_needed := dest.used + 1;
if err = internal_grow(dest, digits_needed); err != nil { return err; }
internal_grow(dest, digits_needed) or_return;
dest.used = digits_needed;
mask := (DIGIT(1) << uint(1)) - DIGIT(1);
@@ -568,15 +568,14 @@ internal_int_mul_digit :: proc(dest, src: ^Int, multiplier: DIGIT, allocator :=
return #force_inline internal_int_shl1(dest, src);
}
if #force_inline platform_int_is_power_of_two(int(multiplier)) {
ix: int;
if ix, err = internal_log(multiplier, 2); err != nil { return err; }
ix := internal_log(multiplier, 2) or_return;
return internal_shl(dest, src, ix);
}
/*
Ensure `dest` is big enough to hold `src` * `multiplier`.
*/
if err = grow(dest, max(src.used + 1, _DEFAULT_DIGIT_COUNT)); err != nil { return err; }
grow(dest, max(src.used + 1, _DEFAULT_DIGIT_COUNT)) or_return;
/*
Save the original used count.
@@ -722,7 +721,7 @@ internal_int_divmod :: proc(quotient, remainder, numerator, denominator: ^Int, a
*/
if #force_inline internal_cmp_mag(numerator, denominator) == -1 {
if remainder != nil {
if err = internal_copy(remainder, numerator); err != nil { return err; }
internal_copy(remainder, numerator) or_return;
}
if quotient != nil {
internal_zero(quotient);
@@ -809,7 +808,7 @@ internal_int_divmod_digit :: proc(quotient, numerator: ^Int, denominator: DIGIT,
*/
q := &Int{};
if err = internal_grow(q, numerator.used); err != nil { return 0, err; }
internal_grow(q, numerator.used) or_return;
q.used = numerator.used;
q.sign = numerator.sign;
@@ -853,7 +852,7 @@ internal_div :: proc { internal_int_div, };
Asssumes quotient, numerator and denominator to have been initialized and not to be nil.
*/
internal_int_mod :: proc(remainder, numerator, denominator: ^Int, allocator := context.allocator) -> (err: Error) {
if err = #force_inline internal_int_divmod(nil, remainder, numerator, denominator, allocator); err != nil { return err; }
(#force_inline internal_int_divmod(nil, remainder, numerator, denominator, allocator)) or_return;
if remainder.used == 0 || denominator.sign == remainder.sign { return nil; }
@@ -865,7 +864,7 @@ internal_mod :: proc{ internal_int_mod, };
remainder = (number + addend) % modulus.
*/
internal_int_addmod :: proc(remainder, number, addend, modulus: ^Int, allocator := context.allocator) -> (err: Error) {
if err = #force_inline internal_add(remainder, number, addend, allocator); err != nil { return err; }
(#force_inline internal_add(remainder, number, addend, allocator)) or_return;
return #force_inline internal_mod(remainder, remainder, modulus, allocator);
}
internal_addmod :: proc { internal_int_addmod, };
@@ -874,7 +873,7 @@ internal_addmod :: proc { internal_int_addmod, };
remainder = (number - decrease) % modulus.
*/
internal_int_submod :: proc(remainder, number, decrease, modulus: ^Int, allocator := context.allocator) -> (err: Error) {
if err = #force_inline internal_sub(remainder, number, decrease, allocator); err != nil { return err; }
(#force_inline internal_sub(remainder, number, decrease, allocator)) or_return;
return #force_inline internal_mod(remainder, remainder, modulus, allocator);
}
internal_submod :: proc { internal_int_submod, };
@@ -883,7 +882,7 @@ internal_submod :: proc { internal_int_submod, };
remainder = (number * multiplicand) % modulus.
*/
internal_int_mulmod :: proc(remainder, number, multiplicand, modulus: ^Int, allocator := context.allocator) -> (err: Error) {
if err = #force_inline internal_mul(remainder, number, multiplicand, allocator); err != nil { return err; }
(#force_inline internal_mul(remainder, number, multiplicand, allocator)) or_return;
return #force_inline internal_mod(remainder, remainder, modulus, allocator);
}
internal_mulmod :: proc { internal_int_mulmod, };
@@ -892,7 +891,7 @@ internal_mulmod :: proc { internal_int_mulmod, };
remainder = (number * number) % modulus.
*/
internal_int_sqrmod :: proc(remainder, number, modulus: ^Int, allocator := context.allocator) -> (err: Error) {
if err = #force_inline internal_sqr(remainder, number, allocator); err != nil { return err; }
(#force_inline internal_sqr(remainder, number, allocator)) or_return;
return #force_inline internal_mod(remainder, remainder, modulus, allocator);
}
internal_sqrmod :: proc { internal_int_sqrmod, };
@@ -915,9 +914,11 @@ internal_int_factorial :: proc(res: ^Int, n: int, allocator := context.allocator
return #force_inline internal_set(res, _factorial_table[n]);
}
if err = #force_inline internal_set(res, _factorial_table[i - 1]); err != nil { return err; }
(#force_inline internal_set(res, _factorial_table[i - 1])) or_return;
for {
if err = #force_inline internal_mul(res, res, DIGIT(i)); err != nil || i == n { return err; }
if err = #force_inline internal_mul(res, res, DIGIT(i)); err != nil || i == n {
return err;
}
i += 1;
}
@@ -950,8 +951,8 @@ internal_int_mod_bits :: proc(remainder, numerator: ^Int, bits: int, allocator :
/*
If the modulus is larger than the value, return the value.
*/
err = internal_copy(remainder, numerator);
if bits >= (numerator.used * _DIGIT_BITS) || err != nil {
internal_copy(remainder, numerator) or_return;
if bits >= (numerator.used * _DIGIT_BITS) {
return;
}
@@ -1264,7 +1265,7 @@ internal_int_pow :: proc(dest, base: ^Int, power: int, allocator := context.allo
A zero base is a special case.
*/
if power < 0 {
if err = internal_zero(dest); err != nil { return err; }
internal_zero(dest) or_return;
return .Math_Domain_Error;
}
if power == 0 { return internal_one(dest); }
@@ -1293,37 +1294,34 @@ internal_int_pow :: proc(dest, base: ^Int, power: int, allocator := context.allo
}
g := &Int{};
if err = internal_copy(g, base); err != nil { return err; }
internal_copy(g, base) or_return;
/*
Set initial result.
*/
if err = internal_one(dest); err != nil { return err; }
internal_one(dest) or_return;
loop: for power > 0 {
defer internal_destroy(g);
for power > 0 {
/*
If the bit is set, multiply.
*/
if power & 1 != 0 {
if err = internal_mul(dest, g, dest); err != nil {
break loop;
}
internal_mul(dest, g, dest) or_return;
}
/*
Square.
*/
if power > 1 {
if err = #force_inline internal_sqr(g, g); err != nil {
break loop;
}
internal_sqr(g, g) or_return;
}
/* shift to next bit */
power >>= 1;
}
internal_destroy(g);
return err;
return;
}
/*
@@ -1336,7 +1334,7 @@ internal_int_pow_int :: proc(dest: ^Int, base, power: int, allocator := context.
base_t := &Int{};
defer internal_destroy(base_t);
if err = internal_set(base_t, base); err != nil { return err; }
internal_set(base_t, base) or_return;
return #force_inline internal_int_pow(dest, base_t, power);
}
@@ -1387,15 +1385,15 @@ internal_int_sqrt :: proc(dest, src: ^Int, allocator := context.allocator) -> (e
count := #force_inline internal_count_bits(src);
a, b := count >> 1, count & 1;
if err = internal_int_power_of_two(x, a+b, allocator); err != nil { return err; }
internal_int_power_of_two(x, a+b, allocator) or_return;
for {
/*
y = (x + n // x) // 2
*/
if err = internal_div(t1, src, x); err != nil { return err; }
if err = internal_add(t2, t1, x); err != nil { return err; }
if err = internal_shr(y, t2, 1); err != nil { return err; }
internal_div(t1, src, x) or_return;
internal_add(t2, t1, x) or_return;
internal_shr(y, t2, 1) or_return;
if c := internal_cmp(y, x); c == 0 || c == 1 {
internal_swap(dest, x);
@@ -1480,33 +1478,33 @@ internal_int_root_n :: proc(dest, src: ^Int, n: int, allocator := context.alloca
Start value must be larger than root.
*/
ilog2 += 2;
if err = internal_int_power_of_two(t2, ilog2); err != nil { return err; }
internal_int_power_of_two(t2, ilog2) or_return;
c: int;
iterations := 0;
for {
/* t1 = t2 */
if err = internal_copy(t1, t2); err != nil { return err; }
internal_copy(t1, t2) or_return;
/* t2 = t1 - ((t1**b - a) / (b * t1**(b-1))) */
/* t3 = t1**(b-1) */
if err = internal_pow(t3, t1, n-1); err != nil { return err; }
internal_pow(t3, t1, n-1) or_return;
/* numerator */
/* t2 = t1**b */
if err = internal_mul(t2, t1, t3); err != nil { return err; }
internal_mul(t2, t1, t3) or_return;
/* t2 = t1**b - a */
if err = internal_sub(t2, t2, a); err != nil { return err; }
internal_sub(t2, t2, a) or_return;
/* denominator */
/* t3 = t1**(b-1) * b */
if err = internal_mul(t3, t3, DIGIT(n)); err != nil { return err; }
internal_mul(t3, t3, DIGIT(n)) or_return;
/* t3 = (t1**b - a)/(b * t1**(b-1)) */
if err = internal_div(t3, t2, t3); err != nil { return err; }
if err = internal_sub(t2, t1, t3); err != nil { return err; }
internal_div(t3, t2, t3) or_return;
internal_sub(t2, t1, t3) or_return;
/*
Number of rounds is at most log_2(root). If it is more it
@@ -1526,14 +1524,14 @@ internal_int_root_n :: proc(dest, src: ^Int, n: int, allocator := context.alloca
iterations = 0;
for {
if err = internal_pow(t2, t1, n); err != nil { return err; }
internal_pow(t2, t1, n) or_return;
c = internal_cmp(t2, a);
if c == 0 {
swap(dest, t1);
return nil;
} else if c == -1 {
if err = internal_add(t1, t1, DIGIT(1)); err != nil { return err; }
internal_add(t1, t1, DIGIT(1)) or_return;
} else {
break;
}
@@ -1549,11 +1547,11 @@ internal_int_root_n :: proc(dest, src: ^Int, n: int, allocator := context.alloca
Correct overshoot from above or from recurrence.
*/
for {
if err = internal_pow(t2, t1, n); err != nil { return err; }
internal_pow(t2, t1, n) or_return;
if internal_cmp(t2, a) != 1 { break; }
if err = internal_sub(t1, t1, DIGIT(1)); err != nil { return err; }
internal_sub(t1, t1, DIGIT(1)) or_return;
iterations += 1;
if iterations == MAX_ITERATIONS_ROOT_N {
@@ -1606,12 +1604,12 @@ internal_int_set_from_integer :: proc(dest: ^Int, src: $T, minimize := false, al
src := src;
if err = internal_error_if_immutable(dest); err != nil { return err; }
internal_error_if_immutable(dest) or_return;
/*
Most internal procs asssume an Int to have already been initialize,
but as this is one of the procs that initializes, we have to check the following.
*/
if err = internal_clear_if_uninitialized_single(dest); err != nil { return err; }
internal_clear_if_uninitialized_single(dest) or_return;
dest.flags = {}; // We're not -Inf, Inf, NaN or Immutable.
@@ -1631,7 +1629,7 @@ internal_int_set_from_integer :: proc(dest: ^Int, src: $T, minimize := false, al
internal_set :: proc { internal_int_set_from_integer, internal_int_copy };
internal_copy_digits :: #force_inline proc(dest, src: ^Int, digits: int) -> (err: Error) {
if err = #force_inline internal_error_if_immutable(dest); err != nil { return err; }
(#force_inline internal_error_if_immutable(dest)) or_return;
/*
If dest == src, do nothing
@@ -1653,7 +1651,7 @@ internal_int_copy :: proc(dest, src: ^Int, minimize := false, allocator := conte
*/
if (dest == src) { return nil; }
if err = internal_error_if_immutable(dest); err != nil { return err; }
internal_error_if_immutable(dest) or_return;
/*
Grow `dest` to fit `src`.
@@ -1661,7 +1659,7 @@ internal_int_copy :: proc(dest, src: ^Int, minimize := false, allocator := conte
*/
needed := src.used if minimize else max(src.used, _DEFAULT_DIGIT_COUNT);
if err = internal_grow(dest, needed, minimize); err != nil { return err; }
internal_grow(dest, needed, minimize) or_return;
/*
Copy everything over and zero high digits.
@@ -1708,9 +1706,7 @@ internal_int_abs :: proc(dest, src: ^Int, allocator := context.allocator) -> (er
/*
Copy `src` to `dest`
*/
if err = internal_copy(dest, src); err != nil {
return err;
}
internal_copy(dest, src) or_return;
/*
Fix sign.
@@ -1744,7 +1740,7 @@ internal_int_neg :: proc(dest, src: ^Int, allocator := context.allocator) -> (er
/*
Copy `src` to `dest`
*/
if err = internal_copy(dest, src); err != nil { return err; }
internal_copy(dest, src) or_return;
/*
Fix sign.
@@ -1953,7 +1949,7 @@ internal_int_power_of_two :: proc(a: ^Int, power: int, allocator := context.allo
Grow to accomodate the single bit.
*/
a.used = (power / _DIGIT_BITS) + 1;
if err = internal_grow(a, a.used); err != nil { return err; }
internal_grow(a, a.used) or_return;
/*
Zero the entirety.
*/
@@ -2061,7 +2057,7 @@ internal_int_and :: proc(dest, a, b: ^Int, allocator := context.allocator) -> (e
/*
Grow the destination to accomodate the result.
*/
if err = internal_grow(dest, used); err != nil { return err; }
internal_grow(dest, used) or_return;
neg_a := #force_inline internal_is_negative(a);
neg_b := #force_inline internal_is_negative(b);
@@ -2122,7 +2118,7 @@ internal_int_or :: proc(dest, a, b: ^Int, allocator := context.allocator) -> (er
/*
Grow the destination to accomodate the result.
*/
if err = internal_grow(dest, used); err != nil { return err; }
internal_grow(dest, used) or_return;
neg_a := #force_inline internal_is_negative(a);
neg_b := #force_inline internal_is_negative(b);
@@ -2183,7 +2179,7 @@ internal_int_xor :: proc(dest, a, b: ^Int, allocator := context.allocator) -> (e
/*
Grow the destination to accomodate the result.
*/
if err = internal_grow(dest, used); err != nil { return err; }
internal_grow(dest, used) or_return;
neg_a := #force_inline internal_is_negative(a);
neg_b := #force_inline internal_is_negative(b);
@@ -2269,21 +2265,21 @@ internal_int_shrmod :: proc(quotient, remainder, numerator: ^Int, bits: int, all
bits := bits;
if bits < 0 { return .Invalid_Argument; }
if err = internal_copy(quotient, numerator); err != nil { return err; }
internal_copy(quotient, numerator) or_return;
/*
Shift right by a certain bit count (store quotient and optional remainder.)
`numerator` should not be used after this.
*/
if remainder != nil {
if err = internal_int_mod_bits(remainder, numerator, bits); err != nil { return err; }
internal_int_mod_bits(remainder, numerator, bits) or_return;
}
/*
Shift by as many digits in the bit count.
*/
if bits >= _DIGIT_BITS {
if err = internal_shr_digit(quotient, bits / _DIGIT_BITS); err != nil { return err; }
internal_shr_digit(quotient, bits / _DIGIT_BITS) or_return;
}
/*
@@ -2362,9 +2358,8 @@ internal_int_shr_signed :: proc(dest, src: ^Int, bits: int, allocator := context
if src.sign == .Zero_or_Positive {
return internal_shr(dest, src, bits);
}
if err = internal_int_add_digit(dest, src, DIGIT(1)); err != nil { return err; }
if err = internal_shr(dest, dest, bits); err != nil { return err; }
internal_int_add_digit(dest, src, DIGIT(1)) or_return;
internal_shr(dest, dest, bits) or_return;
return internal_sub(dest, src, DIGIT(1));
}
@@ -2380,19 +2375,19 @@ internal_int_shl :: proc(dest, src: ^Int, bits: int, allocator := context.alloca
if bits < 0 { return .Invalid_Argument; }
if err = internal_copy(dest, src); err != nil { return err; }
internal_copy(dest, src) or_return;
/*
Grow `dest` to accommodate the additional bits.
*/
digits_needed := dest.used + (bits / _DIGIT_BITS) + 1;
if err = internal_grow(dest, digits_needed); err != nil { return err; }
internal_grow(dest, digits_needed) or_return;
dest.used = digits_needed;
/*
Shift by as many digits in the bit count as we have.
*/
if bits >= _DIGIT_BITS {
if err = internal_shl_digit(dest, bits / _DIGIT_BITS); err != nil { return err; }
internal_shl_digit(dest, bits / _DIGIT_BITS) or_return;
}
/*
@@ -2434,12 +2429,14 @@ internal_int_shl_digit :: proc(quotient: ^Int, digits: int, allocator := context
/*
No need to shift a zero.
*/
if #force_inline internal_is_zero(quotient) { return {}; }
if #force_inline internal_is_zero(quotient) {
return nil;
}
/*
Resize `quotient` to accomodate extra digits.
*/
if err = #force_inline internal_grow(quotient, quotient.used + digits); err != nil { return err; }
(#force_inline internal_grow(quotient, quotient.used + digits)) or_return;
/*
Increment the used by the shift amount then copy upwards.
@@ -2537,7 +2534,7 @@ internal_int_rand :: proc(dest: ^Int, bits: int, r: ^rnd.Rand = nil, allocator :
digits += 1;
}
if err = #force_inline internal_grow(dest, digits); err != nil { return err; }
(#force_inline internal_grow(dest, digits)) or_return;
for i := 0; i < digits; i += 1 {
dest.digit[i] = int_random_digit(r) & _MASK;
@@ -2600,7 +2597,7 @@ internal_int_init_multi :: proc(integers: ..^Int, allocator := context.allocator
integers := integers;
for a in &integers {
if err = internal_clear(a); err != nil { return err; }
internal_clear(a) or_return;
}
return nil;
}

16
core/math/big/logical.odin
View File

@@ -25,7 +25,7 @@ int_and :: proc(dest, a, b: ^Int, allocator := context.allocator) -> (err: Error
assert_if_nil(dest, a, b);
context.allocator = allocator;
if err = internal_clear_if_uninitialized(a, b); err != nil { return err; }
internal_clear_if_uninitialized(a, b) or_return;
return #force_inline internal_int_and(dest, a, b);
}
and :: proc { int_and, };
@@ -37,7 +37,7 @@ int_or :: proc(dest, a, b: ^Int, allocator := context.allocator) -> (err: Error)
assert_if_nil(dest, a, b);
context.allocator = allocator;
if err = internal_clear_if_uninitialized(a, b); err != nil { return err; }
internal_clear_if_uninitialized(a, b) or_return;
return #force_inline internal_int_or(dest, a, b);
}
or :: proc { int_or, };
@@ -49,7 +49,7 @@ int_xor :: proc(dest, a, b: ^Int, allocator := context.allocator) -> (err: Error
assert_if_nil(dest, a, b);
context.allocator = allocator;
if err = internal_clear_if_uninitialized(a, b); err != nil { return err; }
internal_clear_if_uninitialized(a, b) or_return;
return #force_inline internal_int_xor(dest, a, b);
}
xor :: proc { int_xor, };
@@ -64,7 +64,7 @@ int_complement :: proc(dest, src: ^Int, allocator := context.allocator) -> (err:
assert_if_nil(dest, src);
context.allocator = allocator;
if err = internal_clear_if_uninitialized(dest, src); err != nil { return err; }
internal_clear_if_uninitialized(dest, src) or_return;
return #force_inline internal_int_complement(dest, src);
}
complement :: proc { int_complement, };
@@ -97,7 +97,7 @@ int_shr_digit :: proc(quotient: ^Int, digits: int, allocator := context.allocato
assert_if_nil(quotient);
context.allocator = allocator;
if err = internal_clear_if_uninitialized(quotient); err != nil { return err; }
internal_clear_if_uninitialized(quotient) or_return;
return #force_inline internal_int_shr_digit(quotient, digits);
}
shr_digit :: proc { int_shr_digit, };
@@ -109,7 +109,7 @@ int_shr_signed :: proc(dest, src: ^Int, bits: int, allocator := context.allocato
assert_if_nil(dest, src);
context.allocator = allocator;
if err = internal_clear_if_uninitialized(dest, src); err != nil { return err; }
internal_clear_if_uninitialized(dest, src) or_return;
return #force_inline internal_int_shr_signed(dest, src, bits);
}
@@ -122,7 +122,7 @@ int_shl :: proc(dest, src: ^Int, bits: int, allocator := context.allocator) -> (
assert_if_nil(dest, src);
context.allocator = allocator;
if err = internal_clear_if_uninitialized(dest, src); err != nil { return err; }
internal_clear_if_uninitialized(dest, src) or_return;
return #force_inline internal_int_shl(dest, src, bits);
}
shl :: proc { int_shl, };
@@ -138,7 +138,7 @@ int_shl_digit :: proc(quotient: ^Int, digits: int, allocator := context.allocato
assert_if_nil(quotient);
context.allocator = allocator;
if err = internal_clear_if_uninitialized(quotient); err != nil { return err; }
internal_clear_if_uninitialized(quotient) or_return;
return #force_inline internal_int_shl_digit(quotient, digits);
}
shl_digit :: proc { int_shl_digit, };

9
core/math/big/prime.odin
View File

@@ -19,12 +19,13 @@ int_prime_is_divisible :: proc(a: ^Int, allocator := context.allocator) -> (res:
assert_if_nil(a);
context.allocator = allocator;
if err = internal_clear_if_uninitialized(a); err != nil { return {}, err; }
internal_clear_if_uninitialized(a) or_return;
rem: DIGIT;
for prime in _private_prime_table {
if rem, err = #force_inline int_mod_digit(a, prime); err != nil { return false, err; }
if rem == 0 { return true, nil; }
rem := (#force_inline int_mod_digit(a, prime)) or_return;
if rem == 0 {
return true, nil;
}
}
/*
Default to not divisible.

447
core/math/big/private.odin
View File

File diff suppressed because it is too large Load Diff

91
core/math/big/public.odin
View File

@@ -24,7 +24,7 @@ int_add :: proc(dest, a, b: ^Int, allocator := context.allocator) -> (err: Error
assert_if_nil(dest, a, b);
context.allocator = allocator;
if err = internal_clear_if_uninitialized(dest, a, b); err != nil { return err; }
internal_clear_if_uninitialized(dest, a, b) or_return;
/*
All parameters have been initialized.
*/
@@ -41,11 +41,11 @@ int_add_digit :: proc(dest, a: ^Int, digit: DIGIT, allocator := context.allocato
assert_if_nil(dest, a);
context.allocator = allocator;
if err = internal_clear_if_uninitialized(a); err != nil { return err; }
internal_clear_if_uninitialized(a) or_return;
/*
Grow destination as required.
*/
if err = grow(dest, a.used + 1); err != nil { return err; }
grow(dest, a.used + 1) or_return;
/*
All parameters have been initialized.
@@ -60,7 +60,7 @@ int_sub :: proc(dest, number, decrease: ^Int, allocator := context.allocator) ->
assert_if_nil(dest, number, decrease);
context.allocator = allocator;
if err = internal_clear_if_uninitialized(dest, number, decrease); err != nil { return err; }
internal_clear_if_uninitialized(dest, number, decrease) or_return;
/*
All parameters have been initialized.
*/
@@ -77,11 +77,11 @@ int_sub_digit :: proc(dest, a: ^Int, digit: DIGIT, allocator := context.allocato
assert_if_nil(dest, a);
context.allocator = allocator;
if err = internal_clear_if_uninitialized(a); err != nil { return err; }
internal_clear_if_uninitialized(a) or_return;
/*
Grow destination as required.
*/
if err = grow(dest, a.used + 1); err != nil { return err; }
grow(dest, a.used + 1) or_return;
/*
All parameters have been initialized.
@@ -97,11 +97,11 @@ int_halve :: proc(dest, src: ^Int, allocator := context.allocator) -> (err: Erro
assert_if_nil(dest, src);
context.allocator = allocator;
if err = internal_clear_if_uninitialized(dest, src); err != nil { return err; }
internal_clear_if_uninitialized(dest, src) or_return;
/*
Grow destination as required.
*/
if dest != src { if err = grow(dest, src.used + 1); err != nil { return err; } }
if dest != src { grow(dest, src.used + 1) or_return }
return #force_inline internal_int_shr1(dest, src);
}
@@ -116,11 +116,11 @@ int_double :: proc(dest, src: ^Int, allocator := context.allocator) -> (err: Err
assert_if_nil(dest, src);
context.allocator = allocator;
if err = internal_clear_if_uninitialized(dest, src); err != nil { return err; }
internal_clear_if_uninitialized(dest, src) or_return;
/*
Grow destination as required.
*/
if dest != src { if err = grow(dest, src.used + 1); err != nil { return err; } }
if dest != src { grow(dest, src.used + 1) or_return; }
return #force_inline internal_int_shl1(dest, src);
}
@@ -134,7 +134,7 @@ int_mul_digit :: proc(dest, src: ^Int, multiplier: DIGIT, allocator := context.a
assert_if_nil(dest, src);
context.allocator = allocator;
if err = internal_clear_if_uninitialized(src, dest); err != nil { return err; }
internal_clear_if_uninitialized(src, dest) or_return;
return #force_inline internal_int_mul_digit(dest, src, multiplier);
}
@@ -146,7 +146,7 @@ int_mul :: proc(dest, src, multiplier: ^Int, allocator := context.allocator) ->
assert_if_nil(dest, src, multiplier);
context.allocator = allocator;
if err = internal_clear_if_uninitialized(dest, src, multiplier); err != nil { return err; }
internal_clear_if_uninitialized(dest, src, multiplier) or_return;
return #force_inline internal_int_mul(dest, src, multiplier);
}
@@ -166,7 +166,7 @@ int_divmod :: proc(quotient, remainder, numerator, denominator: ^Int, allocator
Early out if neither of the results is wanted.
*/
if quotient == nil && remainder == nil { return nil; }
if err = internal_clear_if_uninitialized(numerator, denominator); err != nil { return err; }
internal_clear_if_uninitialized(numerator, denominator) or_return;
return #force_inline internal_divmod(quotient, remainder, numerator, denominator);
}
@@ -175,7 +175,7 @@ int_divmod_digit :: proc(quotient, numerator: ^Int, denominator: DIGIT, allocato
assert_if_nil(quotient, numerator);
context.allocator = allocator;
if err = internal_clear_if_uninitialized(numerator); err != nil { return 0, err; }
internal_clear_if_uninitialized(numerator) or_return;
return #force_inline internal_divmod(quotient, numerator, denominator);
}
@@ -185,7 +185,7 @@ int_div :: proc(quotient, numerator, denominator: ^Int, allocator := context.all
assert_if_nil(quotient, numerator, denominator);
context.allocator = allocator;
if err = internal_clear_if_uninitialized(numerator, denominator); err != nil { return err; }
internal_clear_if_uninitialized(numerator, denominator) or_return;
return #force_inline internal_divmod(quotient, nil, numerator, denominator);
}
@@ -194,11 +194,10 @@ int_div_digit :: proc(quotient, numerator: ^Int, denominator: DIGIT, allocator :
assert_if_nil(quotient, numerator);
context.allocator = allocator;
if err = internal_clear_if_uninitialized(numerator); err != nil { return err; }
internal_clear_if_uninitialized(numerator) or_return;
remainder: DIGIT;
remainder, err = #force_inline internal_divmod(quotient, numerator, denominator);
return err;
_ = (#force_inline internal_divmod(quotient, numerator, denominator)) or_return;
return;
}
div :: proc { int_div, int_div_digit, };
@@ -211,7 +210,7 @@ int_mod :: proc(remainder, numerator, denominator: ^Int, allocator := context.al
assert_if_nil(remainder, numerator, denominator);
context.allocator = allocator;
if err = internal_clear_if_uninitialized(numerator, denominator); err != nil { return err; }
internal_clear_if_uninitialized(numerator, denominator) or_return;
return #force_inline internal_int_mod(remainder, numerator, denominator);
}
@@ -229,7 +228,7 @@ int_addmod :: proc(remainder, number, addend, modulus: ^Int, allocator := contex
assert_if_nil(remainder, number, addend);
context.allocator = allocator;
if err = internal_clear_if_uninitialized(number, addend, modulus); err != nil { return err; }
internal_clear_if_uninitialized(number, addend, modulus) or_return;
return #force_inline internal_addmod(remainder, number, addend, modulus);
}
@@ -242,7 +241,7 @@ int_submod :: proc(remainder, number, decrease, modulus: ^Int, allocator := cont
assert_if_nil(remainder, number, decrease);
context.allocator = allocator;
if err = internal_clear_if_uninitialized(number, decrease, modulus); err != nil { return err; }
internal_clear_if_uninitialized(number, decrease, modulus) or_return;
return #force_inline internal_submod(remainder, number, decrease, modulus);
}
@@ -255,7 +254,7 @@ int_mulmod :: proc(remainder, number, multiplicand, modulus: ^Int, allocator :=
assert_if_nil(remainder, number, multiplicand);
context.allocator = allocator;
if err = internal_clear_if_uninitialized(number, multiplicand, modulus); err != nil { return err; }
internal_clear_if_uninitialized(number, multiplicand, modulus) or_return;
return #force_inline internal_mulmod(remainder, number, multiplicand, modulus);
}
@@ -268,7 +267,7 @@ int_sqrmod :: proc(remainder, number, modulus: ^Int, allocator := context.alloca
assert_if_nil(remainder, number, modulus);
context.allocator = allocator;
if err = internal_clear_if_uninitialized(number, modulus); err != nil { return err; }
internal_clear_if_uninitialized(number, modulus) or_return;
return #force_inline internal_sqrmod(remainder, number, modulus);
}
@@ -312,14 +311,14 @@ int_choose_digit :: proc(res: ^Int, n, k: int, allocator := context.allocator) -
n_fac, k_fac, n_minus_k_fac := &Int{}, &Int{}, &Int{};
defer internal_destroy(n_fac, k_fac, n_minus_k_fac);
if err = #force_inline internal_int_factorial(n_minus_k_fac, n - k); err != nil { return err; }
if err = #force_inline internal_int_factorial(k_fac, k); err != nil { return err; }
if err = #force_inline internal_mul(k_fac, k_fac, n_minus_k_fac); err != nil { return err; }
(#force_inline internal_int_factorial(n_minus_k_fac, n - k)) or_return;
(#force_inline internal_int_factorial(k_fac, k)) or_return;
(#force_inline internal_mul(k_fac, k_fac, n_minus_k_fac)) or_return;
if err = #force_inline internal_int_factorial(n_fac, n); err != nil { return err; }
if err = #force_inline internal_div(res, n_fac, k_fac); err != nil { return err; }
(#force_inline internal_int_factorial(n_fac, n)) or_return;
(#force_inline internal_div(res, n_fac, k_fac)) or_return;
return err;
return;
}
choose :: proc { int_choose_digit, };
@@ -331,7 +330,7 @@ int_gcd_lcm :: proc(res_gcd, res_lcm, a, b: ^Int, allocator := context.allocator
assert_if_nil(a, b);
context.allocator = allocator;
if err = internal_clear_if_uninitialized(a, b); err != nil { return err; }
internal_clear_if_uninitialized(a, b) or_return;
return #force_inline internal_int_gcd_lcm(res_gcd, res_lcm, a, b);
}
gcd_lcm :: proc { int_gcd_lcm, };
@@ -359,8 +358,8 @@ int_mod_bits :: proc(remainder, numerator: ^Int, bits: int, allocator := context
assert_if_nil(remainder, numerator);
context.allocator = allocator;
if err = internal_clear_if_uninitialized(remainder, numerator); err != nil { return err; }
if bits < 0 { return .Invalid_Argument; }
internal_clear_if_uninitialized(remainder, numerator) or_return;
if bits < 0 { return .Invalid_Argument; }
return #force_inline internal_int_mod_bits(remainder, numerator, bits);
}
@@ -375,7 +374,7 @@ int_log :: proc(a: ^Int, base: DIGIT, allocator := context.allocator) -> (res: i
assert_if_nil(a);
context.allocator = allocator;
if err = internal_clear_if_uninitialized(a); err != nil { return 0, err; }
internal_clear_if_uninitialized(a) or_return;
return #force_inline internal_int_log(a, base);
}
@@ -392,7 +391,7 @@ int_pow :: proc(dest, base: ^Int, power: int, allocator := context.allocator) ->
assert_if_nil(dest, base);
context.allocator = allocator;
if err = internal_clear_if_uninitialized(dest, base); err != nil { return err; }
internal_clear_if_uninitialized(dest, base) or_return;
return #force_inline internal_int_pow(dest, base, power);
}
@@ -420,7 +419,7 @@ int_sqrt :: proc(dest, src: ^Int, allocator := context.allocator) -> (err: Error
assert_if_nil(dest, src);
context.allocator = allocator;
if err = internal_clear_if_uninitialized(dest, src); err != nil { return err; }
internal_clear_if_uninitialized(dest, src) or_return;
return #force_inline internal_int_sqrt(dest, src);
}
@@ -446,7 +445,7 @@ int_root_n :: proc(dest, src: ^Int, n: int, allocator := context.allocator) -> (
/*
Initialize dest + src if needed.
*/
if err = internal_clear_if_uninitialized(dest, src); err != nil { return err; }
internal_clear_if_uninitialized(dest, src) or_return;
return #force_inline internal_int_root_n(dest, src, n);
}
@@ -466,7 +465,7 @@ int_is_zero :: proc(a: ^Int, allocator := context.allocator) -> (zero: bool, err
assert_if_nil(a);
context.allocator = allocator;
if err = internal_clear_if_uninitialized(a); err != nil { return false, err; }
internal_clear_if_uninitialized(a) or_return;
return #force_inline internal_is_zero(a), nil;
}
@@ -475,7 +474,7 @@ int_is_positive :: proc(a: ^Int, allocator := context.allocator) -> (positive: b
assert_if_nil(a);
context.allocator = allocator;
if err = internal_clear_if_uninitialized(a); err != nil { return false, err; }
internal_clear_if_uninitialized(a) or_return;
return #force_inline internal_is_positive(a), nil;
}
@@ -484,7 +483,7 @@ int_is_negative :: proc(a: ^Int, allocator := context.allocator) -> (negative: b
assert_if_nil(a);
context.allocator = allocator;
if err = internal_clear_if_uninitialized(a); err != nil { return false, err; }
internal_clear_if_uninitialized(a) or_return;
return #force_inline internal_is_negative(a), nil;
}
@@ -493,7 +492,7 @@ int_is_even :: proc(a: ^Int, allocator := context.allocator) -> (even: bool, err
assert_if_nil(a);
context.allocator = allocator;
if err = internal_clear_if_uninitialized(a); err != nil { return false, err; }
internal_clear_if_uninitialized(a) or_return;
return #force_inline internal_is_even(a), nil;
}
@@ -502,7 +501,7 @@ int_is_odd :: proc(a: ^Int, allocator := context.allocator) -> (odd: bool, err:
assert_if_nil(a);
context.allocator = allocator;
if err = internal_clear_if_uninitialized(a); err != nil { return false, err; }
internal_clear_if_uninitialized(a) or_return;
return #force_inline internal_is_odd(a), nil;
}
@@ -515,7 +514,7 @@ int_is_power_of_two :: proc(a: ^Int, allocator := context.allocator) -> (res: bo
assert_if_nil(a);
context.allocator = allocator;
if err = internal_clear_if_uninitialized(a); err != nil { return false, err; }
internal_clear_if_uninitialized(a) or_return;
return #force_inline internal_is_power_of_two(a), nil;
}
@@ -527,7 +526,7 @@ int_compare :: proc(a, b: ^Int, allocator := context.allocator) -> (comparison:
assert_if_nil(a, b);
context.allocator = allocator;
if err = internal_clear_if_uninitialized(a, b); err != nil { return 0, err; }
internal_clear_if_uninitialized(a, b) or_return;
return #force_inline internal_cmp(a, b), nil;
}
@@ -540,7 +539,7 @@ int_compare_digit :: proc(a: ^Int, b: DIGIT, allocator := context.allocator) ->
assert_if_nil(a);
context.allocator = allocator;
if err = internal_clear_if_uninitialized(a); err != nil { return 0, err; }
internal_clear_if_uninitialized(a) or_return;
return #force_inline internal_cmp_digit(a, b), nil;
}
@@ -553,7 +552,7 @@ int_compare_magnitude :: proc(a, b: ^Int, allocator := context.allocator) -> (re
assert_if_nil(a, b);
context.allocator = allocator;
if err = internal_clear_if_uninitialized(a, b); err != nil { return 0, err; }
internal_clear_if_uninitialized(a, b) or_return;
return #force_inline internal_cmp_mag(a, b), nil;
}

43
core/math/big/radix.odin
View File

@@ -26,7 +26,7 @@ int_itoa_string :: proc(a: ^Int, radix := i8(-1), zero_terminate := false, alloc
context.allocator = allocator;
a := a; radix := radix;
if err = clear_if_uninitialized(a); err != nil { return "", err; }
clear_if_uninitialized(a) or_return;
/*
Radix defaults to 10.
*/
@@ -39,14 +39,9 @@ int_itoa_string :: proc(a: ^Int, radix := i8(-1), zero_terminate := false, alloc
/*
Calculate the size of the buffer we need, and
*/
size: int;
/*
Exit if calculating the size returned an error.
*/
if size, err = radix_size(a, radix, zero_terminate); err != nil {
return "", err;
}
size := radix_size(a, radix, zero_terminate) or_return;
/*
Allocate the buffer we need.
@@ -70,7 +65,7 @@ int_itoa_cstring :: proc(a: ^Int, radix := i8(-1), allocator := context.allocato
context.allocator = allocator;
a := a; radix := radix;
if err = clear_if_uninitialized(a); err != nil { return "", err; }
clear_if_uninitialized(a) or_return;
/*
Radix defaults to 10.
*/
@@ -104,7 +99,7 @@ int_itoa_cstring :: proc(a: ^Int, radix := i8(-1), allocator := context.allocato
int_itoa_raw :: proc(a: ^Int, radix: i8, buffer: []u8, size := int(-1), zero_terminate := false) -> (written: int, err: Error) {
assert_if_nil(a);
a := a; radix := radix; size := size;
if err = clear_if_uninitialized(a); err != nil { return 0, err; }
clear_if_uninitialized(a) or_return;
/*
Radix defaults to 10.
*/
@@ -117,9 +112,7 @@ int_itoa_raw :: proc(a: ^Int, radix: i8, buffer: []u8, size := int(-1), zero_ter
We weren't given a size. Let's compute it.
*/
if size == -1 {
if size, err = radix_size(a, radix, zero_terminate); err != nil {
return 0, err;
}
size = radix_size(a, radix, zero_terminate) or_return;
}
/*
@@ -256,12 +249,14 @@ int_atoi :: proc(res: ^Int, input: string, radix: i8, allocator := context.alloc
/*
Set the integer to the default of zero.
*/
if err = internal_zero(res); err != nil { return err; }
internal_zero(res) or_return;
/*
We'll interpret an empty string as zero.
*/
if len(input) == 0 { return nil; }
if len(input) == 0 {
return nil;
}
/*
If the leading digit is a minus set the sign to negative.
@@ -301,8 +296,8 @@ int_atoi :: proc(res: ^Int, input: string, radix: i8, allocator := context.alloc
break;
}
if err = internal_mul(res, res, DIGIT(radix)); err != nil { return err; }
if err = internal_add(res, res, DIGIT(y)); err != nil { return err; }
internal_mul(res, res, DIGIT(radix)) or_return;
internal_add(res, res, DIGIT(y)) or_return;
input = input[1:];
}
@@ -333,7 +328,7 @@ radix_size :: proc(a: ^Int, radix: i8, zero_terminate := false, allocator := con
assert_if_nil(a);
if radix < 2 || radix > 64 { return -1, .Invalid_Argument; }
if err = clear_if_uninitialized(a); err != nil { return {}, err; }
clear_if_uninitialized(a) or_return;
if internal_is_zero(a) {
if zero_terminate {
@@ -352,22 +347,22 @@ radix_size :: proc(a: ^Int, radix: i8, zero_terminate := false, allocator := con
digit = a.digit,
};
if size, err = internal_log(t, DIGIT(radix)); err != nil { return {}, err; }
size = internal_log(t, DIGIT(radix)) or_return;
} else {
la, k := &Int{}, &Int{};
defer internal_destroy(la, k);
/* la = floor(log_2(a)) + 1 */
bit_count := internal_count_bits(a);
if err = internal_set(la, bit_count); err != nil { return {}, err; }
internal_set(la, bit_count) or_return;
/* k = floor(2^29/log_2(radix)) + 1 */
lb := _log_bases;
if err = internal_set(k, lb[radix]); err != nil { return {}, err; }
internal_set(k, lb[radix]) or_return;
/* n = floor((la * k) / 2^29) + 1 */
if err = internal_mul(k, la, k); err != nil { return 0, err; }
if err = internal_shr(k, k, _RADIX_SIZE_SCALE); err != nil { return {}, err; }
internal_mul(k, la, k) or_return;
internal_shr(k, k, _RADIX_SIZE_SCALE) or_return;
/* The "+1" here is the "+1" in "floor((la * k) / 2^29) + 1" */
/* n = n + 1 + EOS + sign */
@@ -440,8 +435,8 @@ _itoa_raw_full :: proc(a: ^Int, radix: i8, buffer: []u8, zero_terminate := false
temp, denominator := &Int{}, &Int{};
if err = internal_copy(temp, a); err != nil { return 0, err; }
if err = internal_set(denominator, radix); err != nil { return 0, err; }
internal_copy(temp, a) or_return;
internal_set(denominator, radix) or_return;
available := len(buffer);
if zero_terminate {

28
core/math/big/test.odin
View File

@@ -49,7 +49,7 @@ PyRes :: struct {
if bb.used == 1 {
if err = #force_inline internal_add(sum, aa, bb.digit[0]); err != nil { return PyRes{res=":add:add(sum,a,b):", err=err}; }
} else {
if err = #force_inline internal_add(sum, aa, bb); err != nil { return PyRes{res=":add:add(sum,a,b):", err=err}; }
if err = #force_inline internal_add(sum, aa, bb); err != nil { return PyRes{res=":add:add(sum,a,b):", err=err}; }
}
r: cstring;
@@ -70,7 +70,7 @@ PyRes :: struct {
if bb.used == 1 {
if err = #force_inline internal_sub(sum, aa, bb.digit[0]); err != nil { return PyRes{res=":sub:sub(sum,a,b):", err=err}; }
} else {
if err = #force_inline internal_sub(sum, aa, bb); err != nil { return PyRes{res=":sub:sub(sum,a,b):", err=err}; }
if err = #force_inline internal_sub(sum, aa, bb); err != nil { return PyRes{res=":sub:sub(sum,a,b):", err=err}; }
}
r: cstring;
@@ -88,7 +88,7 @@ PyRes :: struct {
if err = atoi(aa, string(a), 16); err != nil { return PyRes{res=":mul:atoi(a):", err=err}; }
if err = atoi(bb, string(b), 16); err != nil { return PyRes{res=":mul:atoi(b):", err=err}; }
if err = #force_inline internal_mul(product, aa, bb); err != nil { return PyRes{res=":mul:mul(product,a,b):", err=err}; }
if err = #force_inline internal_mul(product, aa, bb); err != nil { return PyRes{res=":mul:mul(product,a,b):", err=err}; }
r: cstring;
r, err = int_itoa_cstring(product, 16, context.temp_allocator);
@@ -104,7 +104,7 @@ PyRes :: struct {
defer internal_destroy(aa, square);
if err = atoi(aa, string(a), 16); err != nil { return PyRes{res=":sqr:atoi(a):", err=err}; }
if err = #force_inline internal_sqr(square, aa); err != nil { return PyRes{res=":sqr:sqr(square,a):", err=err}; }
if err = #force_inline internal_sqr(square, aa); err != nil { return PyRes{res=":sqr:sqr(square,a):", err=err}; }
r: cstring;
r, err = int_itoa_cstring(square, 16, context.temp_allocator);
@@ -124,7 +124,7 @@ PyRes :: struct {
if err = atoi(aa, string(a), 16); err != nil { return PyRes{res=":div:atoi(a):", err=err}; }
if err = atoi(bb, string(b), 16); err != nil { return PyRes{res=":div:atoi(b):", err=err}; }
if err = #force_inline internal_div(quotient, aa, bb); err != nil { return PyRes{res=":div:div(quotient,a,b):", err=err}; }
if err = #force_inline internal_div(quotient, aa, bb); err != nil { return PyRes{res=":div:div(quotient,a,b):", err=err}; }
r: cstring;
r, err = int_itoa_cstring(quotient, 16, context.temp_allocator);
@@ -145,7 +145,7 @@ PyRes :: struct {
defer internal_destroy(aa);
if err = atoi(aa, string(a), 16); err != nil { return PyRes{res=":log:atoi(a):", err=err}; }
if l, err = #force_inline internal_log(aa, base); err != nil { return PyRes{res=":log:log(a, base):", err=err}; }
if l, err = #force_inline internal_log(aa, base); err != nil { return PyRes{res=":log:log(a, base):", err=err}; }
#force_inline internal_zero(aa);
aa.digit[0] = DIGIT(l) & _MASK;
@@ -170,7 +170,7 @@ PyRes :: struct {
defer internal_destroy(dest, bb);
if err = atoi(bb, string(base), 16); err != nil { return PyRes{res=":pow:atoi(base):", err=err}; }
if err = #force_inline internal_pow(dest, bb, power); err != nil { return PyRes{res=":pow:pow(dest, base, power):", err=err}; }
if err = #force_inline internal_pow(dest, bb, power); err != nil { return PyRes{res=":pow:pow(dest, base, power):", err=err}; }
r: cstring;
r, err = int_itoa_cstring(dest, 16, context.temp_allocator);
@@ -189,7 +189,7 @@ PyRes :: struct {
defer internal_destroy(src);
if err = atoi(src, string(source), 16); err != nil { return PyRes{res=":sqrt:atoi(src):", err=err}; }
if err = #force_inline internal_sqrt(src, src); err != nil { return PyRes{res=":sqrt:sqrt(src):", err=err}; }
if err = #force_inline internal_sqrt(src, src); err != nil { return PyRes{res=":sqrt:sqrt(src):", err=err}; }
r: cstring;
r, err = int_itoa_cstring(src, 16, context.temp_allocator);
@@ -208,7 +208,7 @@ PyRes :: struct {
defer internal_destroy(src);
if err = atoi(src, string(source), 16); err != nil { return PyRes{res=":root_n:atoi(src):", err=err}; }
if err = #force_inline internal_root_n(src, src, power); err != nil { return PyRes{res=":root_n:root_n(src):", err=err}; }
if err = #force_inline internal_root_n(src, src, power); err != nil { return PyRes{res=":root_n:root_n(src):", err=err}; }
r: cstring;
r, err = int_itoa_cstring(src, 16, context.temp_allocator);
@@ -227,7 +227,7 @@ PyRes :: struct {
defer internal_destroy(src);
if err = atoi(src, string(source), 16); err != nil { return PyRes{res=":shr_digit:atoi(src):", err=err}; }
if err = #force_inline internal_shr_digit(src, digits); err != nil { return PyRes{res=":shr_digit:shr_digit(src):", err=err}; }
if err = #force_inline internal_shr_digit(src, digits); err != nil { return PyRes{res=":shr_digit:shr_digit(src):", err=err}; }
r: cstring;
r, err = int_itoa_cstring(src, 16, context.temp_allocator);
@@ -246,7 +246,7 @@ PyRes :: struct {
defer internal_destroy(src);
if err = atoi(src, string(source), 16); err != nil { return PyRes{res=":shl_digit:atoi(src):", err=err}; }
if err = #force_inline internal_shl_digit(src, digits); err != nil { return PyRes{res=":shl_digit:shr_digit(src):", err=err}; }
if err = #force_inline internal_shl_digit(src, digits); err != nil { return PyRes{res=":shl_digit:shr_digit(src):", err=err}; }
r: cstring;
r, err = int_itoa_cstring(src, 16, context.temp_allocator);
@@ -265,7 +265,7 @@ PyRes :: struct {
defer internal_destroy(src);
if err = atoi(src, string(source), 16); err != nil { return PyRes{res=":shr:atoi(src):", err=err}; }
if err = #force_inline internal_shr(src, src, bits); err != nil { return PyRes{res=":shr:shr(src, bits):", err=err}; }
if err = #force_inline internal_shr(src, src, bits); err != nil { return PyRes{res=":shr:shr(src, bits):", err=err}; }
r: cstring;
r, err = int_itoa_cstring(src, 16, context.temp_allocator);
@@ -284,7 +284,7 @@ PyRes :: struct {
defer internal_destroy(src);
if err = atoi(src, string(source), 16); err != nil { return PyRes{res=":shr_signed:atoi(src):", err=err}; }
if err = #force_inline internal_shr_signed(src, src, bits); err != nil { return PyRes{res=":shr_signed:shr_signed(src, bits):", err=err}; }
if err = #force_inline internal_shr_signed(src, src, bits); err != nil { return PyRes{res=":shr_signed:shr_signed(src, bits):", err=err}; }
r: cstring;
r, err = int_itoa_cstring(src, 16, context.temp_allocator);
@@ -303,7 +303,7 @@ PyRes :: struct {
defer internal_destroy(src);
if err = atoi(src, string(source), 16); err != nil { return PyRes{res=":shl:atoi(src):", err=err}; }
if err = #force_inline internal_shl(src, src, bits); err != nil { return PyRes{res=":shl:shl(src, bits):", err=err}; }
if err = #force_inline internal_shl(src, src, bits); err != nil { return PyRes{res=":shl:shl(src, bits):", err=err}; }
r: cstring;
r, err = int_itoa_cstring(src, 16, context.temp_allocator);