//returns true if left is > right, false if left <= right
bool do_bigless
(const bigint::bigvalue_t left, const bigint::bigvalue_t right){
if (left.size() > right.size())
return true;
else if(left.size() < right.size())
return false;
bigint::bigvalue_t::const_reverse_iterator
left_digit = left.rbegin();
bigint::bigvalue_t::const_reverse_iterator
right_digit = right.rbegin();
bool abs_val_greatest = false;
while (left_digit != left.rend()){
if (*left_digit > *right_digit){
return true;
} else if (*left_digit < *right_digit){
break;
}
++left_digit;
++right_digit;
}
return abs_val_greatest;
}
//works like doing multiplication by hand if
//left was the int on top and right was the int on bottom
bigint::bigvalue_t do_bigmult
(bigint::bigvalue_t left, bigint::bigvalue_t right){
bigint::bigvalue_t result;
bigint::bigvalue_t number;
//outer loop
for (unsigned int right_i = 0; right_i < right.size(); ++right_i){
number.clear();
int carry = 0;
//innter loop
for(unsigned int left_j = 0; left_j < left.size(); ++left_j){
//append zero's if necessary
if(left_j == 0){
for (unsigned int k = 0; k < right_i; ++k)
number.push_back(0);
}
int product = (right[right_i]*left[left_j]) + carry;
carry = product/10;
int digit = product - (carry * 10);
number.push_back(digit);
if(left_j == left.size() - 1 and carry != 0)
number.push_back(carry);
}
result = do_bigadd(result, number);
}
return result;
}
bigint::bigvalue_t do_bigadd
(bigint::bigvalue_t v1, bigint::bigvalue_t v2){
//do_mult may pass in empty vectors as args
if(v1.size() == 0) v1.push_back(0);
if(v2.size() == 0) v2.push_back(0);
char carry = 0;
bigint::bigvalue_t v3;
bool done1 = false;
bool done2 = false;
for (size_t i = 0; ; ++i) {
char digit1, digit2;
if (i < v1.size()) { digit1 = v1[i]; }
else { digit1 = 0; done1 = true; }
if (i < v2.size()) { digit2 = v2[i]; }
else { digit2 = 0; done2 = true; }
if (done1 && done2) break;
char sum = digit1 + digit2 + carry;
v3.push_back (sum % 10);
carry = sum / 10;
}
if (carry != 0) v3.push_back (carry);
return v3;
}
void divide_by_2 (bigint::bigvalue_t& div_by) {
//int data = 0; begin/rend 000001 end/rbegin == 100000
for(unsigned it = 0; it < div_by.size(); ++it) {
// Divide the value at index it by 2
div_by.at(it) /= 2;
// If the next higher digit is odd, add 5 to current digit
if(it < div_by.size() - 1) {
if(div_by.at(it + 1) % 2) {
div_by.at(it) += 5;
}
}
}
div_by = trim(div_by);
}
bigint::bigvalue_t divide_by_2(bigint::bigvalue_t that){
//bigint::bigvalue_t::iterator
bigint::bigvalue_t fresh;
for(size_t i = 0; i < that.size(); ++i){
unsigned char digit = that[i];
if (i != that.size() -1){
if(that[i+1]%2 == 1) digit += 5;
} else digit += 5;
fresh.push_back(digit);
}
return fresh;
}
//left - right
bigint::bigvalue_t do_bigsub
(bigint::bigvalue_t left, bigint::bigvalue_t right){
//char carry = 0;
bigint::bigvalue_t v3;
bool done1 = false;
bool done2 = false;
bool borrow = false;
for (size_t i = 0; ; ++i) {
char left_digit, right_digit;
if (i < left.size()) { left_digit = left[i]; }
else { left_digit = 0; done1 = true; }
if (i < right.size()) { right_digit = right[i]; }
else { right_digit = 0; done2 = true; }
if (done1 && done2) break;
if (borrow){
left_digit = left_digit - 1;
borrow = false;
}
if(left_digit < right_digit){
borrow = true;
char sum = ( (left_digit + 10) - right_digit);
v3.push_back(sum);
} else {
char sum = left_digit - right_digit;
v3.push_back(sum);
}
}
return v3;
}
bigint::bigvalue_t do_bigadd(const bigint::bigvalue_t& left,
const bigint::bigvalue_t& right) {
bigint::bigvalue_t sum;
int carry = 0;
bool left_empty = false;
bool right_empty = false;
auto left_it = left.begin();
//bigint::bigvalue_t::const_reverse_iterator left_it = left.rbegin();
auto right_it = right.begin();
auto left_end = left.end();
auto right_end = right.end();
if(left.size() == 0) {
left_empty = true;
}
if(right.size() == 0) {
right_empty = true;
}
while(true) {
int curr_value = (left_empty?0:*left_it) +
(right_empty?0:*right_it) + carry;
carry = 0;
if(curr_value >= 10) {
carry = 1;
curr_value -= 10;
}
sum.push_back(curr_value);
if(++left_it == left_end) {
left_empty = true;
}
if(++right_it == right_end) {
right_empty = true;
}
if(left_empty and right_empty) {
if(carry == 1) {
sum.push_back(carry);
}
break;
}
}
return sum;
}
bigint::bigvalue_t do_bigsub(const bigint::bigvalue_t& left,
const bigint::bigvalue_t& right) {
bigint::bigvalue_t sum;
int carry = 0;
bool left_empty = false;
bool right_empty = false;
auto left_it = left.begin();
//bigint::bigvalue_t::const_reverse_iterator left_it = left.rbegin();
auto right_it = right.begin();
auto left_end = left.end();
auto right_end = right.end();
if(left.size() == 0) {
left_empty = true;
}
if(right.size() == 0) {
right_empty = true;
}
while(true) {
int curr_value = (left_empty?0:*left_it) -
(right_empty?0:*right_it) + carry;
carry = 0;
if(curr_value < 0 and !left_empty) {
carry = -1;
curr_value += 10;
}
sum.push_back(curr_value);
if(++left_it == left_end) {
left_empty = true;
}
if(++right_it == right_end) {
right_empty = true;
}
if(left_empty and right_empty) {
break;
}
}
//remove leading 0s
sum = trim(sum);
return sum;
}
bigint::bigvalue_t do_bigmult(const bigint::bigvalue_t& left,
const bigint::bigvalue_t& right) {
bigint::bigvalue_t prod;
prod.resize(left.size() + right.size());
int carry = 0;
int d = 0;
int uv = 0;
for(unsigned i = 0; i != left.size(); ++i) {
carry = 0;
for(unsigned j = 0; j != right.size(); ++j) {
uv = left.at(i) * right.at(j);
d = prod.at(i + j) + uv + carry;
prod.at(i + j) = d % 10;
carry = d/10;
}
if(carry != 0) {
prod.at(right.size() + i) = carry;
}
}
prod = trim(prod);
return prod;
}
//
// do_bigless()
// returns true if left < right
// returns false if left > right or left == right
//
bool do_bigless (const bigint::bigvalue_t& left,
const bigint::bigvalue_t& right) {
if (left.size() < right.size()) {
return true;
} else if (left.size() > right.size()) {
return false;
}
auto itor_left = left.begin();
auto itor_right = right.begin();
while(itor_left != left.end() && itor_right != right.end()) {
if (itor_left > itor_left) {
return false;
} else if (itor_left < itor_right) {
return true;
} else {
itor_left++;
itor_right++;
}
}
return true;
}