BigInteger& operator -- () {
return *this -= BigInteger(1);
}
TEST(BigInteger, CorrectlySubtractsMixedPositiveAndNegative2) {
ASSERT_EQ(17, BigInteger(5) - (-12));
}
TEST(BigInteger, CorrectlySubtractsMixedPositiveAndNegative4) {
ASSERT_EQ(-17, BigInteger(-5) - 12);
}
TEST(BigInteger, CorrectlySubtractsPositiveAndNegative1) {
ASSERT_EQ(-17, BigInteger(-12) - BigInteger(5));
}
TEST(BigInteger, CorrectlyParsesNegativeNumberWithZeroes) {
ASSERT_EQ(-12040, BigInteger(-12040));
}
TEST(BigInteger, CorrectlySubtractsTwoMixedPositiveNumbers3) {
ASSERT_EQ(-999, 1 - BigInteger(1000));
}
TEST(BigInteger, CorrectlySubtractsTwoMixedPositiveNumbers5) {
ASSERT_EQ(10, 21 - BigInteger(11));
}
TEST(BigInteger, CorrectlyAddsTwoNegativeNumbers3) {
ASSERT_EQ(-1000, BigInteger(-999) + BigInteger(-1));
}
TEST(BigInteger, CorrectlyParsesNumberWithZeroes) {
ASSERT_EQ(12040, BigInteger(12040));
}
BigInteger operator<<(const BigInteger& obj, int value) {
BigInteger res = BigInteger(obj.get_msb() + value);
for (int i = 0; i < obj.get_msb(); ++i)
res.set(value + i, obj.at(i));
return res;
}
//-------------------------------------------------------------
// returns the absolute value
BigInteger BigInteger::absolute()
{
return BigInteger( getNumber() ); // +ve by default
}
while (i > 0)
output[j++] = data[--i];
output[j] = '\0';
}
BigInteger operator<<(const BigInteger& obj, int value) {
BigInteger res = BigInteger(obj.get_msb() + value);
for (int i = 0; i < obj.get_msb(); ++i)
res.set(value + i, obj.at(i));
return res;
}
BigInteger operator>>(const BigInteger& obj, int value) {
if (obj.get_msb() <= value)
return BigInteger();
BigInteger res = BigInteger(obj.get_msb() - value);
for (int i = value; i < obj.get_msb(); ++i)
res.set(i - value, obj.at(i));
return res;
}
bool operator<(const BigInteger& lhs, const BigInteger& rhs) {
if (lhs.get_sign() && !rhs.get_sign())
return false;
if (rhs.get_sign() && !lhs.get_sign())
return true;
switch (absolute_less(lhs, rhs)) {
case 'l':
return lhs.get_sign();
case 'r':
return !lhs.get_sign();
BigInteger stringToBigInteger(const std::string &s) {
// Recognize a sign followed by a BigUnsigned.
return (s[0] == '-') ? BigInteger(stringToBigUnsigned(s.substr(1, s.length() - 1)), BigInteger::negative)
: (s[0] == '+') ? BigInteger(stringToBigUnsigned(s.substr(1, s.length() - 1)))
: BigInteger(stringToBigUnsigned(s));
}
BigInteger& operator = (intmax_t v) {
return *this = BigInteger(v);
}
TEST(BigInteger, CorrectlySubtractsTwoMixedPositiveNumbers1) {
ASSERT_EQ(-1265, 34 - BigInteger(1299));
}
TEST(BigInteger, CorrectlyAddsTwoMixedNegativeNumbers1) {
ASSERT_EQ(-1333, -34 + BigInteger(-1299));
}
TEST(BigInteger, CorrectlySubtractsTwoMixedPositiveNumbers2) {
ASSERT_EQ(1265, BigInteger(1299) - 34);
}
TEST(BigInteger, CorrectlyAddsTwoMixedNegativeNumbers2) {
ASSERT_EQ(-1333, BigInteger(-1299) + (-34));
}
TEST(BigInteger, CorrectlySubtractsTwoMixedPositiveNumbers4) {
ASSERT_EQ(999, BigInteger(1000) - 1);
}
TEST(BigInteger, CorrectlyAddsTwoMixedNegativeNumbers3) {
ASSERT_EQ(-1000, -999 + BigInteger(-1));
}
TEST(BigInteger, CorrectlySubtractsTwoMixedPositiveNumbers6) {
ASSERT_EQ(0, BigInteger(11) - 11);
}
TEST(BigInteger, CorrectlyAddsTwoMixedNegativeNumbers4) {
ASSERT_EQ(-1000, BigInteger(-1) + (-999));
}
TEST(BigInteger, CorrectlySubtractsPositiveAndNegative3) {
ASSERT_EQ(17, BigInteger(12) - BigInteger(-5));
}
TEST(BigInteger, CorrectlySubtractsTwoPositiveNumbers1) {
ASSERT_EQ(-1265, BigInteger(34) - BigInteger(1299));
}
TEST(BigInteger, CorrectlySubtractsMixedPositiveAndNegative1) {
ASSERT_EQ(-17, -12 - BigInteger(5));
}
TEST(BigInteger, CorrectlySubtractsTwoPositiveNumbers5) {
ASSERT_EQ(10, BigInteger(21) - BigInteger(11));
}
TEST(BigInteger, CorrectlySubtractsMixedPositiveAndNegative3) {
ASSERT_EQ(17, 12 - BigInteger(-5));
}
TEST(BigInteger, CorrectlyParsesNegativeNumberWithoutZeroes) {
ASSERT_EQ(-12345, BigInteger(-12345));
}
TEST(BigInteger, CorrectlySubtractsTwoNegativeNumbers1) {
ASSERT_EQ(1265, BigInteger(-34) - BigInteger(-1299));
}
BigInteger& operator ++() {
return *this += BigInteger(1);
}
