mirror of
https://github.com/ziglang/zig.git
synced 2024-12-04 02:48:50 +00:00
8766821157
Now there are 3 types:
* std.math.big.int.Const
- the memory is immutable, only stores limbs and is_positive
- all methods operating on constant data go here
* std.math.big.int.Mutable
- the memory is mutable, stores capacity in addition to limbs and
is_positive
- methods here have some Mutable parameters and some Const
parameters. These methods expect callers to pre-calculate the
amount of resources required, and asserts that the resources are
available.
* std.math.big.int.Managed
- the memory is mutable and additionally stores an allocator.
- methods here perform the resource calculations for the programmer.
- this is the high level abstraction from before
Each of these 3 types can be converted to the other ones.
You can see the use case for this in the self-hosted compiler, where we
only store limbs, and construct the big ints as needed.
This gets rid of the hack where the allocator was optional and the
notion of "fixed" versions of the struct. Such things are now modeled
with the `big.int.Const` type.
25 lines
693 B
Zig
25 lines
693 B
Zig
const std = @import("../std.zig");
|
|
const assert = std.debug.assert;
|
|
|
|
pub const Rational = @import("big/rational.zig").Rational;
|
|
pub const int = @import("big/int.zig");
|
|
pub const Limb = usize;
|
|
pub const DoubleLimb = std.meta.IntType(false, 2 * Limb.bit_count);
|
|
pub const SignedDoubleLimb = std.meta.IntType(true, DoubleLimb.bit_count);
|
|
pub const Log2Limb = std.math.Log2Int(Limb);
|
|
|
|
comptime {
|
|
assert(std.math.floorPowerOfTwo(usize, Limb.bit_count) == Limb.bit_count);
|
|
assert(Limb.bit_count <= 64); // u128 set is unsupported
|
|
assert(Limb.is_signed == false);
|
|
}
|
|
|
|
test "" {
|
|
_ = int;
|
|
_ = Rational;
|
|
_ = Limb;
|
|
_ = DoubleLimb;
|
|
_ = SignedDoubleLimb;
|
|
_ = Log2Limb;
|
|
}
|