Number Number::operator[](const Range &range) const
{
int left = range.left();
int right = range.right();
if (left == 0 || right == 0)
throw Exception("Number[0] operation is undefined (numbers are indexed 1..n)");
if (left < right)
throw Exception("Number[x..y] operation where x < y is undefined");
int lefti;
int righti;
if (left > 0) {
lefti = left + m_decimals - 1;
} else {
lefti = m_decimals + left;
}
if (right > 0) {
righti = right + m_decimals - 1;
} else {
righti = m_decimals + right;
}
if ((lefti < 0 || righti < 0) ||
(m_digits.size() <= static_cast<size_t>(lefti) || m_digits.size() <= static_cast<size_t>(righti)))
throw Exception("Number[x..y] out of bounds");
Number out;
out.m_accuracy = m_accuracy;
out.m_precision = m_precision;
out.m_digits.clear();
out.m_digits.insert(out.m_digits.begin(), m_digits.cbegin() + righti, m_digits.cbegin() + lefti + 1);
if (left > 0 && right < 0) {
out.m_decimals = right * (-1);
}
out.m_trailingZeros = out.normalize();
return out;
}
Number Number::inverse() const
{
// dzielenie przez 0
if (isNull())
throw Exception("Divison by 0 detected");
// wynikowa liczba
Number result;
result.m_digits.clear();
result.m_precision = m_precision;
result.m_accuracy = m_accuracy;
result.m_negative = m_negative;
// dzieląca liczba
Number integer = *this;
int shiftBy = m_decimals;
if (m_decimals > 0) {
if (m_digits.size() >= static_cast<size_t>(m_precision)) {
int cut = (m_digits.size() - m_precision);
if (cut <= m_decimals) {
integer.m_digits.erase(integer.m_digits.begin(), integer.m_digits.begin() + cut);
integer.m_decimals -= cut;
shiftBy -= cut;
}
}
integer.shift(shiftBy);
}
// szukanie odwrotności 0.(dowolna ilość zer)1, lub jedynki
if (integer.m_digits.size() == 1 && integer.m_digits.front() == 1) {
result.m_digits.push_back(1);
result.shift(m_decimals);
return result;
}
// tymczasowa
Number tmp(10);
// jako że wrzucamy odwrotnie ...
std::deque<char> numbers;
int digit = 0;
do {
int cmp = tmp.compareWith(integer, true);
if (cmp <= 0) {
++digit;
tmp.subtract(integer, true);
} else {
numbers.push_front(digit);
result.m_decimals++;
digit = 0;
tmp.shift(1);
}
} while(result.m_decimals <= m_precision && !tmp.isNull());
if (digit > 0) {
numbers.push_front(digit);
result.m_decimals++;
}
// teraz dodajemy do liczby
result.m_digits.insert(result.m_digits.begin(), numbers.begin(), numbers.end());
result.m_digits.push_back(0);
// 1 / 0,321 = 1000 * (1 / 321)
result.shift(shiftBy);
// dokładność
if (m_accuracy > 0) {
// todo: sprawdzić czy nie ma ładniejszego sposobu (jakiś range iterator?)
int zeros = result.m_digits.size() - result.m_decimals - m_accuracy;
for (auto li = result.m_digits.begin() + result.m_decimals; zeros > 0; li++, zeros--) {
*li = 0;
}
}
// sprzątanie
result.normalize();
return result;
}