// false == left > right, true == left < right
int bigint::do_bigless(const bigvalue_t& left, const bigvalue_t& right) {
auto left_it = left.rbegin();
auto right_it = right.rbegin();
auto left_end = left.rend();
auto right_end = right.rend();
//cout << "left size" << left.size() << endl;
//cout << "right size" << right.size() << endl;
if(left.size() > right.size()) {
return -1;
}
if(left.size() < right.size()) {
return 1;
}
while(left_it != left_end and right_it != right_end) {
if(*left_it > *right_it) {
return -1;
}
else if (*left_it < *right_it) {
return 1;
}
++left_it;
++right_it;
}
return 0;
}
// ALMOST IDENTICAL TO D0_bIgAdD
bigvalue_t do_bigsub(const bigvalue_t& left,
const bigvalue_t& right){
bigvalue_t result = left;
//.... might work
// initialize variables
digit_t num, left_num, right_num, carry;
signed char temp;
size_t i = 0;
auto itor = result.cbegin();
auto left_itor = left.cbegin();
auto right_itor = right.cbegin();
// loop through each digit and put their sum into the result
while(itor != result.cend()){
// in case left number has less digits
if(left.size() < i) left_num = '0' - '0';
else left_num = *left_itor - '0';
// in case right number has less digits
if(right.size() < i) right_num = '0' - '0';
else right_num = *right_itor - '0';
// deal with individual digit
/////////////////////////////////////////////////////////////////
if(carry != '0') left_num = left_num - ('1' - '0');//// can you
//substrationate chars
temp = (left_num - right_num);// - '0';
carry = '0' - '0';
if(temp < '0' - '0'){
carry = '1' - '0'; //main differences are here...
num = temp + 10;
}
num = temp;
result.push_back(num);
/////////////////////////////////////////////////////////////////
}
return result;
}
bigvalue_t do_bigadd(const bigvalue_t& left,
const bigvalue_t& right){ // supposed tp be private
//needs to return bigvalue_t... not too sure this will work
bigvalue_t result{};// = left;
int maxsize;
int maxl = left.size();
int maxr = right.size();
if(maxl > maxr) maxsize = maxl;
else maxsize = maxr;
//initialize variables
digit_t num;
int left_num, right_num, carry, sum;
auto left_itor = left.cbegin();
auto right_itor = right.cbegin();
// loop through each digit and put their sum into the result
for(int j = 0; j < maxsize; ++j){
// in case left number has less digits
//if(j < maxl and j < maxr) break;
if(j < maxl){
num = *left_itor;
left_num = num - '0';
++left_itor;
}else{
num = '0';
left_num = num - '0';
}
// in case right number has less digits
if(j < maxr){
num = *right_itor;
right_num = num - '0';
++right_itor;
}else{
num = '0';
right_num = num - '0';
}
// deal with individual digit
sum = (left_num + right_num + carry);// - '0';
if(sum > 9){
carry = 1;
sum -= 10;
num = sum + '0';
}else{
carry = 0;
num = sum + '0';
}
result.push_back(num);// mod 10 on char?
sum = 0;
}
if(carry == 1){
num = carry + '0';
result.push_back(num);
}
// not yet made..
// trim_zeros(result);
return result;
//return 2;
}
bigint::bigvalue_t bigint::do_bigmult(const bigvalue_t& left, const bigvalue_t& right) {
bigvalue_t prod;
prod.resize(left.size() + right.size());
int carry = 0;
int d = 0;
for(int i = left.size()-1; i != -1; --i) {
carry = 0;
for(int j = right.size()-1; j != -1; --j) {
d = (prod.at((left.size()-1 -i) + (right.size()-1 - j))) + (left.at(i) * right.at(j)) + carry;
//cout << (prod.at((left.size()-1 - i) + (right.size()-1 - j))) << " new ";
//cout << (left.at(i) * right.at(j)) << " old ";
//cout << carry << "carry" << endl;
//cout << d << endl;
//cout << d%10 << "<--insert"<<endl;
//cout << d/10 << " carry" << endl;
prod.at((left.size()-1 - i) + (right.size()-1 - j)) = d % 10;
carry = d/10;
}
if(carry != 0) {
//cout << carry << "<- insert c"<<endl;
prod.at((right.size()-1) - -1) = carry;
}
}
//trim
return prod;
}
bool do_bigless(const bigvalue_t& left, const bigvalue_t& right){
auto l_itor = left.crbegin();
auto r_itor = right.crbegin();
if (left.size()<right.size()){return true;}
else if (left.size()>right.size()){return false;}
while (l_itor != left.crend()) {
if (*l_itor-'0' < *r_itor-'0'){return true;}
else if (*l_itor-'0' > *r_itor-'0'){return false;}
++l_itor;
++r_itor;
}
return false;
}
bigvalue_t do_bigmul(const bigvalue_t& left, const bigvalue_t& right){
int carry = 0;
digit_t digit = 0;
bigvalue_t prod;
prod.reserve(left.size() + right.size());
for (size_t i=0; i<left.size(); ++i) {
carry = 0;
for (size_t j=0; j<right.size(); ++j) {
digit = prod.at(i+j) + left.at(i)*right.at(j) + carry;
prod.at(i+j) = digit % 10;
carry = digit / 10;
}
prod.at(i+right.size()) = carry;
}
return prod;
}
bool bigint::do_bigabs_less (const bigvalue_t& left, const bigvalue_t& right) {
if(right.size() > left.size()) {
return true;
}
bigvalue_t::const_reverse_iterator left_it = left.rbegin();
bigvalue_t::const_reverse_iterator right_it = right.rbegin();
bigvalue_t::const_reverse_iterator left_end = left.rend();
bigvalue_t::const_reverse_iterator right_end = right.rend();
while(left_it != left_end and right_it != right_end) {
if(*left_it > *right_it) {
return false;
}
else if (*left_it < *right_it) {
return true;
}
++left_it;
++right_it;
}
return false;
}
bigint::bigvalue_t bigint::do_bigadd(const bigvalue_t& left, const bigvalue_t& right) {
bigvalue_t sum;
int carry = 0;
bool left_empty = false;
bool right_empty = false;
bigvalue_t::const_reverse_iterator left_it = left.rbegin();
bigvalue_t::const_reverse_iterator right_it = right.rbegin();
bigvalue_t::const_reverse_iterator left_end = left.rend();
bigvalue_t::const_reverse_iterator right_end = right.rend();
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;
}
// false == left > right true == left < right
int bigint::do_bigless(const bigvalue_t& left, const bigvalue_t& right) {
bigvalue_t::const_reverse_iterator left_it = left.rbegin();
bigvalue_t::const_reverse_iterator right_it = right.rbegin();
bigvalue_t::const_reverse_iterator left_end = left.rend();
bigvalue_t::const_reverse_iterator right_end = right.rend();
if(left.size() > right.size()) {
return -1;
}
if(left.size() < right.size()) {
return 1;
}
while(left_it != left_end and right_it != right_end) {
if(*left_it > *right_it) {
return -1;
}
else if (*left_it < *right_it) {
return 1;
}
++left_it;
++right_it;
}
return 0;
}
bigint::bigvalue_t bigint::do_bigsub(const bigvalue_t& left, const bigvalue_t& right) {
bigvalue_t sum;
int carry = 0;
bool left_empty = false;
bool right_empty = false;
bigvalue_t::const_reverse_iterator left_it = left.rbegin();
bigvalue_t::const_reverse_iterator right_it = right.rbegin();
bigvalue_t::const_reverse_iterator left_end = left.rend();
bigvalue_t::const_reverse_iterator right_end = right.rend();
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;
}