// Written in the D programming language
/**
* Implements a signed 128 bit integer type.
*
Author: Walter Bright
Copyright: Copyright (c) 2022, D Language Foundation
License: $(HTTP boost.org/LICENSE_1_0.txt, Boost License 1.0)
Source: $(PHOBOSSRC std/int128.d)
*/
module std.int128;
private import core.int128;
/***********************************
* 128 bit signed integer type.
*/
public struct Int128
{
@safe pure nothrow @nogc:
Cent data; /// core.int128.Cent
/****************
* Construct an `Int128` from a `long` value.
* The upper 64 bits are formed by sign extension.
* Params:
* lo = signed lower 64 bits
*/
this(long lo)
{
data.lo = lo;
data.hi = lo < 0 ? ~0L : 0;
}
/****************
* Construct an `Int128` from a `ulong` value.
* The upper 64 bits are set to zero.
* Params:
* lo = unsigned lower 64 bits
*/
this(ulong lo)
{
data.lo = lo;
data.hi = 0;
}
/****************
* Construct an `Int128` from a `long` value.
* Params:
* hi = upper 64 bits
* lo = lower 64 bits
*/
this(long hi, long lo)
{
data.hi = hi;
data.lo = lo;
}
/********************
* Construct an `Int128` from a `Cent`.
* Params:
* data = Cent data
*/
this(Cent data)
{
this.data = data;
}
/********************
* Returns: hash value for Int128
*/
size_t toHash() const
{
return cast(size_t)((data.lo & 0xFFFF_FFFF) + (data.hi & 0xFFFF_FFFF) + (data.lo >> 32) + (data.hi >> 32));
}
/************************
* Compare for equality
* Params: lo = signed value to compare with
* Returns: true if Int128 equals value
*/
bool opEquals(long lo) const
{
return data.lo == lo && data.hi == (lo >> 63);
}
/************************
* Compare for equality
* Params: lo = unsigned value to compare with
* Returns: true if Int128 equals value
*/
bool opEquals(ulong lo) const
{
return data.hi == 0 && data.lo == lo;
}
/************************
* Compare for equality
* Params: op2 = value to compare with
* Returns: true if Int128 equals value
*/
bool opEquals(Int128 op2) const
{
return data.hi == op2.data.hi && data.lo == op2.data.lo;
}
/** Support unary arithmentic operator +
* Params: op = "+"
* Returns: lvalue of result
*/
Int128 opUnary(string op)() const
if (op == "+")
{
return this;
}
/** Support unary arithmentic operator - ~
* Params: op = "-", "~"
* Returns: lvalue of result
*/
Int128 opUnary(string op)() const
if (op == "-" || op == "~")
{
static if (op == "-")
return Int128(neg(this.data));
else static if (op == "~")
return Int128(com(this.data));
}
/** Support unary arithmentic operator ++ --
* Params: op = "++", "--"
* Returns: lvalue of result
*/
Int128 opUnary(string op)()
if (op == "++" || op == "--")
{
static if (op == "++")
this.data = inc(this.data);
else static if (op == "--")
this.data = dec(this.data);
else
static assert(0, op);
return this;
}
/** Support casting to a bool
* Params: T = bool
* Returns: boolean result
*/
bool opCast(T : bool)() const
{
return tst(this.data);
}
/** Support binary arithmetic operators + - * / % & | ^ << >> >>>
* Params:
* op = one of the arithmetic binary operators
* op2 = second operand
* Returns: value after the operation is applied
*/
Int128 opBinary(string op)(Int128 op2) const
if (op == "+" || op == "-" ||
op == "*" || op == "/" || op == "%" ||
op == "&" || op == "|" || op == "^")
{
static if (op == "+")
return Int128(add(this.data, op2.data));
else static if (op == "-")
return Int128(sub(this.data, op2.data));
else static if (op == "*")
return Int128(mul(this.data, op2.data));
else static if (op == "/")
return Int128(div(this.data, op2.data));
else static if (op == "%")
{
Cent modulus;
divmod(this.data, op2.data, modulus);
return Int128(modulus);
}
else static if (op == "&")
return Int128(and(this.data, op2.data));
else static if (op == "|")
return Int128(or(this.data, op2.data));
else static if (op == "^")
return Int128(xor(this.data, op2.data));
else
static assert(0, "wrong op value");
}
/// ditto
Int128 opBinary(string op)(long op2) const
if (op == "+" || op == "-" ||
op == "*" || op == "/" || op == "%" ||
op == "&" || op == "|" || op == "^")
{
return mixin("this " ~ op ~ " Int128(0, op2)");
}
/// ditto
Int128 opBinaryRight(string op)(long op2) const
if (op == "+" || op == "-" ||
op == "*" || op == "/" || op == "%" ||
op == "&" || op == "|" || op == "^")
{
mixin("return Int128(0, op2) " ~ op ~ " this;");
}
/// ditto
Int128 opBinary(string op)(long op2) const
if (op == "<<")
{
return Int128(shl(this.data, cast(uint) op2));
}
/// ditto
Int128 opBinary(string op)(long op2) const
if (op == ">>")
{
return Int128(sar(this.data, cast(uint) op2));
}
/// ditto
Int128 opBinary(string op)(long op2) const
if (op == ">>>")
{
return Int128(shr(this.data, cast(uint) op2));
}
/** arithmetic assignment operators += -= *= /= %= &= |= ^= <<= >>= >>>=
* Params: op = one of +, -, etc.
* op2 = second operand
* Returns: lvalue of updated left operand
*/
ref Int128 opOpAssign(string op)(Int128 op2)
if (op == "+" || op == "-" ||
op == "*" || op == "/" || op == "%" ||
op == "&" || op == "|" || op == "^" ||
op == "<<" || op == ">>" || op == ">>>")
{
mixin("this = this " ~ op ~ " op2;");
return this;
}
/// ditto
ref Int128 opOpAssign(string op)(long op2)
if (op == "+" || op == "-" ||
op == "*" || op == "/" || op == "%" ||
op == "&" || op == "|" || op == "^" ||
op == "<<" || op == ">>" || op == ">>>")
{
mixin("this = this " ~ op ~ " op2;");
return this;
}
/** support signed arithmentic comparison operators < <= > >=
* Params: op2 = right hand operand
* Returns: -1 for less than, 0 for equals, 1 for greater than
*/
int opCmp(Int128 op2) const
{
return this == op2 ? 0 : gt(this.data, op2.data) * 2 - 1;
}
/** support signed arithmentic comparison operators < <= > >=
* Params: op2 = right hand operand
* Returns: -1 for less than, 0 for equals, 1 for greater than
*/
int opCmp(long op2) const
{
return opCmp(Int128(0, op2));
}
enum min = Int128(long.min, 0); /// minimum value
enum max = Int128(long.max, ulong.max); /// maximum value
}
/********************************************* Tests ************************************/
version (unittest)
{
import core.stdc.stdio;
@trusted void print(Int128 c)
{
printf("%lld, %lld\n", c.data.hi, c.data.lo);
}
@trusted void printx(Int128 c)
{
printf("%llx, %llx\n", c.data.hi, c.data.lo);
}
}
/// Int128 tests
@safe pure nothrow @nogc
unittest
{
Int128 c = Int128(5, 6);
assert(c == c);
assert(c == +c);
assert(c == - -c);
assert(~c == Int128(~5, ~6));
++c;
assert(c == Int128(5, 7));
assert(--c == Int128(5, 6));
assert(!!c);
assert(!Int128());
assert(c + Int128(10, 20) == Int128(15, 26));
assert(c - Int128(1, 2) == Int128(4, 4));
assert(c * Int128(100, 2) == Int128(610, 12));
assert(c / Int128(3, 2) == Int128(0, 1));
assert(c % Int128(3, 2) == Int128(2, 4));
assert((c & Int128(3, 2)) == Int128(1, 2));
assert((c | Int128(3, 2)) == Int128(7, 6));
assert((c ^ Int128(3, 2)) == Int128(6, 4));
assert(c + 15 == Int128(5, 21));
assert(c - 15 == Int128(4, -9));
assert(c * 15 == Int128(75, 90));
assert(c / 15 == Int128(0, 6148914691236517205));
assert(c % 15 == Int128(0, 11));
assert((c & 15) == Int128(0, 6));
assert((c | 15) == Int128(5, 15));
assert((c ^ 15) == Int128(5, 9));
assert(15 + c == Int128(5, 21));
assert(15 - c == Int128(-5, 9));
assert(15 * c == Int128(75, 90));
assert(15 / c == Int128(0, 0));
assert(15 % c == Int128(0, 15));
assert((15 & c) == Int128(0, 6));
assert((15 | c) == Int128(5, 15));
assert((15 ^ c) == Int128(5, 9));
assert(c << 1 == Int128(10, 12));
assert(-c >> 1 == Int128(-3, 9223372036854775805));
assert(-c >>> 1 == Int128(9223372036854775805, 9223372036854775805));
assert((c += 1) == Int128(5, 7));
assert((c -= 1) == Int128(5, 6));
assert((c += Int128(0, 1)) == Int128(5, 7));
assert((c -= Int128(0, 1)) == Int128(5, 6));
assert((c *= 2) == Int128(10, 12));
assert((c /= 2) == Int128(5, 6));
assert((c %= 2) == Int128());
c += Int128(5, 6);
assert((c *= Int128(10, 20)) == Int128(160, 120));
assert((c /= Int128(10, 20)) == Int128(0, 15));
c += Int128(72, 0);
assert((c %= Int128(10, 20)) == Int128(1, -125));
assert((c &= Int128(3, 20)) == Int128(1, 0));
assert((c |= Int128(8, 2)) == Int128(9, 2));
assert((c ^= Int128(8, 2)) == Int128(1, 0));
c |= Int128(10, 5);
assert((c <<= 1) == Int128(11 * 2, 5 * 2));
assert((c >>>= 1) == Int128(11, 5));
c = Int128(long.min, long.min);
assert((c >>= 1) == Int128(long.min >> 1, cast(ulong) long.min >> 1));
assert(-Int128.min == Int128.min);
assert(Int128.max + 1 == Int128.min);
c = Int128(5, 6);
assert(c < Int128(6, 5));
assert(c > 10);
c = Int128(-1UL);
assert(c == -1UL);
c = Int128(-1L);
assert(c == -1L);
}