diff --git a/src/CalcManager/CEngine/CalcInput.cpp b/src/CalcManager/CEngine/CalcInput.cpp index c4f9c9d..707a36e 100644 --- a/src/CalcManager/CEngine/CalcInput.cpp +++ b/src/CalcManager/CEngine/CalcInput.cpp @@ -307,7 +307,7 @@ Rational CalcInput::ToRational(uint32_t radix, int32_t precision) PRAT rat = StringToRat(m_base.IsNegative(), m_base.value, m_exponent.IsNegative(), m_exponent.value, radix, precision); if (rat == nullptr) { - return Rational{}; + return 0; } Rational result{ rat }; diff --git a/src/CalcManager/CEngine/Rational.cpp b/src/CalcManager/CEngine/Rational.cpp index 08d93a1..20bf990 100644 --- a/src/CalcManager/CEngine/Rational.cpp +++ b/src/CalcManager/CEngine/Rational.cpp @@ -50,12 +50,12 @@ namespace CalcEngine destroyrat(pr); } - Rational::Rational(uint64_t ui, uint32_t radix, int32_t precision) + Rational::Rational(uint64_t ui, int32_t precision) { uint32_t hi = HIDWORD(ui); uint32_t lo = LODWORD(ui); - Rational temp = Rational{ hi }.Lsh(32, radix, precision).Or(lo, radix, precision); + Rational temp = Rational{ hi }.Lsh(32, precision).Or(lo, precision); m_p = Number{ temp.P() }; m_q = Number{ temp.Q() }; @@ -206,14 +206,14 @@ namespace CalcEngine return result; } - Rational Rational::Lsh(Rational const& rhs, uint32_t radix, int32_t precision) const + Rational Rational::Lsh(Rational const& rhs, int32_t precision) const { PRAT lhsRat = this->ToPRAT(); PRAT rhsRat = rhs.ToPRAT(); try { - lshrat(&lhsRat, rhsRat, radix, precision); + lshrat(&lhsRat, rhsRat, RATIONAL_BASE, precision); destroyrat(rhsRat); } catch (DWORD error) @@ -229,14 +229,14 @@ namespace CalcEngine return result; } - Rational Rational::Rsh(Rational const& rhs, uint32_t radix, int32_t precision) const + Rational Rational::Rsh(Rational const& rhs, int32_t precision) const { PRAT lhsRat = this->ToPRAT(); PRAT rhsRat = rhs.ToPRAT(); try { - rshrat(&lhsRat, rhsRat, radix, precision); + rshrat(&lhsRat, rhsRat, RATIONAL_BASE, precision); destroyrat(rhsRat); } catch (DWORD error) @@ -252,32 +252,19 @@ namespace CalcEngine return result; } - Rational Rational::Not(bool isIntegerMode, Rational const& chopNum, uint32_t radix, int32_t precision) const + Rational Rational::Not(Rational const& chopNum, int32_t precision) const { - Rational result{}; - - if (radix == 10 && !isIntegerMode) - { - result = RationalMath::Integer(*this, radix, precision); - result = result.Add(1, precision); - result = result.Negate(); - } - else - { - result = this->Xor(chopNum, radix, precision); - } - - return result; + return this->Xor(chopNum, precision); } - Rational Rational::And(Rational const& rhs, uint32_t radix, int32_t precision) const + Rational Rational::And(Rational const& rhs, int32_t precision) const { PRAT lhsRat = this->ToPRAT(); PRAT rhsRat = rhs.ToPRAT(); try { - andrat(&lhsRat, rhsRat, radix, precision); + andrat(&lhsRat, rhsRat, RATIONAL_BASE, precision); destroyrat(rhsRat); } catch (DWORD error) @@ -293,13 +280,13 @@ namespace CalcEngine return result; } - Rational Rational::Or(Rational const& rhs, uint32_t radix, int32_t precision) const + Rational Rational::Or(Rational const& rhs, int32_t precision) const { PRAT lhsRat = this->ToPRAT(); PRAT rhsRat = rhs.ToPRAT(); try { - orrat(&lhsRat, rhsRat, radix, precision); + orrat(&lhsRat, rhsRat, RATIONAL_BASE, precision); destroyrat(rhsRat); } catch (DWORD error) @@ -315,13 +302,13 @@ namespace CalcEngine return result; } - Rational Rational::Xor(Rational const& rhs, uint32_t radix, int32_t precision) const + Rational Rational::Xor(Rational const& rhs, int32_t precision) const { PRAT lhsRat = this->ToPRAT(); PRAT rhsRat = rhs.ToPRAT(); try { - xorrat(&lhsRat, rhsRat, radix, precision); + xorrat(&lhsRat, rhsRat, RATIONAL_BASE, precision); destroyrat(rhsRat); } catch (DWORD error) @@ -454,13 +441,13 @@ namespace CalcEngine return result; } - uint64_t Rational::ToUInt64_t(uint32_t radix, int32_t precision) const + uint64_t Rational::ToUInt64_t(int32_t precision) const { PRAT rat = this->ToPRAT(); uint64_t result; try { - result = rattoUlonglong(rat, radix, precision); + result = rattoUlonglong(rat, RATIONAL_BASE, precision); } catch (DWORD error) { diff --git a/src/CalcManager/CEngine/calc.cpp b/src/CalcManager/CEngine/calc.cpp index afbae25..e0f7b0e 100644 --- a/src/CalcManager/CEngine/calc.cpp +++ b/src/CalcManager/CEngine/calc.cpp @@ -95,7 +95,7 @@ CCalcEngine::CCalcEngine(bool fPrecedence, bool fIntegerMode, CalculationManager m_dwWordBitWidth = DwWordBitWidthFromeNumWidth(m_numwidth); - m_maxTrigonometricNum = RationalMath::Pow(10, 100, m_radix, m_precision); + m_maxTrigonometricNum = RationalMath::Pow(10, 100, m_precision); SetRadixTypeAndNumWidth(DEC_RADIX, m_numwidth); SettingsChanged(); @@ -118,7 +118,7 @@ void CCalcEngine::InitChopNumbers() for (size_t i = 0; i < m_chopNumbers.size(); i++) { auto maxVal = m_chopNumbers[i].Div(2, m_precision); - maxVal = RationalMath::Integer(maxVal, m_radix, m_precision); + maxVal = RationalMath::Integer(maxVal, m_precision); m_maxDecimalValueStrings[i] = maxVal.ToString(10, FMT_FLOAT, m_precision); } diff --git a/src/CalcManager/CEngine/scicomm.cpp b/src/CalcManager/CEngine/scicomm.cpp index 1630371..71ea956 100644 --- a/src/CalcManager/CEngine/scicomm.cpp +++ b/src/CalcManager/CEngine/scicomm.cpp @@ -1048,12 +1048,12 @@ wstring CCalcEngine::GetStringForDisplay(Rational const& rat, uint32_t radix) try { - uint64_t w64Bits = tempRat.ToUInt64_t(m_radix, m_precision); + uint64_t w64Bits = tempRat.ToUInt64_t(m_precision); bool fMsb = ((w64Bits >> (m_dwWordBitWidth - 1)) & 1); if ((radix == 10) && fMsb) { // If high bit is set, then get the decimal number in negative 2's compl form. - tempRat = tempRat.Not(true, m_chopNumbers[m_numwidth], m_radix, m_precision); + tempRat = tempRat.Not(m_chopNumbers[m_numwidth], m_precision); tempRat = tempRat.Add(1, m_precision); tempRat = tempRat.Negate(); } diff --git a/src/CalcManager/CEngine/scidisp.cpp b/src/CalcManager/CEngine/scidisp.cpp index b1f26e3..669fcdb 100644 --- a/src/CalcManager/CEngine/scidisp.cpp +++ b/src/CalcManager/CEngine/scidisp.cpp @@ -57,7 +57,7 @@ CalcEngine::Rational CCalcEngine::TruncateNumForIntMath(CalcEngine::Rational con } // Truncate to an integer. Do not round here. - auto result = RationalMath::Integer(rat, m_radix, m_precision); + auto result = RationalMath::Integer(rat, m_precision); // Can be converting a dec negative number to Hex/Oct/Bin rep. Use 2's complement form // Check the range. @@ -66,10 +66,10 @@ CalcEngine::Rational CCalcEngine::TruncateNumForIntMath(CalcEngine::Rational con // if negative make positive by doing a twos complement result = result.Negate(); result = result.Sub(1, m_precision); - result = result.Not(true /* IntegerMode */, m_chopNumbers[m_numwidth], m_radix, m_precision); + result = result.Not(m_chopNumbers[m_numwidth], m_precision); } - result = result.And(m_chopNumbers[m_numwidth], m_radix, m_precision); + result = result.And(m_chopNumbers[m_numwidth], m_precision); return result; } diff --git a/src/CalcManager/CEngine/scifunc.cpp b/src/CalcManager/CEngine/scifunc.cpp index 26daf23..d3eb62f 100644 --- a/src/CalcManager/CEngine/scifunc.cpp +++ b/src/CalcManager/CEngine/scifunc.cpp @@ -32,26 +32,35 @@ CalcEngine::Rational CCalcEngine::SciCalcFunctions(CalcEngine::Rational const& r switch (op) { case IDC_CHOP: - result = m_bInv ? Frac(rat, m_radix, m_precision) : Integer(rat, m_radix, m_precision); + result = m_bInv ? Frac(rat, m_precision) : Integer(rat, m_precision); break; /* Return complement. */ case IDC_COM: - result = rat.Not(m_fIntegerMode, m_chopNumbers[m_numwidth], m_radix, m_precision); + if (m_radix == 10 && !m_fIntegerMode) + { + result = RationalMath::Integer(rat, m_precision); + result = result.Add(1, m_precision); + result = result.Negate(); + } + else + { + result = rat.Xor(m_chopNumbers[m_numwidth], m_precision); + } break; // Rotate Left with hi bit wrapped over to lo bit case IDC_ROL: if (m_fIntegerMode) { - result = Integer(rat, m_radix, m_precision); + result = Integer(rat, m_precision); - uint64_t w64Bits = result.ToUInt64_t(m_radix, m_precision); + uint64_t w64Bits = result.ToUInt64_t(m_precision); uint64_t msb = (w64Bits >> (m_dwWordBitWidth - 1)) & 1; w64Bits <<= 1; // LShift by 1 w64Bits |= msb; // Set the prev Msb as the current Lsb - result = Rational{ w64Bits, m_radix, m_precision }; + result = Rational{ w64Bits, m_precision }; } break; @@ -59,14 +68,14 @@ CalcEngine::Rational CCalcEngine::SciCalcFunctions(CalcEngine::Rational const& r case IDC_ROR: if (m_fIntegerMode) { - result = Integer(rat, m_radix, m_precision); + result = Integer(rat, m_precision); - uint64_t w64Bits = result.ToUInt64_t(m_radix, m_precision); + uint64_t w64Bits = result.ToUInt64_t(m_precision); uint64_t lsb = ((w64Bits & 0x01) == 1) ? 1 : 0; w64Bits >>= 1; //RShift by 1 w64Bits |= (lsb << (m_dwWordBitWidth - 1)); - result = Rational{ w64Bits, m_radix, m_precision }; + result = Rational{ w64Bits, m_precision }; } break; @@ -89,42 +98,42 @@ CalcEngine::Rational CCalcEngine::SciCalcFunctions(CalcEngine::Rational const& r case IDC_SIN: /* Sine; normal and arc */ if (!m_fIntegerMode) { - result = m_bInv ? ASin(rat, m_angletype, m_radix, m_precision) : Sin(rat, m_angletype, m_radix, m_precision); + result = m_bInv ? ASin(rat, m_angletype, m_precision) : Sin(rat, m_angletype, m_precision); } break; case IDC_SINH: /* Sine- hyperbolic and archyperbolic */ if (!m_fIntegerMode) { - result = m_bInv ? ASinh(rat, m_radix, m_precision) : Sinh(rat, m_radix, m_precision); + result = m_bInv ? ASinh(rat, m_precision) : Sinh(rat, m_precision); } break; case IDC_COS: /* Cosine, follows convention of sine function. */ if (!m_fIntegerMode) { - result = m_bInv ? ACos(rat, m_angletype, m_radix, m_precision) : Cos(rat, m_angletype, m_radix, m_precision); + result = m_bInv ? ACos(rat, m_angletype, m_precision) : Cos(rat, m_angletype, m_precision); } break; case IDC_COSH: /* Cosine hyperbolic, follows convention of sine h function. */ if (!m_fIntegerMode) { - result = m_bInv ? ACosh(rat, m_radix, m_precision) : Cosh(rat, m_radix, m_precision); + result = m_bInv ? ACosh(rat, m_precision) : Cosh(rat, m_precision); } break; case IDC_TAN: /* Same as sine and cosine. */ if (!m_fIntegerMode) { - result = m_bInv ? ATan(rat, m_angletype, m_radix, m_precision) : Tan(rat, m_angletype, m_radix, m_precision); + result = m_bInv ? ATan(rat, m_angletype, m_precision) : Tan(rat, m_angletype, m_precision); } break; case IDC_TANH: /* Same as sine h and cosine h. */ if (!m_fIntegerMode) { - result = m_bInv ? ATanh(rat, m_precision) : Tanh(rat, m_radix, m_precision); + result = m_bInv ? ATanh(rat, m_precision) : Tanh(rat, m_precision); } break; @@ -133,16 +142,16 @@ CalcEngine::Rational CCalcEngine::SciCalcFunctions(CalcEngine::Rational const& r break; case IDC_SQR: /* Square */ - result = Pow(rat, 2, m_radix, m_precision); + result = Pow(rat, 2, m_precision); break; case IDC_SQRT: /* Square Root */ - result = Root(rat, 2, m_radix, m_precision); + result = Root(rat, 2, m_precision); break; case IDC_CUBEROOT: case IDC_CUB: /* Cubing and cube root functions. */ - result = IDC_CUBEROOT == op ? Root(rat, 3, m_radix, m_precision) : Pow(rat, 3, m_radix, m_precision); + result = IDC_CUBEROOT == op ? Root(rat, 3, m_precision) : Pow(rat, 3, m_precision); break; case IDC_LOG: /* Functions for common log. */ @@ -150,15 +159,15 @@ CalcEngine::Rational CCalcEngine::SciCalcFunctions(CalcEngine::Rational const& r break; case IDC_POW10: - result = Pow(10, rat, m_radix, m_precision); + result = Pow(10, rat, m_precision); break; case IDC_LN: /* Functions for natural log. */ - result = m_bInv ? Exp(rat, m_radix, m_precision) : Log(rat, m_precision); + result = m_bInv ? Exp(rat, m_precision) : Log(rat, m_precision); break; case IDC_FAC: /* Calculate factorial. Inverse is ineffective. */ - result = Fact(rat, m_radix, m_precision); + result = Fact(rat, m_precision); break; case IDC_DEGREES: @@ -173,14 +182,14 @@ CalcEngine::Rational CCalcEngine::SciCalcFunctions(CalcEngine::Rational const& r { Rational shftRat{ m_bInv ? 100 : 60 }; - Rational degreeRat = Integer(rat, m_radix, m_precision); + Rational degreeRat = Integer(rat, m_precision); Rational minuteRat = rat.Sub(degreeRat, m_precision); minuteRat = minuteRat.Mul(shftRat, m_precision); Rational secondRat = minuteRat; - minuteRat = Integer(minuteRat, m_radix, m_precision); + minuteRat = Integer(minuteRat, m_precision); secondRat = secondRat.Sub(minuteRat, m_precision); secondRat = secondRat.Mul(shftRat, m_precision); diff --git a/src/CalcManager/CEngine/scimath.cpp b/src/CalcManager/CEngine/scimath.cpp index 7e922dd..15908f6 100644 --- a/src/CalcManager/CEngine/scimath.cpp +++ b/src/CalcManager/CEngine/scimath.cpp @@ -8,12 +8,12 @@ using namespace std; using namespace CalcEngine; -Rational RationalMath::Frac(Rational const& rat, uint32_t radix, int32_t precision) +Rational RationalMath::Frac(Rational const& rat, int32_t precision) { PRAT prat = rat.ToPRAT(); try { - fracrat(&prat, radix, precision); + fracrat(&prat, RATIONAL_BASE, precision); } catch (DWORD error) { @@ -27,12 +27,12 @@ Rational RationalMath::Frac(Rational const& rat, uint32_t radix, int32_t precisi return result; } -Rational RationalMath::Integer(Rational const& rat, uint32_t radix, int32_t precision) +Rational RationalMath::Integer(Rational const& rat, int32_t precision) { PRAT prat = rat.ToPRAT(); try { - intrat(&prat, radix, precision); + intrat(&prat, RATIONAL_BASE, precision); } catch (DWORD error) { @@ -46,14 +46,14 @@ Rational RationalMath::Integer(Rational const& rat, uint32_t radix, int32_t prec return result; } -Rational RationalMath::Pow(Rational const& base, Rational const& pow, uint32_t radix, int32_t precision) +Rational RationalMath::Pow(Rational const& base, Rational const& pow, int32_t precision) { PRAT baseRat = base.ToPRAT(); PRAT powRat = pow.ToPRAT(); try { - powrat(&baseRat, powRat, radix, precision); + powrat(&baseRat, powRat, RATIONAL_BASE, precision); destroyrat(powRat); } catch (DWORD error) @@ -69,18 +69,18 @@ Rational RationalMath::Pow(Rational const& base, Rational const& pow, uint32_t r return result; } -Rational RationalMath::Root(Rational const& base, Rational const& root, uint32_t radix, int32_t precision) +Rational RationalMath::Root(Rational const& base, Rational const& root, int32_t precision) { - return Pow(base, Invert(root, precision), radix, precision); + return Pow(base, Invert(root, precision), precision); } -Rational RationalMath::Fact(Rational const& rat, uint32_t radix, int32_t precision) +Rational RationalMath::Fact(Rational const& rat, int32_t precision) { PRAT prat = rat.ToPRAT(); try { - factrat(&prat, radix, precision); + factrat(&prat, RATIONAL_BASE, precision); } catch (DWORD error) { @@ -94,13 +94,13 @@ Rational RationalMath::Fact(Rational const& rat, uint32_t radix, int32_t precisi return result; } -Rational RationalMath::Exp(Rational const& rat, uint32_t radix, int32_t precision) +Rational RationalMath::Exp(Rational const& rat, int32_t precision) { PRAT prat = rat.ToPRAT(); try { - exprat(&prat, radix, precision); + exprat(&prat, RATIONAL_BASE, precision); } catch (DWORD error) { @@ -149,13 +149,13 @@ Rational RationalMath::Abs(Rational const& rat) return Rational{ Number{ 1, rat.P().Exp(), rat.P().Mantissa() }, Number{ 1, rat.Q().Exp(), rat.Q().Mantissa() } }; } -Rational RationalMath::Sin(Rational const& rat, ANGLE_TYPE angletype, uint32_t radix, int32_t precision) +Rational RationalMath::Sin(Rational const& rat, ANGLE_TYPE angletype, int32_t precision) { PRAT prat = rat.ToPRAT(); try { - sinanglerat(&prat, angletype, radix, precision); + sinanglerat(&prat, angletype, RATIONAL_BASE, precision); } catch (DWORD error) { @@ -169,13 +169,13 @@ Rational RationalMath::Sin(Rational const& rat, ANGLE_TYPE angletype, uint32_t r return result; } -Rational RationalMath::Cos(Rational const& rat, ANGLE_TYPE angletype, uint32_t radix, int32_t precision) +Rational RationalMath::Cos(Rational const& rat, ANGLE_TYPE angletype, int32_t precision) { PRAT prat = rat.ToPRAT(); try { - cosanglerat(&prat, angletype, radix, precision); + cosanglerat(&prat, angletype, RATIONAL_BASE, precision); } catch (DWORD error) { @@ -189,13 +189,13 @@ Rational RationalMath::Cos(Rational const& rat, ANGLE_TYPE angletype, uint32_t r return result; } -Rational RationalMath::Tan(Rational const& rat, ANGLE_TYPE angletype, uint32_t radix, int32_t precision) +Rational RationalMath::Tan(Rational const& rat, ANGLE_TYPE angletype, int32_t precision) { PRAT prat = rat.ToPRAT(); try { - tananglerat(&prat, angletype, radix, precision); + tananglerat(&prat, angletype, RATIONAL_BASE, precision); } catch (DWORD error) { @@ -209,13 +209,13 @@ Rational RationalMath::Tan(Rational const& rat, ANGLE_TYPE angletype, uint32_t r return result; } -Rational RationalMath::ASin(Rational const& rat, ANGLE_TYPE angletype, uint32_t radix, int32_t precision) +Rational RationalMath::ASin(Rational const& rat, ANGLE_TYPE angletype, int32_t precision) { PRAT prat = rat.ToPRAT(); try { - asinanglerat(&prat, angletype, radix, precision); + asinanglerat(&prat, angletype, RATIONAL_BASE, precision); } catch (DWORD error) { @@ -229,13 +229,13 @@ Rational RationalMath::ASin(Rational const& rat, ANGLE_TYPE angletype, uint32_t return result; } -Rational RationalMath::ACos(Rational const& rat, ANGLE_TYPE angletype, uint32_t radix, int32_t precision) +Rational RationalMath::ACos(Rational const& rat, ANGLE_TYPE angletype, int32_t precision) { PRAT prat = rat.ToPRAT(); try { - acosanglerat(&prat, angletype, radix, precision); + acosanglerat(&prat, angletype, RATIONAL_BASE, precision); } catch (DWORD error) { @@ -249,13 +249,13 @@ Rational RationalMath::ACos(Rational const& rat, ANGLE_TYPE angletype, uint32_t return result; } -Rational RationalMath::ATan(Rational const& rat, ANGLE_TYPE angletype, uint32_t radix, int32_t precision) +Rational RationalMath::ATan(Rational const& rat, ANGLE_TYPE angletype, int32_t precision) { PRAT prat = rat.ToPRAT(); try { - atananglerat(&prat, angletype, radix, precision); + atananglerat(&prat, angletype, RATIONAL_BASE, precision); } catch (DWORD error) { @@ -269,13 +269,13 @@ Rational RationalMath::ATan(Rational const& rat, ANGLE_TYPE angletype, uint32_t return result; } -Rational RationalMath::Sinh(Rational const& rat, uint32_t radix, int32_t precision) +Rational RationalMath::Sinh(Rational const& rat, int32_t precision) { PRAT prat = rat.ToPRAT(); try { - sinhrat(&prat, radix, precision); + sinhrat(&prat, RATIONAL_BASE, precision); } catch (DWORD error) { @@ -289,13 +289,13 @@ Rational RationalMath::Sinh(Rational const& rat, uint32_t radix, int32_t precisi return result; } -Rational RationalMath::Cosh(Rational const& rat, uint32_t radix, int32_t precision) +Rational RationalMath::Cosh(Rational const& rat, int32_t precision) { PRAT prat = rat.ToPRAT(); try { - coshrat(&prat, radix, precision); + coshrat(&prat, RATIONAL_BASE, precision); } catch (DWORD error) { @@ -309,13 +309,13 @@ Rational RationalMath::Cosh(Rational const& rat, uint32_t radix, int32_t precisi return result; } -Rational RationalMath::Tanh(Rational const& rat, uint32_t radix, int32_t precision) +Rational RationalMath::Tanh(Rational const& rat, int32_t precision) { PRAT prat = rat.ToPRAT(); try { - tanhrat(&prat, radix, precision); + tanhrat(&prat, RATIONAL_BASE, precision); } catch (DWORD error) { @@ -329,13 +329,13 @@ Rational RationalMath::Tanh(Rational const& rat, uint32_t radix, int32_t precisi return result; } -Rational RationalMath::ASinh(Rational const& rat, uint32_t radix, int32_t precision) +Rational RationalMath::ASinh(Rational const& rat, int32_t precision) { PRAT prat = rat.ToPRAT(); try { - asinhrat(&prat, radix, precision); + asinhrat(&prat, RATIONAL_BASE, precision); } catch (DWORD error) { @@ -349,13 +349,13 @@ Rational RationalMath::ASinh(Rational const& rat, uint32_t radix, int32_t precis return result; } -Rational RationalMath::ACosh(Rational const& rat, uint32_t radix, int32_t precision) +Rational RationalMath::ACosh(Rational const& rat, int32_t precision) { PRAT prat = rat.ToPRAT(); try { - acoshrat(&prat, radix, precision); + acoshrat(&prat, RATIONAL_BASE, precision); } catch (DWORD error) { diff --git a/src/CalcManager/CEngine/scioper.cpp b/src/CalcManager/CEngine/scioper.cpp index fae2f15..59dbb57 100644 --- a/src/CalcManager/CEngine/scioper.cpp +++ b/src/CalcManager/CEngine/scioper.cpp @@ -18,15 +18,15 @@ CalcEngine::Rational CCalcEngine::DoOperation(int operation, CalcEngine::Rationa switch (operation) { case IDC_AND: - result = result.And(rhs, m_radix, m_precision); + result = result.And(rhs, m_precision); break; case IDC_OR: - result = result.Or(rhs, m_radix, m_precision); + result = result.Or(rhs, m_precision); break; case IDC_XOR: - result = result.Xor(rhs, m_radix, m_precision); + result = result.Xor(rhs, m_precision); break; case IDC_RSHF: @@ -36,21 +36,21 @@ CalcEngine::Rational CCalcEngine::DoOperation(int operation, CalcEngine::Rationa throw CALC_E_NORESULT; } - uint64_t w64Bits = rhs.ToUInt64_t(m_radix, m_precision); + uint64_t w64Bits = rhs.ToUInt64_t(m_precision); bool fMsb = (w64Bits >> (m_dwWordBitWidth - 1)) & 1; Rational holdVal = result; - result = rhs.Rsh(holdVal, m_radix, m_precision); + result = rhs.Rsh(holdVal, m_precision); if (fMsb) { - result = Integer(result, m_radix, m_precision); + result = Integer(result, m_precision); - auto tempRat = m_chopNumbers[m_numwidth].Rsh(holdVal, m_radix, m_precision); - tempRat = Integer(tempRat, m_radix, m_precision); + auto tempRat = m_chopNumbers[m_numwidth].Rsh(holdVal, m_precision); + tempRat = Integer(tempRat, m_precision); - tempRat = tempRat.Xor(m_chopNumbers[m_numwidth], m_radix, m_precision); - result = result.Or(tempRat, m_radix, m_precision); + tempRat = tempRat.Xor(m_chopNumbers[m_numwidth], m_precision); + result = result.Or(tempRat, m_precision); } break; } @@ -61,7 +61,7 @@ CalcEngine::Rational CCalcEngine::DoOperation(int operation, CalcEngine::Rationa throw CALC_E_NORESULT; } - result = rhs.Lsh(result, m_radix, m_precision); + result = rhs.Lsh(result, m_precision); break; case IDC_ADD: @@ -85,23 +85,23 @@ CalcEngine::Rational CCalcEngine::DoOperation(int operation, CalcEngine::Rationa if (m_fIntegerMode) { - uint64_t w64Bits = rhs.ToUInt64_t(m_radix, m_precision); + uint64_t w64Bits = rhs.ToUInt64_t(m_precision); bool fMsb = (w64Bits >> (m_dwWordBitWidth - 1)) & 1; if (fMsb) { - result = rhs.Not(true /* IntegerMode */, m_chopNumbers[m_numwidth], m_radix, m_precision); + result = rhs.Not(m_chopNumbers[m_numwidth], m_precision); result = result.Add(1, m_precision); iNumeratorSign = -1; } - w64Bits = temp.ToUInt64_t(m_radix, m_precision); + w64Bits = temp.ToUInt64_t(m_precision); fMsb = (w64Bits >> (m_dwWordBitWidth - 1)) & 1; if (fMsb) { - temp = temp.Not(true /* IntegerMode */, m_chopNumbers[m_numwidth], m_radix, m_precision); + temp = temp.Not(m_chopNumbers[m_numwidth], m_precision); temp = temp.Add(1, m_precision); iDenominatorSign = -1; @@ -121,18 +121,18 @@ CalcEngine::Rational CCalcEngine::DoOperation(int operation, CalcEngine::Rationa if (m_fIntegerMode && iFinalSign == -1) { - result = Integer(result, m_radix, m_precision).Negate(); + result = Integer(result, m_precision).Negate(); } break; } case IDC_PWR: // Calculates rhs to the result(th) power. - result = Pow(rhs, result, m_radix, m_precision); + result = Pow(rhs, result, m_precision); break; case IDC_ROOT: // Calculates rhs to the result(th) root. - result = Root(rhs, result, m_radix, m_precision); + result = Root(rhs, result, m_precision); break; } } diff --git a/src/CalcManager/CEngine/sciset.cpp b/src/CalcManager/CEngine/sciset.cpp index 319a2a4..716bba1 100644 --- a/src/CalcManager/CEngine/sciset.cpp +++ b/src/CalcManager/CEngine/sciset.cpp @@ -18,13 +18,13 @@ void CCalcEngine::SetRadixTypeAndNumWidth(RADIX_TYPE radixtype, NUM_WIDTH numwid // back to 1111,1111,1000,0001 when in Word mode. if (m_fIntegerMode) { - uint64_t w64Bits = m_currentVal.ToUInt64_t(m_radix, m_precision); + uint64_t w64Bits = m_currentVal.ToUInt64_t(m_precision); bool fMsb = (w64Bits >> (m_dwWordBitWidth - 1)) & 1; // make sure you use the old width if (fMsb) { // If high bit is set, then get the decimal number in -ve 2'scompl form. - auto tempResult = m_currentVal.Not(true /* IntegerMode */, m_chopNumbers[m_numwidth], m_radix, m_precision); + auto tempResult = m_currentVal.Not(m_chopNumbers[m_numwidth], m_precision); tempResult = tempResult.Add(1, m_precision); m_currentVal = tempResult.Negate(); @@ -85,7 +85,7 @@ bool CCalcEngine::TryToggleBit(CalcEngine::Rational& rat, DWORD wbitno) return false; // ignore error cant happen } - Rational result = Integer(rat, m_radix, m_precision); + Rational result = Integer(rat, m_precision); if (result.IsZero()) { // This is the same work around happenning in SciCalcFunctions. Ought to move to intrat function itself. @@ -93,8 +93,8 @@ bool CCalcEngine::TryToggleBit(CalcEngine::Rational& rat, DWORD wbitno) result = Rational{}; } - auto pow = Pow(2, static_cast(wbitno), m_radix, m_precision); - rat = result.Xor(pow, m_radix, m_precision); + auto pow = Pow(2, static_cast(wbitno), m_precision); + rat = result.Xor(pow, m_precision); return true; } diff --git a/src/CalcManager/Header Files/Rational.h b/src/CalcManager/Header Files/Rational.h index ac8bfca..aea8ce4 100644 --- a/src/CalcManager/Header Files/Rational.h +++ b/src/CalcManager/Header Files/Rational.h @@ -6,6 +6,10 @@ namespace CalcEngine { + // Default Base/Radix to use for Rational calculations + // RatPack calculations currently support up to Base64. + inline constexpr uint32_t RATIONAL_BASE = 10; + class Rational { public: @@ -14,7 +18,7 @@ namespace CalcEngine Rational(Number const& p, Number const& q) noexcept; Rational(int32_t i); Rational(uint32_t ui); - Rational(uint64_t ui, uint32_t radix, int32_t precision); + Rational(uint64_t ui, int32_t precision); explicit Rational(PRAT prat) noexcept; PRAT ToPRAT() const; @@ -29,13 +33,13 @@ namespace CalcEngine Rational Div(Rational const& rhs, int32_t precision) const; Rational Mod(Rational const& rhs) const; - Rational Lsh(Rational const& r, uint32_t radix, int32_t precision) const; - Rational Rsh(Rational const& r, uint32_t radix, int32_t precision) const; + Rational Lsh(Rational const& r, int32_t precision) const; + Rational Rsh(Rational const& r, int32_t precision) const; - Rational Not(bool isIntegerMode, Rational const& chopNum, uint32_t radix, int32_t precision) const; - Rational And(Rational const& r, uint32_t radix, int32_t precision) const; - Rational Or(Rational const& r, uint32_t radix, int32_t precision) const; - Rational Xor(Rational const& r, uint32_t radix, int32_t precision) const; + Rational Not(Rational const& chopNum, int32_t precision) const; + Rational And(Rational const& r, int32_t precision) const; + Rational Or(Rational const& r, int32_t precision) const; + Rational Xor(Rational const& r, int32_t precision) const; bool IsZero() const; bool IsLess(Rational const& r, int32_t precision) const; @@ -44,7 +48,7 @@ namespace CalcEngine bool IsEq(Rational const& r, int32_t precision) const; std::wstring ToString(uint32_t radix, NUMOBJ_FMT format, int32_t precision) const; - uint64_t ToUInt64_t(uint32_t radix, int32_t precision) const; + uint64_t ToUInt64_t(int32_t precision) const; private: Number m_p; diff --git a/src/CalcManager/Header Files/scimath.h b/src/CalcManager/Header Files/scimath.h index 8f0d164..e3726eb 100644 --- a/src/CalcManager/Header Files/scimath.h +++ b/src/CalcManager/Header Files/scimath.h @@ -5,31 +5,31 @@ namespace CalcEngine::RationalMath { - Rational Frac(Rational const& rat, uint32_t radix, int32_t precision); - Rational Integer(Rational const& rat, uint32_t radix, int32_t precision); + Rational Frac(Rational const& rat, int32_t precision); + Rational Integer(Rational const& rat, int32_t precision); - Rational Pow(Rational const& base, Rational const& pow, uint32_t radix, int32_t precision); - Rational Root(Rational const& base, Rational const& root, uint32_t radix, int32_t precision); - Rational Fact(Rational const& rat, uint32_t radix, int32_t precision); + Rational Pow(Rational const& base, Rational const& pow, int32_t precision); + Rational Root(Rational const& base, Rational const& root, int32_t precision); + Rational Fact(Rational const& rat, int32_t precision); - Rational Exp(Rational const& rat, uint32_t radix, int32_t precision); + Rational Exp(Rational const& rat, int32_t precision); Rational Log(Rational const& rat, int32_t precision); Rational Log10(Rational const& rat, int32_t precision); Rational Invert(Rational const& rat, int32_t precision); Rational Abs(Rational const& rat); - Rational Sin(Rational const& rat, ANGLE_TYPE angletype, uint32_t radix, int32_t precision); - Rational Cos(Rational const& rat, ANGLE_TYPE angletype, uint32_t radix, int32_t precision); - Rational Tan(Rational const& rat, ANGLE_TYPE angletype, uint32_t radix, int32_t precision); - Rational ASin(Rational const& rat, ANGLE_TYPE angletype, uint32_t radix, int32_t precision); - Rational ACos(Rational const& rat, ANGLE_TYPE angletype, uint32_t radix, int32_t precision); - Rational ATan(Rational const& rat, ANGLE_TYPE angletype, uint32_t radix, int32_t precision); + Rational Sin(Rational const& rat, ANGLE_TYPE angletype, int32_t precision); + Rational Cos(Rational const& rat, ANGLE_TYPE angletype, int32_t precision); + Rational Tan(Rational const& rat, ANGLE_TYPE angletype, int32_t precision); + Rational ASin(Rational const& rat, ANGLE_TYPE angletype, int32_t precision); + Rational ACos(Rational const& rat, ANGLE_TYPE angletype, int32_t precision); + Rational ATan(Rational const& rat, ANGLE_TYPE angletype, int32_t precision); - Rational Sinh(Rational const& rat, uint32_t radix, int32_t precision); - Rational Cosh(Rational const& rat, uint32_t radix, int32_t precision); - Rational Tanh(Rational const& rat, uint32_t radix, int32_t precision); - Rational ASinh(Rational const& rat, uint32_t radix, int32_t precision); - Rational ACosh(Rational const& rat, uint32_t radix, int32_t precision); + Rational Sinh(Rational const& rat, int32_t precision); + Rational Cosh(Rational const& rat, int32_t precision); + Rational Tanh(Rational const& rat, int32_t precision); + Rational ASinh(Rational const& rat, int32_t precision); + Rational ACosh(Rational const& rat, int32_t precision); Rational ATanh(Rational const& rat, int32_t precision); -} \ No newline at end of file +} diff --git a/src/CalcManager/Ratpack/conv.cpp b/src/CalcManager/Ratpack/conv.cpp index 789e021..57ec5bb 100644 --- a/src/CalcManager/Ratpack/conv.cpp +++ b/src/CalcManager/Ratpack/conv.cpp @@ -1,4 +1,4 @@ -// Copyright (c) Microsoft Corporation. All rights reserved. +// Copyright (c) Microsoft Corporation. All rights reserved. // Licensed under the MIT License. //--------------------------------------------------------------------------- @@ -347,6 +347,7 @@ PNUMBER numtonRadixx(_In_ PNUMBER a, uint32_t radix) // mantissa a string representation of a number // exponentIsNegative true if exponent is less than zero // exponent a string representation of a number +// radix is the number base used in the source string // // RETURN: PRAT representation of string input. // Or nullptr if no number scanned. diff --git a/src/CalcManager/Ratpack/rat.cpp b/src/CalcManager/Ratpack/rat.cpp index 3d1023d..ee294dc 100644 --- a/src/CalcManager/Ratpack/rat.cpp +++ b/src/CalcManager/Ratpack/rat.cpp @@ -1,4 +1,4 @@ -// Copyright (c) Microsoft Corporation. All rights reserved. +// Copyright (c) Microsoft Corporation. All rights reserved. // Licensed under the MIT License. //----------------------------------------------------------------------------- diff --git a/src/CalcManager/Ratpack/support.cpp b/src/CalcManager/Ratpack/support.cpp index 9ea60e0..81e17ec 100644 --- a/src/CalcManager/Ratpack/support.cpp +++ b/src/CalcManager/Ratpack/support.cpp @@ -1,4 +1,4 @@ -// Copyright (c) Microsoft Corporation. All rights reserved. +// Copyright (c) Microsoft Corporation. All rights reserved. // Licensed under the MIT License. //----------------------------------------------------------------------------