use @"llvm.sadd.with.overflow.i8"[(I8, Bool)](a: I8, b: I8)
use @"llvm.sadd.with.overflow.i16"[(I16, Bool)](a: I16, b: I16)
use @"llvm.sadd.with.overflow.i32"[(I32, Bool)](a: I32, b: I32)
use @"llvm.sadd.with.overflow.i64"[(I64, Bool)](a: I64, b: I64)
use @"llvm.sadd.with.overflow.i128"[(I128, Bool)](a: I128, b: I128)
use @"llvm.ssub.with.overflow.i8"[(I8, Bool)](a: I8, b: I8)
use @"llvm.ssub.with.overflow.i16"[(I16, Bool)](a: I16, b: I16)
use @"llvm.ssub.with.overflow.i32"[(I32, Bool)](a: I32, b: I32)
use @"llvm.ssub.with.overflow.i64"[(I64, Bool)](a: I64, b: I64)
use @"llvm.ssub.with.overflow.i128"[(I128, Bool)](a: I128, b: I128)
use @"llvm.smul.with.overflow.i8"[(I8, Bool)](a: I8, b: I8)
use @"llvm.smul.with.overflow.i16"[(I16, Bool)](a: I16, b: I16)
use @"llvm.smul.with.overflow.i32"[(I32, Bool)](a: I32, b: I32)
use @"llvm.smul.with.overflow.i64"[(I64, Bool)](a: I64, b: I64)
primitive I8 is SignedInteger[I8, U8]
new create(value: I8) => value
new from[A: (Number & Real[A] val)](a: A) => a.i8()
new min_value() => -0x80
new max_value() => 0x7F
fun abs(): U8 => if this < 0 then (-this).u8() else this.u8() end
fun bit_reverse(): I8 => @"llvm.bitreverse.i8"(this.u8()).i8()
fun bswap(): I8 => this
fun popcount(): U8 => @"llvm.ctpop.i8"(this.u8())
fun clz(): U8 => @"llvm.ctlz.i8"(this.u8(), false)
fun ctz(): U8 => @"llvm.cttz.i8"(this.u8(), false)
fun clz_unsafe(): U8 =>
"""
Unsafe operation.
If this is 0, the result is undefined.
"""
@"llvm.ctlz.i8"(this.u8(), true)
fun ctz_unsafe(): U8 =>
"""
Unsafe operation.
If this is 0, the result is undefined.
"""
@"llvm.cttz.i8"(this.u8(), true)
fun bitwidth(): U8 => 8
fun bytewidth(): USize => bitwidth().usize() / 8
fun min(y: I8): I8 => if this < y then this else y end
fun max(y: I8): I8 => if this > y then this else y end
fun fld(y: I8): I8 =>
_SignedArithmetic.fld[I8, U8](this, y)
fun fld_unsafe(y: I8): I8 =>
_SignedUnsafeArithmetic.fld_unsafe[I8, U8](this, y)
fun mod(y: I8): I8 =>
_SignedArithmetic.mod[I8, U8](this, y)
fun mod_unsafe(y: I8): I8 =>
_SignedUnsafeArithmetic.mod_unsafe[I8, U8](this, y)
fun addc(y: I8): (I8, Bool) =>
@"llvm.sadd.with.overflow.i8"(this, y)
fun subc(y: I8): (I8, Bool) =>
@"llvm.ssub.with.overflow.i8"(this, y)
fun mulc(y: I8): (I8, Bool) =>
@"llvm.smul.with.overflow.i8"(this, y)
fun divc(y: I8): (I8, Bool) =>
_SignedCheckedArithmetic.div_checked[I8, U8](this, y)
fun remc(y: I8): (I8, Bool) =>
_SignedCheckedArithmetic.rem_checked[I8, U8](this, y)
fun fldc(y: I8): (I8, Bool) =>
_SignedCheckedArithmetic.fld_checked[I8, U8](this, y)
fun modc(y: I8): (I8, Bool) =>
_SignedCheckedArithmetic.mod_checked[I8, U8](this, y)
fun add_partial(y: I8): I8 ? =>
_SignedPartialArithmetic.add_partial[I8](this, y)?
fun sub_partial(y: I8): I8 ? =>
_SignedPartialArithmetic.sub_partial[I8](this, y)?
fun mul_partial(y: I8): I8 ? =>
_SignedPartialArithmetic.mul_partial[I8](this, y)?
fun div_partial(y: I8): I8 ? =>
_SignedPartialArithmetic.div_partial[I8, U8](this, y)?
fun rem_partial(y: I8): I8 ? =>
_SignedPartialArithmetic.rem_partial[I8, U8](this, y)?
fun divrem_partial(y: I8): (I8, I8) ? =>
_SignedPartialArithmetic.divrem_partial[I8, U8](this, y)?
fun fld_partial(y: I8): I8 ? =>
_SignedPartialArithmetic.fld_partial[I8, U8](this, y)?
fun mod_partial(y: I8): I8 ? =>
_SignedPartialArithmetic.mod_partial[I8, U8](this, y)?
primitive I16 is SignedInteger[I16, U16]
new create(value: I16) => value
new from[A: (Number & Real[A] val)](a: A) => a.i16()
new min_value() => -0x8000
new max_value() => 0x7FFF
fun abs(): U16 => if this < 0 then (-this).u16() else this.u16() end
fun bit_reverse(): I16 => @"llvm.bitreverse.i16"(this.u16()).i16()
fun bswap(): I16 => @"llvm.bswap.i16"(this.u16()).i16()
fun popcount(): U16 => @"llvm.ctpop.i16"(this.u16())
fun clz(): U16 => @"llvm.ctlz.i16"(this.u16(), false)
fun ctz(): U16 => @"llvm.cttz.i16"(this.u16(), false)
fun clz_unsafe(): U16 =>
"""
Unsafe operation.
If this is 0, the result is undefined.
"""
@"llvm.ctlz.i16"(this.u16(), true)
fun ctz_unsafe(): U16 =>
"""
Unsafe operation.
If this is 0, the result is undefined.
"""
@"llvm.cttz.i16"(this.u16(), true)
fun bitwidth(): U16 => 16
fun bytewidth(): USize => bitwidth().usize() / 8
fun min(y: I16): I16 => if this < y then this else y end
fun max(y: I16): I16 => if this > y then this else y end
fun fld(y: I16): I16 =>
_SignedArithmetic.fld[I16, U16](this, y)
fun fld_unsafe(y: I16): I16 =>
_SignedUnsafeArithmetic.fld_unsafe[I16, U16](this, y)
fun mod(y: I16): I16 =>
_SignedArithmetic.mod[I16, U16](this, y)
fun mod_unsafe(y: I16): I16 =>
_SignedUnsafeArithmetic.mod_unsafe[I16, U16](this, y)
fun addc(y: I16): (I16, Bool) =>
@"llvm.sadd.with.overflow.i16"(this, y)
fun subc(y: I16): (I16, Bool) =>
@"llvm.ssub.with.overflow.i16"(this, y)
fun mulc(y: I16): (I16, Bool) =>
@"llvm.smul.with.overflow.i16"(this, y)
fun divc(y: I16): (I16, Bool) =>
_SignedCheckedArithmetic.div_checked[I16, U16](this, y)
fun remc(y: I16): (I16, Bool) =>
_SignedCheckedArithmetic.rem_checked[I16, U16](this, y)
fun fldc(y: I16): (I16, Bool) =>
_SignedCheckedArithmetic.fld_checked[I16, U16](this, y)
fun modc(y: I16): (I16, Bool) =>
_SignedCheckedArithmetic.mod_checked[I16, U16](this, y)
fun add_partial(y: I16): I16 ? =>
_SignedPartialArithmetic.add_partial[I16](this, y)?
fun sub_partial(y: I16): I16 ? =>
_SignedPartialArithmetic.sub_partial[I16](this, y)?
fun mul_partial(y: I16): I16 ? =>
_SignedPartialArithmetic.mul_partial[I16](this, y)?
fun div_partial(y: I16): I16 ? =>
_SignedPartialArithmetic.div_partial[I16, U16](this, y)?
fun rem_partial(y: I16): I16 ? =>
_SignedPartialArithmetic.rem_partial[I16, U16](this, y)?
fun divrem_partial(y: I16): (I16, I16) ? =>
_SignedPartialArithmetic.divrem_partial[I16, U16](this, y)?
fun fld_partial(y: I16): I16 ? =>
_SignedPartialArithmetic.fld_partial[I16, U16](this, y)?
fun mod_partial(y: I16): I16 ? =>
_SignedPartialArithmetic.mod_partial[I16, U16](this, y)?
primitive I32 is SignedInteger[I32, U32]
new create(value: I32) => value
new from[A: (Number & Real[A] val)](a: A) => a.i32()
new min_value() => -0x8000_0000
new max_value() => 0x7FFF_FFFF
fun abs(): U32 => if this < 0 then (-this).u32() else this.u32() end
fun bit_reverse(): I32 => @"llvm.bitreverse.i32"(this.u32()).i32()
fun bswap(): I32 => @"llvm.bswap.i32"(this.u32()).i32()
fun popcount(): U32 => @"llvm.ctpop.i32"(this.u32())
fun clz(): U32 => @"llvm.ctlz.i32"(this.u32(), false)
fun ctz(): U32 => @"llvm.cttz.i32"(this.u32(), false)
fun clz_unsafe(): U32 =>
"""
Unsafe operation.
If this is 0, the result is undefined.
"""
@"llvm.ctlz.i32"(this.u32(), true)
fun ctz_unsafe(): U32 =>
"""
Unsafe operation.
If this is 0, the result is undefined.
"""
@"llvm.cttz.i32"(this.u32(), true)
fun bitwidth(): U32 => 32
fun bytewidth(): USize => bitwidth().usize() / 8
fun min(y: I32): I32 => if this < y then this else y end
fun max(y: I32): I32 => if this > y then this else y end
fun fld(y: I32): I32 =>
_SignedArithmetic.fld[I32, U32](this, y)
fun fld_unsafe(y: I32): I32 =>
_SignedUnsafeArithmetic.fld_unsafe[I32, U32](this, y)
fun mod(y: I32): I32 =>
_SignedArithmetic.mod[I32, U32](this, y)
fun mod_unsafe(y: I32): I32 =>
_SignedUnsafeArithmetic.mod_unsafe[I32, U32](this, y)
fun addc(y: I32): (I32, Bool) =>
@"llvm.sadd.with.overflow.i32"(this, y)
fun subc(y: I32): (I32, Bool) =>
@"llvm.ssub.with.overflow.i32"(this, y)
fun mulc(y: I32): (I32, Bool) =>
@"llvm.smul.with.overflow.i32"(this, y)
fun divc(y: I32): (I32, Bool) =>
_SignedCheckedArithmetic.div_checked[I32, U32](this, y)
fun remc(y: I32): (I32, Bool) =>
_SignedCheckedArithmetic.rem_checked[I32, U32](this, y)
fun fldc(y: I32): (I32, Bool) =>
_SignedCheckedArithmetic.fld_checked[I32, U32](this, y)
fun modc(y: I32): (I32, Bool) =>
_SignedCheckedArithmetic.mod_checked[I32, U32](this, y)
fun add_partial(y: I32): I32 ? =>
_SignedPartialArithmetic.add_partial[I32](this, y)?
fun sub_partial(y: I32): I32 ? =>
_SignedPartialArithmetic.sub_partial[I32](this, y)?
fun mul_partial(y: I32): I32 ? =>
_SignedPartialArithmetic.mul_partial[I32](this, y)?
fun div_partial(y: I32): I32 ? =>
_SignedPartialArithmetic.div_partial[I32, U32](this, y)?
fun rem_partial(y: I32): I32 ? =>
_SignedPartialArithmetic.rem_partial[I32, U32](this, y)?
fun divrem_partial(y: I32): (I32, I32) ? =>
_SignedPartialArithmetic.divrem_partial[I32, U32](this, y)?
fun fld_partial(y: I32): I32 ? =>
_SignedPartialArithmetic.fld_partial[I32, U32](this, y)?
fun mod_partial(y: I32): I32 ? =>
_SignedPartialArithmetic.mod_partial[I32, U32](this, y)?
primitive I64 is SignedInteger[I64, U64]
new create(value: I64) => value
new from[A: (Number & Real[A] val)](a: A) => a.i64()
new min_value() => -0x8000_0000_0000_0000
new max_value() => 0x7FFF_FFFF_FFFF_FFFF
fun abs(): U64 => if this < 0 then (-this).u64() else this.u64() end
fun bit_reverse(): I64 => @"llvm.bitreverse.i64"(this.u64()).i64()
fun bswap(): I64 => @"llvm.bswap.i64"(this.u64()).i64()
fun popcount(): U64 => @"llvm.ctpop.i64"(this.u64())
fun clz(): U64 => @"llvm.ctlz.i64"(this.u64(), false)
fun ctz(): U64 => @"llvm.cttz.i64"(this.u64(), false)
fun clz_unsafe(): U64 =>
"""
Unsafe operation.
If this is 0, the result is undefined.
"""
@"llvm.ctlz.i64"(this.u64(), true)
fun ctz_unsafe(): U64 =>
"""
Unsafe operation.
If this is 0, the result is undefined.
"""
@"llvm.cttz.i64"(this.u64(), true)
fun bitwidth(): U64 => 64
fun bytewidth(): USize => bitwidth().usize() / 8
fun min(y: I64): I64 => if this < y then this else y end
fun max(y: I64): I64 => if this > y then this else y end
fun fld(y: I64): I64 =>
_SignedArithmetic.fld[I64, U64](this, y)
fun fld_unsafe(y: I64): I64 =>
_SignedUnsafeArithmetic.fld_unsafe[I64, U64](this, y)
fun mod(y: I64): I64 =>
_SignedArithmetic.mod[I64, U64](this, y)
fun mod_unsafe(y: I64): I64 =>
_SignedUnsafeArithmetic.mod_unsafe[I64, U64](this, y)
fun hash(): USize => u64().hash()
fun addc(y: I64): (I64, Bool) =>
@"llvm.sadd.with.overflow.i64"(this, y)
fun subc(y: I64): (I64, Bool) =>
@"llvm.ssub.with.overflow.i64"(this, y)
fun mulc(y: I64): (I64, Bool) =>
_SignedCheckedArithmetic._mul_checked[U64, I64](this, y)
fun divc(y: I64): (I64, Bool) =>
_SignedCheckedArithmetic.div_checked[I64, U64](this, y)
fun remc(y: I64): (I64, Bool) =>
_SignedCheckedArithmetic.rem_checked[I64, U64](this, y)
fun fldc(y: I64): (I64, Bool) =>
_SignedCheckedArithmetic.fld_checked[I64, U64](this, y)
fun modc(y: I64): (I64, Bool) =>
_SignedCheckedArithmetic.mod_checked[I64, U64](this, y)
fun add_partial(y: I64): I64 ? =>
_SignedPartialArithmetic.add_partial[I64](this, y)?
fun sub_partial(y: I64): I64 ? =>
_SignedPartialArithmetic.sub_partial[I64](this, y)?
fun mul_partial(y: I64): I64 ? =>
_SignedPartialArithmetic.mul_partial[I64](this, y)?
fun div_partial(y: I64): I64 ? =>
_SignedPartialArithmetic.div_partial[I64, U64](this, y)?
fun rem_partial(y: I64): I64 ? =>
_SignedPartialArithmetic.rem_partial[I64, U64](this, y)?
fun divrem_partial(y: I64): (I64, I64) ? =>
_SignedPartialArithmetic.divrem_partial[I64, U64](this, y)?
fun fld_partial(y: I64): I64 ? =>
_SignedPartialArithmetic.fld_partial[I64, U64](this, y)?
fun mod_partial(y: I64): I64 ? =>
_SignedPartialArithmetic.mod_partial[I64, U64](this, y)?
primitive ILong is SignedInteger[ILong, ULong]
new create(value: ILong) => value
new from[A: (Number & Real[A] val)](a: A) => a.ilong()
new min_value() =>
ifdef ilp32 or llp64 then
-0x8000_0000
else
-0x8000_0000_0000_0000
end
new max_value() =>
ifdef ilp32 or llp64 then
0x7FFF_FFFF
else
0x7FFF_FFFF_FFFF_FFFF
end
fun abs(): ULong => if this < 0 then (-this).ulong() else this.ulong() end
fun bit_reverse(): ILong =>
ifdef ilp32 or llp64 then
@"llvm.bitreverse.i32"(this.u32()).ilong()
else
@"llvm.bitreverse.i64"(this.u64()).ilong()
end
fun bswap(): ILong =>
ifdef ilp32 or llp64 then
@"llvm.bswap.i32"(this.u32()).ilong()
else
@"llvm.bswap.i64"(this.u64()).ilong()
end
fun popcount(): ULong =>
ifdef ilp32 or llp64 then
@"llvm.ctpop.i32"(this.u32()).ulong()
else
@"llvm.ctpop.i64"(this.u64()).ulong()
end
fun clz(): ULong =>
ifdef ilp32 or llp64 then
@"llvm.ctlz.i32"(this.u32(), false).ulong()
else
@"llvm.ctlz.i64"(this.u64(), false).ulong()
end
fun ctz(): ULong =>
ifdef ilp32 or llp64 then
@"llvm.cttz.i32"(this.u32(), false).ulong()
else
@"llvm.cttz.i64"(this.u64(), false).ulong()
end
fun clz_unsafe(): ULong =>
ifdef ilp32 or llp64 then
@"llvm.ctlz.i32"(this.u32(), true).ulong()
else
@"llvm.ctlz.i64"(this.u64(), true).ulong()
end
fun ctz_unsafe(): ULong =>
ifdef ilp32 or llp64 then
@"llvm.cttz.i32"(this.u32(), false).ulong()
else
@"llvm.cttz.i64"(this.u64(), true).ulong()
end
fun bitwidth(): ULong => ifdef ilp32 or llp64 then 32 else 64 end
fun bytewidth(): USize => bitwidth().usize() / 8
fun min(y: ILong): ILong => if this < y then this else y end
fun max(y: ILong): ILong => if this > y then this else y end
fun fld(y: ILong): ILong =>
_SignedArithmetic.fld[ILong, ULong](this, y)
fun fld_unsafe(y: ILong): ILong =>
_SignedUnsafeArithmetic.fld_unsafe[ILong, ULong](this, y)
fun mod(y: ILong): ILong =>
_SignedArithmetic.mod[ILong, ULong](this, y)
fun mod_unsafe(y: ILong): ILong =>
_SignedUnsafeArithmetic.mod_unsafe[ILong, ULong](this, y)
fun hash(): USize => ulong().hash()
fun addc(y: ILong): (ILong, Bool) =>
ifdef ilp32 or llp64 then
(let r, let o) =
@"llvm.sadd.with.overflow.i32"(this.i32(), y.i32())
(r.ilong(), o)
else
(let r, let o) =
@"llvm.sadd.with.overflow.i64"(this.i64(), y.i64())
(r.ilong(), o)
end
fun subc(y: ILong): (ILong, Bool) =>
ifdef ilp32 or llp64 then
(let r, let o) =
@"llvm.ssub.with.overflow.i32"(this.i32(), y.i32())
(r.ilong(), o)
else
(let r, let o) =
@"llvm.ssub.with.overflow.i64"(this.i64(), y.i64())
(r.ilong(), o)
end
fun mulc(y: ILong): (ILong, Bool) =>
ifdef ilp32 or llp64 then
(let r, let o) =
@"llvm.smul.with.overflow.i32"(this.i32(), y.i32())
(r.ilong(), o)
else
_SignedCheckedArithmetic._mul_checked[ULong, ILong](this, y)
end
fun divc(y: ILong): (ILong, Bool) =>
_SignedCheckedArithmetic.div_checked[ILong, ULong](this, y)
fun remc(y: ILong): (ILong, Bool) =>
_SignedCheckedArithmetic.rem_checked[ILong, ULong](this, y)
fun fldc(y: ILong): (ILong, Bool) =>
_SignedCheckedArithmetic.fld_checked[ILong, ULong](this, y)
fun modc(y: ILong): (ILong, Bool) =>
_SignedCheckedArithmetic.mod_checked[ILong, ULong](this, y)
fun add_partial(y: ILong): ILong ? =>
_SignedPartialArithmetic.add_partial[ILong](this, y)?
fun sub_partial(y: ILong): ILong ? =>
_SignedPartialArithmetic.sub_partial[ILong](this, y)?
fun mul_partial(y: ILong): ILong ? =>
_SignedPartialArithmetic.mul_partial[ILong](this, y)?
fun div_partial(y: ILong): ILong ? =>
_SignedPartialArithmetic.div_partial[ILong, ULong](this, y)?
fun rem_partial(y: ILong): ILong ? =>
_SignedPartialArithmetic.rem_partial[ILong, ULong](this, y)?
fun divrem_partial(y: ILong): (ILong, ILong) ? =>
_SignedPartialArithmetic.divrem_partial[ILong, ULong](this, y)?
fun fld_partial(y: ILong): ILong ? =>
_SignedPartialArithmetic.fld_partial[ILong, ULong](this, y)?
fun mod_partial(y: ILong): ILong ? =>
_SignedPartialArithmetic.mod_partial[ILong, ULong](this, y)?
primitive ISize is SignedInteger[ISize, USize]
new create(value: ISize) => value
new from[A: (Number & Real[A] val)](a: A) => a.isize()
new min_value() =>
ifdef ilp32 then
-0x8000_0000
else
-0x8000_0000_0000_0000
end
new max_value() =>
ifdef ilp32 then
0x7FFF_FFFF
else
0x7FFF_FFFF_FFFF_FFFF
end
fun abs(): USize => if this < 0 then (-this).usize() else this.usize() end
fun bit_reverse(): ISize =>
ifdef ilp32 then
@"llvm.bitreverse.i32"(this.u32()).isize()
else
@"llvm.bitreverse.i64"(this.u64()).isize()
end
fun bswap(): ISize =>
ifdef ilp32 then
@"llvm.bswap.i32"(this.u32()).isize()
else
@"llvm.bswap.i64"(this.u64()).isize()
end
fun popcount(): USize =>
ifdef ilp32 then
@"llvm.ctpop.i32"(this.u32()).usize()
else
@"llvm.ctpop.i64"(this.u64()).usize()
end
fun clz(): USize =>
ifdef ilp32 then
@"llvm.ctlz.i32"(this.u32(), false).usize()
else
@"llvm.ctlz.i64"(this.u64(), false).usize()
end
fun ctz(): USize =>
ifdef ilp32 then
@"llvm.cttz.i32"(this.u32(), false).usize()
else
@"llvm.cttz.i64"(this.u64(), false).usize()
end
fun clz_unsafe(): USize =>
ifdef ilp32 then
@"llvm.ctlz.i32"(this.u32(), true).usize()
else
@"llvm.ctlz.i64"(this.u64(), true).usize()
end
fun ctz_unsafe(): USize =>
ifdef ilp32 then
@"llvm.cttz.i32"(this.u32(), true).usize()
else
@"llvm.cttz.i64"(this.u64(), true).usize()
end
fun bitwidth(): USize => ifdef ilp32 then 32 else 64 end
fun bytewidth(): USize => bitwidth().usize() / 8
fun min(y: ISize): ISize => if this < y then this else y end
fun max(y: ISize): ISize => if this > y then this else y end
fun fld(y: ISize): ISize =>
_SignedArithmetic.fld[ISize, USize](this, y)
fun fld_unsafe(y: ISize): ISize =>
_SignedUnsafeArithmetic.fld_unsafe[ISize, USize](this, y)
fun mod(y: ISize): ISize =>
_SignedArithmetic.mod[ISize, USize](this, y)
fun mod_unsafe(y: ISize): ISize =>
_SignedUnsafeArithmetic.mod_unsafe[ISize, USize](this, y)
fun addc(y: ISize): (ISize, Bool) =>
ifdef ilp32 then
(let r, let o) =
@"llvm.sadd.with.overflow.i32"(this.i32(), y.i32())
(r.isize(), o)
else
(let r, let o) =
@"llvm.sadd.with.overflow.i64"(this.i64(), y.i64())
(r.isize(), o)
end
fun subc(y: ISize): (ISize, Bool) =>
ifdef ilp32 then
(let r, let o) =
@"llvm.ssub.with.overflow.i32"(this.i32(), y.i32())
(r.isize(), o)
else
(let r, let o) =
@"llvm.ssub.with.overflow.i64"(this.i64(), y.i64())
(r.isize(), o)
end
fun mulc(y: ISize): (ISize, Bool) =>
ifdef ilp32 then
(let r, let o) =
@"llvm.smul.with.overflow.i32"(this.i32(), y.i32())
(r.isize(), o)
else
_SignedCheckedArithmetic._mul_checked[USize, ISize](this, y)
end
fun divc(y: ISize): (ISize, Bool) =>
_SignedCheckedArithmetic.div_checked[ISize, USize](this, y)
fun remc(y: ISize): (ISize, Bool) =>
_SignedCheckedArithmetic.rem_checked[ISize, USize](this, y)
fun fldc(y: ISize): (ISize, Bool) =>
_SignedCheckedArithmetic.fld_checked[ISize, USize](this, y)
fun modc(y: ISize): (ISize, Bool) =>
_SignedCheckedArithmetic.mod_checked[ISize, USize](this, y)
fun add_partial(y: ISize): ISize ? =>
_SignedPartialArithmetic.add_partial[ISize](this, y)?
fun sub_partial(y: ISize): ISize ? =>
_SignedPartialArithmetic.sub_partial[ISize](this, y)?
fun mul_partial(y: ISize): ISize ? =>
_SignedPartialArithmetic.mul_partial[ISize](this, y)?
fun div_partial(y: ISize): ISize ? =>
_SignedPartialArithmetic.div_partial[ISize, USize](this, y)?
fun rem_partial(y: ISize): ISize ? =>
_SignedPartialArithmetic.rem_partial[ISize, USize](this, y)?
fun divrem_partial(y: ISize): (ISize, ISize) ? =>
_SignedPartialArithmetic.divrem_partial[ISize, USize](this, y)?
fun fld_partial(y: ISize): ISize ? =>
_SignedPartialArithmetic.fld_partial[ISize, USize](this, y)?
fun mod_partial(y: ISize): ISize ? =>
_SignedPartialArithmetic.mod_partial[ISize, USize](this, y)?
primitive I128 is SignedInteger[I128, U128]
new create(value: I128) => value
new from[A: (Number & Real[A] val)](a: A) => a.i128()
new min_value() => -0x8000_0000_0000_0000_0000_0000_0000_0000
new max_value() => 0x7FFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF
fun abs(): U128 => if this < 0 then (-this).u128() else this.u128() end
fun bit_reverse(): I128 => @"llvm.bitreverse.i128"(this.u128()).i128()
fun bswap(): I128 => @"llvm.bswap.i128"(this.u128()).i128()
fun popcount(): U128 => @"llvm.ctpop.i128"(this.u128())
fun clz(): U128 => @"llvm.ctlz.i128"(this.u128(), false)
fun ctz(): U128 => @"llvm.cttz.i128"(this.u128(), false)
fun clz_unsafe(): U128 =>
"""
Unsafe operation.
If this is 0, the result is undefined.
"""
@"llvm.ctlz.i128"(this.u128(), true)
fun ctz_unsafe(): U128 =>
"""
Unsafe operation.
If this is 0, the result is undefined.
"""
@"llvm.cttz.i128"(this.u128(), true)
fun bitwidth(): U128 => 128
fun bytewidth(): USize => bitwidth().usize() / 8
fun min(y: I128): I128 => if this < y then this else y end
fun max(y: I128): I128 => if this > y then this else y end
fun fld(y: I128): I128 => _SignedArithmetic.fld[I128, U128](this, y)
fun fld_unsafe(y: I128): I128 =>
_SignedUnsafeArithmetic.fld_unsafe[I128, U128](this, y)
fun mod(y: I128): I128 =>
_SignedArithmetic.mod[I128, U128](this, y)
fun mod_unsafe(y: I128): I128 =>
_SignedUnsafeArithmetic.mod_unsafe[I128, U128](this, y)
fun hash(): USize => u128().hash()
fun hash64(): U64 => u128().hash64()
fun string(): String iso^ =>
_ToString._u128(abs().u128(), this < 0)
fun mul(y: I128): I128 =>
(u128() * y.u128()).i128()
fun divrem(y: I128): (I128, I128) =>
ifdef native128 then
(this / y, this % y)
else
if y == 0 then
return (0, 0)
end
var num: I128 = if this >= 0 then this else -this end
var den: I128 = if y >= 0 then y else -y end
(let q, let r) = num.u128().divrem(den.u128())
(var q', var r') = (q.i128(), r.i128())
if this < 0 then
r' = -r'
if y > 0 then
q' = -q'
end
elseif y < 0 then
q' = -q'
end
(q', r')
end
fun div(y: I128): I128 =>
ifdef native128 then
this / y
else
(let q, let r) = divrem(y)
q
end
fun rem(y: I128): I128 =>
ifdef native128 then
this % y
else
(let q, let r) = divrem(y)
r
end
fun mul_unsafe(y: I128): I128 =>
"""
Unsafe operation.
If the operation overflows, the result is undefined.
"""
ifdef native128 then
this *~ y
else
this * y
end
fun divrem_unsafe(y: I128): (I128, I128) =>
"""
Unsafe operation.
If y is 0, the result is undefined.
If the operation overflows, the result is undefined.
"""
ifdef native128 then
(this *~ y, this /~ y)
else
divrem(y)
end
fun div_unsafe(y: I128): I128 =>
"""
Unsafe operation.
If y is 0, the result is undefined.
If the operation overflows, the result is undefined.
"""
ifdef native128 then
this /~ y
else
this / y
end
fun rem_unsafe(y: I128): I128 =>
"""
Unsafe operation.
If y is 0, the result is undefined.
If the operation overflows, the result is undefined.
"""
ifdef native128 then
this %~ y
else
this % y
end
fun f32(): F32 =>
f64().f32()
fun f64(): F64 =>
if this < 0 then
-(-u128()).f64()
else
u128().f64()
end
fun f32_unsafe(): F32 =>
"""
Unsafe operation.
If the value doesn't fit in the destination type, the result is undefined.
"""
f64_unsafe().f32_unsafe()
fun f64_unsafe(): F64 =>
"""
Unsafe operation.
If the value doesn't fit in the destination type, the result is undefined.
"""
f64()
fun addc(y: I128): (I128, Bool) =>
ifdef native128 then
@"llvm.sadd.with.overflow.i128"(this, y)
else
let overflow =
if y > 0 then
(this > (max_value() - y))
else
(this < (min_value() - y))
end
(this + y, overflow)
end
fun subc(y: I128): (I128, Bool) =>
ifdef native128 then
@"llvm.ssub.with.overflow.i128"(this, y)
else
let overflow =
if y > 0 then
(this < (min_value() + y))
else
(this > (max_value() + y))
end
(this - y, overflow)
end
fun mulc(y: I128): (I128, Bool) =>
// using llvm.smul.with.overflow.i128 would require to link
// llvm compiler-rt where the function implementing it lives: https://github.com/llvm-mirror/compiler-rt/blob/master/lib/builtins/muloti4.c
// See this bug for reference:
// the following implementation is more or less exactly was __muloti4 is
// doing
_SignedCheckedArithmetic._mul_checked[U128, I128](this, y)
fun divc(y: I128): (I128, Bool) =>
_SignedCheckedArithmetic.div_checked[I128, U128](this, y)
fun remc(y: I128): (I128, Bool) =>
_SignedCheckedArithmetic.rem_checked[I128, U128](this, y)
fun fldc(y: I128): (I128, Bool) =>
_SignedCheckedArithmetic.fld_checked[I128, U128](this, y)
fun modc(y: I128): (I128, Bool) =>
_SignedCheckedArithmetic.mod_checked[I128, U128](this, y)
fun add_partial(y: I128): I128 ? =>
_SignedPartialArithmetic.add_partial[I128](this, y)?
fun sub_partial(y: I128): I128 ? =>
_SignedPartialArithmetic.sub_partial[I128](this, y)?
fun mul_partial(y: I128): I128 ? =>
_SignedPartialArithmetic.mul_partial[I128](this, y)?
fun div_partial(y: I128): I128 ? =>
_SignedPartialArithmetic.div_partial[I128, U128](this, y)?
fun rem_partial(y: I128): I128 ? =>
_SignedPartialArithmetic.rem_partial[I128, U128](this, y)?
fun divrem_partial(y: I128): (I128, I128) ? =>
_SignedPartialArithmetic.divrem_partial[I128, U128](this, y)?
fun fld_partial(y: I128): I128 ? =>
_SignedPartialArithmetic.fld_partial[I128, U128](this, y)?
fun mod_partial(y: I128): I128 ? =>
_SignedPartialArithmetic.mod_partial[I128, U128](this, y)?
type Signed is (I8 | I16 | I32 | I64 | I128 | ILong | ISize)