ed/Odin
1
0
Fork 0
mirror of https://github.com/Ed94/Odin.git synced 2026-08-06 23:58:50 +00:00
Code Issues Packages Projects Releases Wiki Activity

big: More refactoring.

Browse Source
This commit is contained in:
Jeroen van Rijn
2021-08-11 20:59:53 +02:00
parent 07dca737f0
commit d505a05d36
5 changed files with 95 additions and 122 deletions
Download Patch File Download Diff File Expand all files Collapse all files
core/math/big/common.odin
+2 -2
View File
@@ -111,7 +111,7 @@ Flags :: bit_set[Flag; u8];
Error :: enum int { Error :: enum int {
Okay = 0, Okay = 0,
Out_Of_Memory = 1, Out_Of_Memory = 1,
Invalid_Pointer = 2, // Invalid_Pointer = 2,
Invalid_Argument = 3, Invalid_Argument = 3,
Assignment_To_Immutable = 4, Assignment_To_Immutable = 4,
@@ -127,7 +127,7 @@ Error :: enum int {
Error_String :: #partial [Error]string{ Error_String :: #partial [Error]string{
.Out_Of_Memory = "Out of memory", .Out_Of_Memory = "Out of memory",
.Invalid_Pointer = "Invalid pointer", // .Invalid_Pointer = "Invalid pointer",
.Invalid_Argument = "Invalid argument", .Invalid_Argument = "Invalid argument",
.Assignment_To_Immutable = "Assignment to immutable", .Assignment_To_Immutable = "Assignment to immutable",
core/math/big/helpers.odin
+43 -60
View File
@@ -61,7 +61,7 @@ int_copy :: proc(dest, src: ^Int, minimize := false, allocator := context.alloca
Check that `src` is usable and `dest` isn't immutable. Check that `src` is usable and `dest` isn't immutable.
*/ */
assert_if_nil(dest, src); assert_if_nil(dest, src);
if err = #force_inline internal_clear_if_uninitialized(src); err != nil { return err; } if err = #force_inline internal_clear_if_uninitialized(src, allocator); err != nil { return err; }
if err = #force_inline internal_error_if_immutable(dest); err != nil { return err; } if err = #force_inline internal_error_if_immutable(dest); err != nil { return err; }
return #force_inline internal_int_copy(dest, src, minimize, allocator); return #force_inline internal_int_copy(dest, src, minimize, allocator);
@@ -87,7 +87,7 @@ int_abs :: proc(dest, src: ^Int, allocator := context.allocator) -> (err: Error)
Check that `src` is usable and `dest` isn't immutable. Check that `src` is usable and `dest` isn't immutable.
*/ */
assert_if_nil(dest, src); assert_if_nil(dest, src);
if err = #force_inline internal_clear_if_uninitialized(src); err != nil { return err; } if err = #force_inline internal_clear_if_uninitialized(src, allocator); err != nil { return err; }
if err = #force_inline internal_error_if_immutable(dest); err != nil { return err; } if err = #force_inline internal_error_if_immutable(dest); err != nil { return err; }
return #force_inline internal_int_abs(dest, src, allocator); return #force_inline internal_int_abs(dest, src, allocator);
@@ -106,7 +106,7 @@ int_neg :: proc(dest, src: ^Int, allocator := context.allocator) -> (err: Error)
Check that `src` is usable and `dest` isn't immutable. Check that `src` is usable and `dest` isn't immutable.
*/ */
assert_if_nil(dest, src); assert_if_nil(dest, src);
if err = #force_inline internal_clear_if_uninitialized(src); err != nil { return err; } if err = #force_inline internal_clear_if_uninitialized(src, allocator); err != nil { return err; }
if err = #force_inline internal_error_if_immutable(dest); err != nil { return err; } if err = #force_inline internal_error_if_immutable(dest); err != nil { return err; }
return #force_inline internal_int_neg(dest, src, allocator); return #force_inline internal_int_neg(dest, src, allocator);
@@ -116,16 +116,16 @@ neg :: proc { int_neg, };
/* /*
Helpers to extract values from the `Int`. Helpers to extract values from the `Int`.
*/ */
int_bitfield_extract_single :: proc(a: ^Int, offset: int) -> (bit: _WORD, err: Error) { int_bitfield_extract_single :: proc(a: ^Int, offset: int, allocator := context.allocator) -> (bit: _WORD, err: Error) {
return #force_inline int_bitfield_extract(a, offset, 1); return #force_inline int_bitfield_extract(a, offset, 1, allocator);
} }
int_bitfield_extract :: proc(a: ^Int, offset, count: int) -> (res: _WORD, err: Error) { int_bitfield_extract :: proc(a: ^Int, offset, count: int, allocator := context.allocator) -> (res: _WORD, err: Error) {
/* /*
Check that `a` is usable. Check that `a` is usable.
*/ */
assert_if_nil(a); assert_if_nil(a);
if err = #force_inline internal_clear_if_uninitialized(a); err != nil { return 0, err; } if err = #force_inline internal_clear_if_uninitialized(a, allocator); err != nil { return {}, err; }
return #force_inline internal_int_bitfield_extract(a, offset, count); return #force_inline internal_int_bitfield_extract(a, offset, count);
} }
@@ -372,28 +372,13 @@ int_random_digit :: proc(r: ^rnd.Rand = nil) -> (res: DIGIT) {
return 0; // We shouldn't get here. return 0; // We shouldn't get here.
} }
int_rand :: proc(dest: ^Int, bits: int, r: ^rnd.Rand = nil) -> (err: Error) { int_rand :: proc(dest: ^Int, bits: int, r: ^rnd.Rand = nil, allocator := context.allocator) -> (err: Error) {
bits := bits; /*
Check that `a` is usable.
*/
assert_if_nil(dest);
return #force_inline internal_int_rand(dest, bits, r, allocator);
if bits <= 0 { return .Invalid_Argument; }
digits := bits / _DIGIT_BITS;
bits %= _DIGIT_BITS;
if bits > 0 {
digits += 1;
}
if err = grow(dest, digits); err != nil { return err; }
for i := 0; i < digits; i += 1 {
dest.digit[i] = int_random_digit(r) & _MASK;
}
if bits > 0 {
dest.digit[digits - 1] &= ((1 << uint(bits)) - 1);
}
dest.used = digits;
return nil;
} }
rand :: proc { int_rand, }; rand :: proc { int_rand, };
@@ -401,31 +386,28 @@ rand :: proc { int_rand, };
Internal helpers. Internal helpers.
*/ */
assert_initialized :: proc(a: ^Int, loc := #caller_location) { assert_initialized :: proc(a: ^Int, loc := #caller_location) {
assert_if_nil(a);
assert(is_initialized(a), "`Int` was not properly initialized.", loc); assert(is_initialized(a), "`Int` was not properly initialized.", loc);
} }
zero_unused :: proc(dest: ^Int, old_used := -1) { zero_unused :: proc(dest: ^Int, old_used := -1) {
if dest == nil { return; } assert_if_nil(dest);
if ! #force_inline is_initialized(dest) { return; } if ! #force_inline is_initialized(dest) { return; }
internal_zero_unused(dest, old_used); #force_inline internal_zero_unused(dest, old_used);
} }
clear_if_uninitialized_single :: proc(arg: ^Int) -> (err: Error) { clear_if_uninitialized_single :: proc(arg: ^Int, allocator := context.allocator) -> (err: Error) {
if !is_initialized(arg) { assert_if_nil(arg);
if arg == nil { return nil; } return #force_inline internal_clear_if_uninitialized_single(arg, allocator);
return grow(arg, _DEFAULT_DIGIT_COUNT);
}
return err;
} }
clear_if_uninitialized_multi :: proc(args: ..^Int) -> (err: Error) { clear_if_uninitialized_multi :: proc(args: ..^Int, allocator := context.allocator) -> (err: Error) {
for i in args { args := args;
if i == nil { continue; } assert_if_nil(..args);
if !is_initialized(i) {
e := grow(i, _DEFAULT_DIGIT_COUNT); for i in &args {
if e != nil { err = e; } if err = #force_inline internal_clear_if_uninitialized_single(i, allocator); err != nil { return nil; }
}
} }
return err; return err;
} }
@@ -448,28 +430,33 @@ error_if_immutable :: proc {error_if_immutable_single, error_if_immutable_multi,
Allocates several `Int`s at once. Allocates several `Int`s at once.
*/ */
int_init_multi :: proc(integers: ..^Int) -> (err: Error) { int_init_multi :: proc(integers: ..^Int) -> (err: Error) {
assert_if_nil(..integers);
integers := integers; integers := integers;
for a in &integers { for a in &integers {
if err = clear(a); err != nil { return err; } if err = #force_inline internal_clear(a); err != nil { return err; }
} }
return nil; return nil;
} }
init_multi :: proc { int_init_multi, }; init_multi :: proc { int_init_multi, };
_copy_digits :: proc(dest, src: ^Int, digits: int) -> (err: Error) { _copy_digits :: proc(dest, src: ^Int, digits: int, allocator := context.allocator) -> (err: Error) {
digits := digits; digits := digits;
if err = clear_if_uninitialized(src); err != nil { return err; } /*
if err = clear_if_uninitialized(dest); err != nil { return err; } Check that `src` is usable and `dest` isn't immutable.
*/
assert_if_nil(dest, src);
if err = #force_inline internal_clear_if_uninitialized(src, allocator); err != nil { return err; }
if err = #force_inline internal_error_if_immutable(dest); err != nil { return err; }
/* /*
If dest == src, do nothing If dest == src, do nothing
*/ */
if (dest == src) { if (dest == src) { return nil; }
return nil;
}
digits = min(digits, len(src.digit), len(dest.digit)); digits = min(digits, len(src.digit), len(dest.digit));
mem.copy_non_overlapping(&dest.digit[0], &src.digit[0], size_of(DIGIT) * digits); #force_inline mem.copy_non_overlapping(&dest.digit[0], &src.digit[0], size_of(DIGIT) * digits);
return nil; return nil;
} }
@@ -479,10 +466,10 @@ _copy_digits :: proc(dest, src: ^Int, digits: int) -> (err: Error) {
This is used to ensure that leading zero digits are trimmed and the leading "used" digit will be non-zero. This is used to ensure that leading zero digits are trimmed and the leading "used" digit will be non-zero.
Typically very fast. Also fixes the sign if there are no more leading digits. Typically very fast. Also fixes the sign if there are no more leading digits.
*/ */
clamp :: proc(a: ^Int) -> (err: Error) { clamp :: proc(a: ^Int, allocator := context.allocator) -> (err: Error) {
if err = clear_if_uninitialized(a); err != nil { assert_if_nil(a);
return err; if err = #force_inline internal_clear_if_uninitialized(a, allocator); err != nil { return err; }
}
for a.used > 0 && a.digit[a.used - 1] == 0 { for a.used > 0 && a.digit[a.used - 1] == 0 {
a.used -= 1; a.used -= 1;
} }
@@ -493,7 +480,6 @@ clamp :: proc(a: ^Int) -> (err: Error) {
return nil; return nil;
} }
/* /*
Initialize constants. Initialize constants.
*/ */
@@ -528,9 +514,6 @@ assert_if_nil :: #force_inline proc(integers: ..^Int, loc := #caller_location) {
integers := integers; integers := integers;
for i in &integers { for i in &integers {
if i == nil { assert(i != nil, "(nil)", loc);
msg := fmt.tprintf("%v(nil)", loc.procedure);
assert(false, msg, loc);
}
} }
} }
core/math/big/internal.odin
+7 -21
View File
@@ -1850,10 +1850,6 @@ internal_int_bitfield_extract :: proc(a: ^Int, offset, count: int) -> (res: _WOR
Assumes `a` not to be `nil`, and to have already been initialized. Assumes `a` not to be `nil`, and to have already been initialized.
*/ */
internal_int_shrink :: proc(a: ^Int) -> (err: Error) { internal_int_shrink :: proc(a: ^Int) -> (err: Error) {
if a == nil {
return .Invalid_Pointer;
}
needed := max(_MIN_DIGIT_COUNT, a.used); needed := max(_MIN_DIGIT_COUNT, a.used);
if a.used != needed { if a.used != needed {
@@ -1864,9 +1860,6 @@ internal_int_shrink :: proc(a: ^Int) -> (err: Error) {
internal_shrink :: proc { internal_int_shrink, }; internal_shrink :: proc { internal_int_shrink, };
internal_int_grow :: proc(a: ^Int, digits: int, allow_shrink := false, allocator := context.allocator) -> (err: Error) { internal_int_grow :: proc(a: ^Int, digits: int, allow_shrink := false, allocator := context.allocator) -> (err: Error) {
if a == nil {
return .Invalid_Pointer;
}
raw := transmute(mem.Raw_Dynamic_Array)a.digit; raw := transmute(mem.Raw_Dynamic_Array)a.digit;
/* /*
@@ -1899,12 +1892,9 @@ internal_grow :: proc { internal_int_grow, };
/* /*
Clear `Int` and resize it to the default size. Clear `Int` and resize it to the default size.
Assumes `a` not to be `nil`.
*/ */
internal_int_clear :: proc(a: ^Int, minimize := false, allocator := context.allocator) -> (err: Error) { internal_int_clear :: proc(a: ^Int, minimize := false, allocator := context.allocator) -> (err: Error) {
if a == nil {
return .Invalid_Pointer;
}
raw := transmute(mem.Raw_Dynamic_Array)a.digit; raw := transmute(mem.Raw_Dynamic_Array)a.digit;
if raw.cap != 0 { if raw.cap != 0 {
mem.zero_slice(a.digit[:a.used]); mem.zero_slice(a.digit[:a.used]);
@@ -1912,7 +1902,7 @@ internal_int_clear :: proc(a: ^Int, minimize := false, allocator := context.allo
a.sign = .Zero_or_Positive; a.sign = .Zero_or_Positive;
a.used = 0; a.used = 0;
return grow(a, a.used, minimize, allocator); return #force_inline internal_grow(a, a.used, minimize, allocator);
} }
internal_clear :: proc { internal_int_clear, }; internal_clear :: proc { internal_int_clear, };
internal_zero :: internal_clear; internal_zero :: internal_clear;
@@ -1967,9 +1957,7 @@ internal_int_power_of_two :: proc(a: ^Int, power: int, allocator := context.allo
/* /*
Check that `a` is usable. Check that `a` is usable.
*/ */
if a == nil { assert_if_nil(a);
return .Invalid_Pointer;
}
if power < 0 || power > _MAX_BIT_COUNT { if power < 0 || power > _MAX_BIT_COUNT {
return .Invalid_Argument; return .Invalid_Argument;
@@ -2142,7 +2130,7 @@ internal_int_random_digit :: proc(r: ^rnd.Rand = nil) -> (res: DIGIT) {
return 0; // We shouldn't get here. return 0; // We shouldn't get here.
} }
internal_int_rand :: proc(dest: ^Int, bits: int, r: ^rnd.Rand = nil) -> (err: Error) { internal_int_rand :: proc(dest: ^Int, bits: int, r: ^rnd.Rand = nil, allocator := context.allocator) -> (err: Error) {
bits := bits; bits := bits;
if bits <= 0 { return .Invalid_Argument; } if bits <= 0 { return .Invalid_Argument; }
@@ -2154,7 +2142,7 @@ internal_int_rand :: proc(dest: ^Int, bits: int, r: ^rnd.Rand = nil) -> (err: Er
digits += 1; digits += 1;
} }
if err = grow(dest, digits); err != nil { return err; } if err = grow(dest, digits, true, allocator); err != nil { return err; }
for i := 0; i < digits; i += 1 { for i := 0; i < digits; i += 1 {
dest.digit[i] = int_random_digit(r) & _MASK; dest.digit[i] = int_random_digit(r) & _MASK;
@@ -2176,17 +2164,15 @@ internal_assert_initialized :: proc(a: ^Int, loc := #caller_location) {
internal_clear_if_uninitialized_single :: proc(arg: ^Int, allocator := context.allocator) -> (err: Error) { internal_clear_if_uninitialized_single :: proc(arg: ^Int, allocator := context.allocator) -> (err: Error) {
if !internal_is_initialized(arg) { if !internal_is_initialized(arg) {
if arg == nil { return nil; } return #force_inline internal_grow(arg, _DEFAULT_DIGIT_COUNT, true, allocator);
return internal_grow(arg, _DEFAULT_DIGIT_COUNT, true, allocator);
} }
return err; return err;
} }
internal_clear_if_uninitialized_multi :: proc(args: ..^Int, allocator := context.allocator) -> (err: Error) { internal_clear_if_uninitialized_multi :: proc(args: ..^Int, allocator := context.allocator) -> (err: Error) {
for i in args { for i in args {
if i == nil { continue; }
if !internal_is_initialized(i) { if !internal_is_initialized(i) {
e := internal_grow(i, _DEFAULT_DIGIT_COUNT, true, allocator); e := #force_inline internal_grow(i, _DEFAULT_DIGIT_COUNT, true, allocator);
if e != nil { err = e; } if e != nil { err = e; }
} }
} }
core/math/big/logical.odin
+1
View File
@@ -24,6 +24,7 @@ import "core:mem"
2's complement `and`, returns `dest = a & b;` 2's complement `and`, returns `dest = a & b;`
*/ */
int_and :: proc(dest, a, b: ^Int) -> (err: Error) { int_and :: proc(dest, a, b: ^Int) -> (err: Error) {
assert_if_nil(dest, a, b);
if err = clear_if_uninitialized(a, b); err != nil { return err; } if err = clear_if_uninitialized(a, b); err != nil { return err; }
used := max(a.used, b.used) + 1; used := max(a.used, b.used) + 1;
core/math/big/public.odin
+38 -35
View File
@@ -21,7 +21,7 @@ package big
High-level addition. Handles sign. High-level addition. Handles sign.
*/ */
int_add :: proc(dest, a, b: ^Int, allocator := context.allocator) -> (err: Error) { int_add :: proc(dest, a, b: ^Int, allocator := context.allocator) -> (err: Error) {
if dest == nil || a == nil || b == nil { return .Invalid_Pointer; } assert_if_nil(dest, a, b);
if err = clear_if_uninitialized(dest, a, b); err != nil { return err; } if err = clear_if_uninitialized(dest, a, b); err != nil { return err; }
/* /*
All parameters have been initialized. All parameters have been initialized.
@@ -36,7 +36,7 @@ int_add :: proc(dest, a, b: ^Int, allocator := context.allocator) -> (err: Error
dest = a + digit; dest = a + digit;
*/ */
int_add_digit :: proc(dest, a: ^Int, digit: DIGIT, allocator := context.allocator) -> (err: Error) { int_add_digit :: proc(dest, a: ^Int, digit: DIGIT, allocator := context.allocator) -> (err: Error) {
if dest == nil || a == nil { return .Invalid_Pointer; } assert_if_nil(dest, a);
if err = clear_if_uninitialized(a); err != nil { return err; } if err = clear_if_uninitialized(a); err != nil { return err; }
/* /*
Grow destination as required. Grow destination as required.
@@ -53,7 +53,7 @@ int_add_digit :: proc(dest, a: ^Int, digit: DIGIT, allocator := context.allocato
High-level subtraction, dest = number - decrease. Handles signs. High-level subtraction, dest = number - decrease. Handles signs.
*/ */
int_sub :: proc(dest, number, decrease: ^Int, allocator := context.allocator) -> (err: Error) { int_sub :: proc(dest, number, decrease: ^Int, allocator := context.allocator) -> (err: Error) {
if dest == nil || number == nil || decrease == nil { return .Invalid_Pointer; } assert_if_nil(dest, number, decrease);
if err = clear_if_uninitialized(dest, number, decrease); err != nil { return err; } if err = clear_if_uninitialized(dest, number, decrease); err != nil { return err; }
/* /*
All parameters have been initialized. All parameters have been initialized.
@@ -68,7 +68,7 @@ int_sub :: proc(dest, number, decrease: ^Int, allocator := context.allocator) ->
dest = a - digit; dest = a - digit;
*/ */
int_sub_digit :: proc(dest, a: ^Int, digit: DIGIT, allocator := context.allocator) -> (err: Error) { int_sub_digit :: proc(dest, a: ^Int, digit: DIGIT, allocator := context.allocator) -> (err: Error) {
if dest == nil || a == nil { return .Invalid_Pointer; } assert_if_nil(dest, a);
if err = clear_if_uninitialized(a); err != nil { return err; } if err = clear_if_uninitialized(a); err != nil { return err; }
/* /*
Grow destination as required. Grow destination as required.
@@ -86,7 +86,7 @@ int_sub_digit :: proc(dest, a: ^Int, digit: DIGIT, allocator := context.allocato
dest = src >> 1 dest = src >> 1
*/ */
int_halve :: proc(dest, src: ^Int) -> (err: Error) { int_halve :: proc(dest, src: ^Int) -> (err: Error) {
if dest == nil || src == nil { return .Invalid_Pointer; } assert_if_nil(dest, src);
if err = clear_if_uninitialized(dest, src); err != nil { return err; } if err = clear_if_uninitialized(dest, src); err != nil { return err; }
/* /*
Grow destination as required. Grow destination as required.
@@ -103,7 +103,7 @@ shr1 :: halve;
dest = src << 1 dest = src << 1
*/ */
int_double :: proc(dest, src: ^Int) -> (err: Error) { int_double :: proc(dest, src: ^Int) -> (err: Error) {
if dest == nil || src == nil { return .Invalid_Pointer; } assert_if_nil(dest, src);
if err = clear_if_uninitialized(dest, src); err != nil { return err; } if err = clear_if_uninitialized(dest, src); err != nil { return err; }
/* /*
Grow destination as required. Grow destination as required.
@@ -119,7 +119,7 @@ shl1 :: double;
Multiply by a DIGIT. Multiply by a DIGIT.
*/ */
int_mul_digit :: proc(dest, src: ^Int, multiplier: DIGIT, allocator := context.allocator) -> (err: Error) { int_mul_digit :: proc(dest, src: ^Int, multiplier: DIGIT, allocator := context.allocator) -> (err: Error) {
if dest == nil || src == nil { return .Invalid_Pointer; } assert_if_nil(dest, src);
if err = clear_if_uninitialized(src, dest); err != nil { return err; } if err = clear_if_uninitialized(src, dest); err != nil { return err; }
return #force_inline internal_int_mul_digit(dest, src, multiplier, allocator); return #force_inline internal_int_mul_digit(dest, src, multiplier, allocator);
@@ -129,7 +129,7 @@ int_mul_digit :: proc(dest, src: ^Int, multiplier: DIGIT, allocator := context.a
High level multiplication (handles sign). High level multiplication (handles sign).
*/ */
int_mul :: proc(dest, src, multiplier: ^Int, allocator := context.allocator) -> (err: Error) { int_mul :: proc(dest, src, multiplier: ^Int, allocator := context.allocator) -> (err: Error) {
if dest == nil || src == nil || multiplier == nil { return .Invalid_Pointer; } assert_if_nil(dest, src, multiplier);
if err = clear_if_uninitialized(dest, src, multiplier); err != nil { return err; } if err = clear_if_uninitialized(dest, src, multiplier); err != nil { return err; }
return #force_inline internal_int_mul(dest, src, multiplier, allocator); return #force_inline internal_int_mul(dest, src, multiplier, allocator);
@@ -154,7 +154,7 @@ int_divmod :: proc(quotient, remainder, numerator, denominator: ^Int) -> (err: E
} }
int_divmod_digit :: proc(quotient, numerator: ^Int, denominator: DIGIT) -> (remainder: DIGIT, err: Error) { int_divmod_digit :: proc(quotient, numerator: ^Int, denominator: DIGIT) -> (remainder: DIGIT, err: Error) {
if quotient == nil { return 0, .Invalid_Pointer; }; assert_if_nil(quotient, numerator);
if err = clear_if_uninitialized(numerator); err != nil { return 0, err; } if err = clear_if_uninitialized(numerator); err != nil { return 0, err; }
return #force_inline internal_divmod(quotient, numerator, denominator); return #force_inline internal_divmod(quotient, numerator, denominator);
@@ -162,14 +162,14 @@ int_divmod_digit :: proc(quotient, numerator: ^Int, denominator: DIGIT) -> (rema
divmod :: proc{ int_divmod, int_divmod_digit, }; divmod :: proc{ int_divmod, int_divmod_digit, };
int_div :: proc(quotient, numerator, denominator: ^Int) -> (err: Error) { int_div :: proc(quotient, numerator, denominator: ^Int) -> (err: Error) {
if quotient == nil { return .Invalid_Pointer; }; assert_if_nil(quotient, numerator, denominator);
if err = clear_if_uninitialized(numerator, denominator); err != nil { return err; } if err = clear_if_uninitialized(numerator, denominator); err != nil { return err; }
return #force_inline internal_divmod(quotient, nil, numerator, denominator); return #force_inline internal_divmod(quotient, nil, numerator, denominator);
} }
int_div_digit :: proc(quotient, numerator: ^Int, denominator: DIGIT) -> (err: Error) { int_div_digit :: proc(quotient, numerator: ^Int, denominator: DIGIT) -> (err: Error) {
if quotient == nil { return .Invalid_Pointer; }; assert_if_nil(quotient, numerator);
if err = clear_if_uninitialized(numerator); err != nil { return err; } if err = clear_if_uninitialized(numerator); err != nil { return err; }
remainder: DIGIT; remainder: DIGIT;
@@ -184,7 +184,7 @@ div :: proc { int_div, int_div_digit, };
denominator < remainder <= 0 if denominator < 0 denominator < remainder <= 0 if denominator < 0
*/ */
int_mod :: proc(remainder, numerator, denominator: ^Int) -> (err: Error) { int_mod :: proc(remainder, numerator, denominator: ^Int) -> (err: Error) {
if remainder == nil { return .Invalid_Pointer; }; assert_if_nil(remainder, numerator, denominator);
if err = clear_if_uninitialized(numerator, denominator); err != nil { return err; } if err = clear_if_uninitialized(numerator, denominator); err != nil { return err; }
return #force_inline internal_int_mod(remainder, numerator, denominator); return #force_inline internal_int_mod(remainder, numerator, denominator);
@@ -200,7 +200,7 @@ mod :: proc { int_mod, int_mod_digit, };
remainder = (number + addend) % modulus. remainder = (number + addend) % modulus.
*/ */
int_addmod :: proc(remainder, number, addend, modulus: ^Int) -> (err: Error) { int_addmod :: proc(remainder, number, addend, modulus: ^Int) -> (err: Error) {
if remainder == nil { return .Invalid_Pointer; }; assert_if_nil(remainder, number, addend);
if err = clear_if_uninitialized(number, addend, modulus); err != nil { return err; } if err = clear_if_uninitialized(number, addend, modulus); err != nil { return err; }
return #force_inline internal_addmod(remainder, number, addend, modulus); return #force_inline internal_addmod(remainder, number, addend, modulus);
@@ -211,7 +211,7 @@ addmod :: proc { int_addmod, };
remainder = (number - decrease) % modulus. remainder = (number - decrease) % modulus.
*/ */
int_submod :: proc(remainder, number, decrease, modulus: ^Int) -> (err: Error) { int_submod :: proc(remainder, number, decrease, modulus: ^Int) -> (err: Error) {
if remainder == nil { return .Invalid_Pointer; }; assert_if_nil(remainder, number, decrease);
if err = clear_if_uninitialized(number, decrease, modulus); err != nil { return err; } if err = clear_if_uninitialized(number, decrease, modulus); err != nil { return err; }
return #force_inline internal_submod(remainder, number, decrease, modulus); return #force_inline internal_submod(remainder, number, decrease, modulus);
@@ -222,7 +222,7 @@ submod :: proc { int_submod, };
remainder = (number * multiplicand) % modulus. remainder = (number * multiplicand) % modulus.
*/ */
int_mulmod :: proc(remainder, number, multiplicand, modulus: ^Int) -> (err: Error) { int_mulmod :: proc(remainder, number, multiplicand, modulus: ^Int) -> (err: Error) {
if remainder == nil { return .Invalid_Pointer; }; assert_if_nil(remainder, number, multiplicand);
if err = clear_if_uninitialized(number, multiplicand, modulus); err != nil { return err; } if err = clear_if_uninitialized(number, multiplicand, modulus); err != nil { return err; }
return #force_inline internal_mulmod(remainder, number, multiplicand, modulus); return #force_inline internal_mulmod(remainder, number, multiplicand, modulus);
@@ -233,7 +233,7 @@ mulmod :: proc { int_mulmod, };
remainder = (number * number) % modulus. remainder = (number * number) % modulus.
*/ */
int_sqrmod :: proc(remainder, number, modulus: ^Int) -> (err: Error) { int_sqrmod :: proc(remainder, number, modulus: ^Int) -> (err: Error) {
if remainder == nil { return .Invalid_Pointer; }; assert_if_nil(remainder, number, modulus);
if err = clear_if_uninitialized(number, modulus); err != nil { return err; } if err = clear_if_uninitialized(number, modulus); err != nil { return err; }
return #force_inline internal_sqrmod(remainder, number, modulus); return #force_inline internal_sqrmod(remainder, number, modulus);
@@ -243,7 +243,7 @@ sqrmod :: proc { int_sqrmod, };
int_factorial :: proc(res: ^Int, n: int) -> (err: Error) { int_factorial :: proc(res: ^Int, n: int) -> (err: Error) {
if n < 0 || n > FACTORIAL_MAX_N { return .Invalid_Argument; } if n < 0 || n > FACTORIAL_MAX_N { return .Invalid_Argument; }
if res == nil { return .Invalid_Pointer; } assert_if_nil(res);
return #force_inline internal_int_factorial(res, n); return #force_inline internal_int_factorial(res, n);
} }
@@ -266,7 +266,7 @@ factorial :: proc { int_factorial, };
*/ */
int_choose_digit :: proc(res: ^Int, n, k: int) -> (err: Error) { int_choose_digit :: proc(res: ^Int, n, k: int) -> (err: Error) {
if res == nil { return .Invalid_Pointer; } assert_if_nil(res);
if n < 0 || n > FACTORIAL_MAX_N { return .Invalid_Argument; } if n < 0 || n > FACTORIAL_MAX_N { return .Invalid_Argument; }
if k > n { return zero(res); } if k > n { return zero(res); }
@@ -291,10 +291,12 @@ choose :: proc { int_choose_digit, };
/* /*
Function computing both GCD and (if target isn't `nil`) also LCM. Function computing both GCD and (if target isn't `nil`) also LCM.
*/ */
int_gcd_lcm :: proc(res_gcd, res_lcm, a, b: ^Int) -> (err: Error) { int_gcd_lcm :: proc(res_gcd, res_lcm, a, b: ^Int, allocator := context.allocator) -> (err: Error) {
if res_gcd == nil && res_lcm == nil { return nil; } if res_gcd == nil && res_lcm == nil { return nil; }
if err = clear_if_uninitialized(res_gcd, res_lcm, a, b); err != nil { return err; } assert_if_nil(a, b);
if err = clear_if_uninitialized(a, allocator); err != nil { return err; }
if err = clear_if_uninitialized(b, allocator); err != nil { return err; }
return #force_inline internal_int_gcd_lcm(res_gcd, res_lcm, a, b); return #force_inline internal_int_gcd_lcm(res_gcd, res_lcm, a, b);
} }
gcd_lcm :: proc { int_gcd_lcm, }; gcd_lcm :: proc { int_gcd_lcm, };
@@ -319,7 +321,8 @@ lcm :: proc { int_lcm, };
remainder = numerator % (1 << bits) remainder = numerator % (1 << bits)
*/ */
int_mod_bits :: proc(remainder, numerator: ^Int, bits: int) -> (err: Error) { int_mod_bits :: proc(remainder, numerator: ^Int, bits: int) -> (err: Error) {
if remainder == nil || numerator == nil { return .Invalid_Pointer; } assert_if_nil(remainder, numerator);
if err = clear_if_uninitialized(remainder, numerator); err != nil { return err; } if err = clear_if_uninitialized(remainder, numerator); err != nil { return err; }
if bits < 0 { return .Invalid_Argument; } if bits < 0 { return .Invalid_Argument; }
@@ -333,7 +336,7 @@ mod_bits :: proc { int_mod_bits, };
Logs and roots and such. Logs and roots and such.
*/ */
int_log :: proc(a: ^Int, base: DIGIT) -> (res: int, err: Error) { int_log :: proc(a: ^Int, base: DIGIT) -> (res: int, err: Error) {
if a == nil { return 0, .Invalid_Pointer; } assert_if_nil(a);
if err = clear_if_uninitialized(a); err != nil { return 0, err; } if err = clear_if_uninitialized(a); err != nil { return 0, err; }
return #force_inline internal_int_log(a, base); return #force_inline internal_int_log(a, base);
@@ -348,7 +351,7 @@ log :: proc { int_log, digit_log, };
Calculate `dest = base^power` using a square-multiply algorithm. Calculate `dest = base^power` using a square-multiply algorithm.
*/ */
int_pow :: proc(dest, base: ^Int, power: int) -> (err: Error) { int_pow :: proc(dest, base: ^Int, power: int) -> (err: Error) {
if dest == nil || base == nil { return .Invalid_Pointer; } assert_if_nil(dest, base);
if err = clear_if_uninitialized(dest, base); err != nil { return err; } if err = clear_if_uninitialized(dest, base); err != nil { return err; }
return #force_inline internal_int_pow(dest, base, power); return #force_inline internal_int_pow(dest, base, power);
@@ -358,7 +361,7 @@ int_pow :: proc(dest, base: ^Int, power: int) -> (err: Error) {
Calculate `dest = base^power` using a square-multiply algorithm. Calculate `dest = base^power` using a square-multiply algorithm.
*/ */
int_pow_int :: proc(dest: ^Int, base, power: int) -> (err: Error) { int_pow_int :: proc(dest: ^Int, base, power: int) -> (err: Error) {
if dest == nil { return .Invalid_Pointer; } assert_if_nil(dest);
return #force_inline internal_pow(dest, base, power); return #force_inline internal_pow(dest, base, power);
} }
@@ -374,7 +377,7 @@ small_pow :: proc(base: _WORD, exponent: _WORD) -> (result: _WORD) {
This function is less generic than `root_n`, simpler and faster. This function is less generic than `root_n`, simpler and faster.
*/ */
int_sqrt :: proc(dest, src: ^Int) -> (err: Error) { int_sqrt :: proc(dest, src: ^Int) -> (err: Error) {
if dest == nil || src == nil { return .Invalid_Pointer; } assert_if_nil(dest, src);
if err = clear_if_uninitialized(dest, src); err != nil { return err; } if err = clear_if_uninitialized(dest, src); err != nil { return err; }
return #force_inline internal_int_sqrt(dest, src); return #force_inline internal_int_sqrt(dest, src);
@@ -395,7 +398,7 @@ int_root_n :: proc(dest, src: ^Int, n: int) -> (err: Error) {
*/ */
if n == 2 { return sqrt(dest, src); } if n == 2 { return sqrt(dest, src); }
if dest == nil || src == nil { return .Invalid_Pointer; } assert_if_nil(dest, src);
/* /*
Initialize dest + src if needed. Initialize dest + src if needed.
*/ */
@@ -416,35 +419,35 @@ int_is_initialized :: proc(a: ^Int) -> bool {
} }
int_is_zero :: proc(a: ^Int) -> (zero: bool, err: Error) { int_is_zero :: proc(a: ^Int) -> (zero: bool, err: Error) {
if a == nil { return false, .Invalid_Pointer; } assert_if_nil(a);
if err = clear_if_uninitialized(a); err != nil { return false, err; } if err = clear_if_uninitialized(a); err != nil { return false, err; }
return #force_inline internal_is_zero(a), nil; return #force_inline internal_is_zero(a), nil;
} }
int_is_positive :: proc(a: ^Int) -> (positive: bool, err: Error) { int_is_positive :: proc(a: ^Int) -> (positive: bool, err: Error) {
if a == nil { return false, .Invalid_Pointer; } assert_if_nil(a);
if err = clear_if_uninitialized(a); err != nil { return false, err; } if err = clear_if_uninitialized(a); err != nil { return false, err; }
return #force_inline internal_is_positive(a), nil; return #force_inline internal_is_positive(a), nil;
} }
int_is_negative :: proc(a: ^Int) -> (negative: bool, err: Error) { int_is_negative :: proc(a: ^Int) -> (negative: bool, err: Error) {
if a == nil { return false, .Invalid_Pointer; } assert_if_nil(a);
if err = clear_if_uninitialized(a); err != nil { return false, err; } if err = clear_if_uninitialized(a); err != nil { return false, err; }
return #force_inline internal_is_negative(a), nil; return #force_inline internal_is_negative(a), nil;
} }
int_is_even :: proc(a: ^Int) -> (even: bool, err: Error) { int_is_even :: proc(a: ^Int) -> (even: bool, err: Error) {
if a == nil { return false, .Invalid_Pointer; } assert_if_nil(a);
if err = clear_if_uninitialized(a); err != nil { return false, err; } if err = clear_if_uninitialized(a); err != nil { return false, err; }
return #force_inline internal_is_even(a), nil; return #force_inline internal_is_even(a), nil;
} }
int_is_odd :: proc(a: ^Int) -> (odd: bool, err: Error) { int_is_odd :: proc(a: ^Int) -> (odd: bool, err: Error) {
if a == nil { return false, .Invalid_Pointer; } assert_if_nil(a);
if err = clear_if_uninitialized(a); err != nil { return false, err; } if err = clear_if_uninitialized(a); err != nil { return false, err; }
return #force_inline internal_is_odd(a), nil; return #force_inline internal_is_odd(a), nil;
@@ -455,7 +458,7 @@ platform_int_is_power_of_two :: #force_inline proc(a: int) -> bool {
} }
int_is_power_of_two :: proc(a: ^Int) -> (res: bool, err: Error) { int_is_power_of_two :: proc(a: ^Int) -> (res: bool, err: Error) {
if a == nil { return false, .Invalid_Pointer; } assert_if_nil(a);
if err = clear_if_uninitialized(a); err != nil { return false, err; } if err = clear_if_uninitialized(a); err != nil { return false, err; }
return #force_inline internal_is_power_of_two(a), nil; return #force_inline internal_is_power_of_two(a), nil;
@@ -465,7 +468,7 @@ int_is_power_of_two :: proc(a: ^Int) -> (res: bool, err: Error) {
Compare two `Int`s, signed. Compare two `Int`s, signed.
*/ */
int_compare :: proc(a, b: ^Int) -> (comparison: int, err: Error) { int_compare :: proc(a, b: ^Int) -> (comparison: int, err: Error) {
if a == nil || b == nil { return 0, .Invalid_Pointer; } assert_if_nil(a, b);
if err = clear_if_uninitialized(a, b); err != nil { return 0, err; } if err = clear_if_uninitialized(a, b); err != nil { return 0, err; }
return #force_inline internal_cmp(a, b), nil; return #force_inline internal_cmp(a, b), nil;
@@ -476,7 +479,7 @@ int_cmp :: int_compare;
Compare an `Int` to an unsigned number upto the size of the backing type. Compare an `Int` to an unsigned number upto the size of the backing type.
*/ */
int_compare_digit :: proc(a: ^Int, b: DIGIT) -> (comparison: int, err: Error) { int_compare_digit :: proc(a: ^Int, b: DIGIT) -> (comparison: int, err: Error) {
if a == nil { return 0, .Invalid_Pointer; } assert_if_nil(a);
if err = clear_if_uninitialized(a); err != nil { return 0, err; } if err = clear_if_uninitialized(a); err != nil { return 0, err; }
return #force_inline internal_cmp_digit(a, b), nil; return #force_inline internal_cmp_digit(a, b), nil;
@@ -487,7 +490,7 @@ int_cmp_digit :: int_compare_digit;
Compare the magnitude of two `Int`s, unsigned. Compare the magnitude of two `Int`s, unsigned.
*/ */
int_compare_magnitude :: proc(a, b: ^Int) -> (res: int, err: Error) { int_compare_magnitude :: proc(a, b: ^Int) -> (res: int, err: Error) {
if a == nil || b == nil { return 0, .Invalid_Pointer; } assert_if_nil(a, b);
if err = clear_if_uninitialized(a, b); err != nil { return 0, err; } if err = clear_if_uninitialized(a, b); err != nil { return 0, err; }
return #force_inline internal_cmp_mag(a, b), nil; return #force_inline internal_cmp_mag(a, b), nil;