From 32fb8500cb845374c73a05d932ba2036ee92846c Mon Sep 17 00:00:00 2001 From: Josh Koon <45607479+joshkoon@users.noreply.github.com> Date: Thu, 21 Feb 2019 10:50:32 -0800 Subject: [PATCH 01/13] Fix Log10 function (#27) --- src/CalcManager/CEngine/scimath.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/CalcManager/CEngine/scimath.cpp b/src/CalcManager/CEngine/scimath.cpp index b1fc77a4..7e922dd8 100644 --- a/src/CalcManager/CEngine/scimath.cpp +++ b/src/CalcManager/CEngine/scimath.cpp @@ -136,7 +136,7 @@ Rational RationalMath::Log(Rational const& rat, int32_t precision) Rational RationalMath::Log10(Rational const& rat, int32_t precision) { - return Log(rat, precision).Div(10, precision); + return Log(rat, precision).Div(Rational{ ln_ten }, precision); } Rational RationalMath::Invert(Rational const& rat, int32_t precision) From 1302d51afe7fcd339e7fc74b0a371c283ed16e0b Mon Sep 17 00:00:00 2001 From: Matt Cooley Date: Thu, 21 Feb 2019 16:26:47 -0800 Subject: [PATCH 02/13] Update minor version to 1902 (#32) --- build/pipelines/azure-pipelines.release.yaml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/build/pipelines/azure-pipelines.release.yaml b/build/pipelines/azure-pipelines.release.yaml index 22d88994..59cd41c3 100644 --- a/build/pipelines/azure-pipelines.release.yaml +++ b/build/pipelines/azure-pipelines.release.yaml @@ -9,8 +9,8 @@ pr: none variables: versionMajor: 10 - versionMinor: 1901 - versionBuild: $[counter('10.1901.*', 500)] + versionMinor: 1902 + versionBuild: $[counter('10.1902.*', 0)] versionPatch: 0 name: '$(versionMajor).$(versionMinor).$(versionBuild).$(versionPatch)' From 5a530c4bed38fd3b5349a7472cf6c8ecd755b718 Mon Sep 17 00:00:00 2001 From: Josh Koon <45607479+joshkoon@users.noreply.github.com> Date: Thu, 21 Feb 2019 16:36:54 -0800 Subject: [PATCH 03/13] Change m_nPrecNum from int to size_t and rename to m_precedenceOpCount (#33) --- src/CalcManager/CEngine/calc.cpp | 2 +- src/CalcManager/CEngine/scicomm.cpp | 38 +++++++++++------------ src/CalcManager/Header Files/CalcEngine.h | 2 +- 3 files changed, 21 insertions(+), 21 deletions(-) diff --git a/src/CalcManager/CEngine/calc.cpp b/src/CalcManager/CEngine/calc.cpp index 229f2789..afbae25f 100644 --- a/src/CalcManager/CEngine/calc.cpp +++ b/src/CalcManager/CEngine/calc.cpp @@ -65,7 +65,7 @@ CCalcEngine::CCalcEngine(bool fPrecedence, bool fIntegerMode, CalculationManager m_nOpCode(0), m_nPrevOpCode(0), m_openParenCount(0), - m_nPrecNum(0), + m_precedenceOpCount(0), m_nTempCom(0), m_nLastCom(0), m_parenVals{}, diff --git a/src/CalcManager/CEngine/scicomm.cpp b/src/CalcManager/CEngine/scicomm.cpp index 9ecbdcb2..16303716 100644 --- a/src/CalcManager/CEngine/scicomm.cpp +++ b/src/CalcManager/CEngine/scicomm.cpp @@ -228,19 +228,19 @@ void CCalcEngine::ProcessCommandWorker(WPARAM wParam) if ((nx > ni) && m_fPrecedence) { - if (m_nPrecNum < MAXPRECDEPTH) + if (m_precedenceOpCount < MAXPRECDEPTH) { - m_precedenceVals[m_nPrecNum] = m_lastVal; + m_precedenceVals[m_precedenceOpCount] = m_lastVal; - m_nPrecOp[m_nPrecNum] = m_nOpCode; + m_nPrecOp[m_precedenceOpCount] = m_nOpCode; m_HistoryCollector.PushLastOpndStart(); // Eg. 1 + 2 *, Need to remember the start of 2 to do Precedence invertion if need to } else { - m_nPrecNum = MAXPRECDEPTH - 1; + m_precedenceOpCount = MAXPRECDEPTH - 1; HandleErrorCommand(wParam); } - m_nPrecNum++; + m_precedenceOpCount++; } else { @@ -256,12 +256,12 @@ void CCalcEngine::ProcessCommandWorker(WPARAM wParam) DisplayNum(); } - if ((m_nPrecNum != 0) && (m_nPrecOp[m_nPrecNum - 1])) + if ((m_precedenceOpCount != 0) && (m_nPrecOp[m_precedenceOpCount - 1])) { - m_nPrecNum--; - m_nOpCode = m_nPrecOp[m_nPrecNum]; + m_precedenceOpCount--; + m_nOpCode = m_nPrecOp[m_precedenceOpCount]; - m_lastVal = m_precedenceVals[m_nPrecNum]; + m_lastVal = m_precedenceVals[m_precedenceOpCount]; nx = NPrecedenceOfOp(m_nOpCode); // Precedence Invertion Higher to lower can happen which needs explicit enclosure of brackets @@ -385,7 +385,7 @@ void CCalcEngine::ProcessCommandWorker(WPARAM wParam) m_lastVal = Rational{}; m_bChangeOp = false; - m_nPrecNum = m_nTempCom = m_nLastCom = m_nOpCode = m_openParenCount = 0; + m_precedenceOpCount = m_nTempCom = m_nLastCom = m_nOpCode = m_openParenCount = 0; m_nPrevOpCode = 0; m_bNoPrevEqu = true; @@ -495,11 +495,11 @@ void CCalcEngine::ProcessCommandWorker(WPARAM wParam) else if (!m_bError) DisplayNum(); - if (m_nPrecNum == 0 || !m_fPrecedence) + if (m_precedenceOpCount == 0 || !m_fPrecedence) break; - m_nOpCode = m_nPrecOp[--m_nPrecNum]; - m_lastVal = m_precedenceVals[m_nPrecNum]; + m_nOpCode = m_nPrecOp[--m_precedenceOpCount]; + m_lastVal = m_precedenceVals[m_precedenceOpCount]; // Precedence Invertion check ni = NPrecedenceOfOp(m_nPrevOpCode); @@ -511,7 +511,7 @@ void CCalcEngine::ProcessCommandWorker(WPARAM wParam) m_HistoryCollector.PopLastOpndStart(); m_bNoPrevEqu = true; - } while (m_nPrecNum >= 0); + } while (m_precedenceOpCount >= 0); if (!m_bError) { @@ -541,7 +541,7 @@ void CCalcEngine::ProcessCommandWorker(WPARAM wParam) // paren // -OR- the the precidence holding array is full if ((m_openParenCount >= MAXPRECDEPTH && nx) || (!m_openParenCount && !nx) - || ((m_nPrecNum >= MAXPRECDEPTH && m_nPrecOp[m_nPrecNum - 1] != 0))) + || ((m_precedenceOpCount >= MAXPRECDEPTH && m_nPrecOp[m_precedenceOpCount - 1] != 0))) { HandleErrorCommand(wParam); break; @@ -558,9 +558,9 @@ void CCalcEngine::ProcessCommandWorker(WPARAM wParam) m_nOp[m_openParenCount++] = (m_bChangeOp ? m_nOpCode : 0); /* save a special marker on the precedence array */ - if (m_nPrecNum < m_nPrecOp.size()) + if (m_precedenceOpCount < m_nPrecOp.size()) { - m_nPrecOp[m_nPrecNum++] = 0; + m_nPrecOp[m_precedenceOpCount++] = 0; } m_lastVal = Rational{}; @@ -592,7 +592,7 @@ void CCalcEngine::ProcessCommandWorker(WPARAM wParam) m_nPrevOpCode = m_nOpCode; // Now process the precedence stack till we get to an opcode which is zero. - for (m_nOpCode = m_nPrecOp[--m_nPrecNum]; m_nOpCode; m_nOpCode = m_nPrecOp[--m_nPrecNum]) + for (m_nOpCode = m_nPrecOp[--m_precedenceOpCount]; m_nOpCode; m_nOpCode = m_nPrecOp[--m_precedenceOpCount]) { // Precedence Inversion check ni = NPrecedenceOfOp(m_nPrevOpCode); @@ -603,7 +603,7 @@ void CCalcEngine::ProcessCommandWorker(WPARAM wParam) } m_HistoryCollector.PopLastOpndStart(); - m_lastVal = m_precedenceVals[m_nPrecNum]; + m_lastVal = m_precedenceVals[m_precedenceOpCount]; m_currentVal = DoOperation(m_nOpCode, m_currentVal, m_lastVal); m_nPrevOpCode = m_nOpCode; diff --git a/src/CalcManager/Header Files/CalcEngine.h b/src/CalcManager/Header Files/CalcEngine.h index b5527608..78bac318 100644 --- a/src/CalcManager/Header Files/CalcEngine.h +++ b/src/CalcManager/Header Files/CalcEngine.h @@ -112,7 +112,7 @@ private: int m_openParenCount; // Number of open parentheses. std::array m_nOp; /* Holding array for parenthesis operations. */ std::array m_nPrecOp; /* Holding array for precedence operations. */ - int m_nPrecNum; /* Current number of precedence ops in holding. */ + size_t m_precedenceOpCount; /* Current number of precedence ops in holding. */ int m_nLastCom; // Last command entered. ANGLE_TYPE m_angletype; // Current Angle type when in dec mode. one of deg, rad or grad NUM_WIDTH m_numwidth; // one of qword, dword, word or byte mode. From 47f9996fa9c59cbcdb637a583751cb40344378f8 Mon Sep 17 00:00:00 2001 From: Matt Cooley Date: Thu, 21 Feb 2019 16:47:32 -0800 Subject: [PATCH 04/13] Auto-flight daily builds (#30) The final step of the release pipeline is to submit the build to the Store and to our internal Aero dashboard. --- .../prepare-release-internalonly.yaml | 38 +++++++++++++++++++ 1 file changed, 38 insertions(+) diff --git a/build/pipelines/templates/prepare-release-internalonly.yaml b/build/pipelines/templates/prepare-release-internalonly.yaml index 4949d1ba..6bb3b6cb 100644 --- a/build/pipelines/templates/prepare-release-internalonly.yaml +++ b/build/pipelines/templates/prepare-release-internalonly.yaml @@ -31,6 +31,12 @@ jobs: env: XES_DISABLEPROV: true + - task: NuGetToolInstaller@0 + displayName: Use NuGet 4.7.1 + inputs: + versionSpec: 4.7.1 + checkLatest: true + - task: DownloadBuildArtifacts@0 displayName: Download appxBundle artifact inputs: @@ -96,6 +102,7 @@ jobs: useArtifactServiceForMedia: true outPath: $(Build.ArtifactStagingDirectory)\StoreBrokerPayload paToken: $(System.AccessToken) + logRootPath: $(Build.ArtifactStagingDirectory)/StoreBrokerLogs - task: PublishBuildArtifacts@1 displayName: Publish StoreBrokerPayload artifact @@ -103,6 +110,37 @@ jobs: artifactName: storeBrokerPayload pathToPublish: $(Build.ArtifactStagingDirectory)/StoreBrokerPayload + - task: PkgESStoreBrokerFlight@10 + name: StoreBrokerFlight + displayName: Flight package with StoreBroker + env: + XES_SERIALPOSTBUILDREADY: True + inputs: + packageToFlight: Custom + appId: 9WZDNCRFHVN5 + flightId: 161f0975-cb5f-475b-8ef6-26383c37621f + submissionDataPath: $(Build.ArtifactStagingDirectory)/StoreBrokerPayload/SBCalculator.json + packagePath: $(Build.ArtifactStagingDirectory)/StoreBrokerPayload/SBCalculator.zip + updatePackageAction: AddPackages + logRootPath: $(Build.ArtifactStagingDirectory)/StoreBrokerLogs + + - task: PublishBuildArtifacts@1 + displayName: Publish StoreBrokerLogs artifact + inputs: + artifactName: storeBrokerLogs + pathToPublish: $(Build.ArtifactStagingDirectory)/StoreBrokerLogs + + - task: PkgESStoreBrokerAeroUpload@10 + displayName: Upload to Aero flighting dashboard + env: + SYSTEM_ACCESSTOKEN: $(System.AccessToken) + inputs: + productId: 00009007199266248474 + flightId: 161f0975-cb5f-475b-8ef6-26383c37621f + submissionId: $(StoreBrokerFlight.WS_SubmissionId) + submissionDataPath: $(Build.ArtifactStagingDirectory)/StoreBrokerPayload/SBCalculator.json + packagePath: $(Build.ArtifactStagingDirectory)/StoreBrokerPayload/SBCalculator.zip + - task: PkgESLateTasks@10 displayName: Run PackageES LateTasks env: From 73372283a0fedc537eada17ffa1d8e0397bad997 Mon Sep 17 00:00:00 2001 From: Josh Koon <45607479+joshkoon@users.noreply.github.com> Date: Fri, 22 Feb 2019 10:00:19 -0800 Subject: [PATCH 05/13] CalcEngine: Remove the need to specify base/radix when working with Rational values (#31) - Separates values from the representation (base/radix) of those values. - Uses a single base for all values represented as Rationals. - Rationals are converted to/from a specific base when they are converted to/from strings. --- src/CalcManager/CEngine/CalcInput.cpp | 2 +- src/CalcManager/CEngine/Rational.cpp | 45 ++++++---------- src/CalcManager/CEngine/calc.cpp | 4 +- src/CalcManager/CEngine/scicomm.cpp | 4 +- src/CalcManager/CEngine/scidisp.cpp | 6 +-- src/CalcManager/CEngine/scifunc.cpp | 53 +++++++++++-------- src/CalcManager/CEngine/scimath.cpp | 68 ++++++++++++------------- src/CalcManager/CEngine/scioper.cpp | 36 ++++++------- src/CalcManager/CEngine/sciset.cpp | 10 ++-- src/CalcManager/Header Files/Rational.h | 20 +++++--- src/CalcManager/Header Files/scimath.h | 36 ++++++------- src/CalcManager/Ratpack/conv.cpp | 3 +- src/CalcManager/Ratpack/rat.cpp | 2 +- src/CalcManager/Ratpack/support.cpp | 2 +- 14 files changed, 146 insertions(+), 145 deletions(-) diff --git a/src/CalcManager/CEngine/CalcInput.cpp b/src/CalcManager/CEngine/CalcInput.cpp index c4f9c9d8..707a36e4 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 08d93a1e..20bf9903 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 afbae25f..e0f7b0e0 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 16303716..71ea956f 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 b1f26e3c..669fcdbb 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 26daf238..d3eb62ff 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 7e922dd8..15908f6b 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 fae2f15e..59dbb572 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 319a2a45..716bba18 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 ac8bfca0..aea8ce49 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 8f0d1645..e3726eba 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 789e021a..57ec5bbc 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 3d1023d8..ee294dc6 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 9ea60e0d..81e17ec0 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. //---------------------------------------------------------------------------- From 424891516f1902e1cf3d4258425e1e472f4a8286 Mon Sep 17 00:00:00 2001 From: Howard Wolosky Date: Fri, 22 Feb 2019 15:50:08 -0800 Subject: [PATCH 06/13] Removing team contact email address from README Removing the team contact email address from the README and disabled it from accepting incoming mail from external users. We want to encourage open communication with the community, and so would prefer to defer all communication to open channels whenever possible. --- README.md | 3 --- 1 file changed, 3 deletions(-) diff --git a/README.md b/README.md index f011234c..41fe84e4 100644 --- a/README.md +++ b/README.md @@ -60,6 +60,3 @@ email to ensure we received your original message. Further information, includin Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the [MIT License](.\LICENSE). - -## Contact -Questions that can't be answered on GitHub? Reach out to the team: <[calculator@microsoft.com](mailto:calculator@microsoft.com)> From 0cb5e9bae09492d50868b612637c74c0c169a052 Mon Sep 17 00:00:00 2001 From: Josh Koon <45607479+joshkoon@users.noreply.github.com> Date: Mon, 25 Feb 2019 11:41:32 -0800 Subject: [PATCH 07/13] CalcEngine: Manage precision internally to Rational and convert functions to operator overrides (#35) * Convert Rational::Negate to an operator override * Convert Rational::Add to + and += operator overrides. * Convert Rational::Sub to - and -= operator overrides. * Convert Rational::Div and ::Mul to use /, /=, *, *= operator overrides. * Convert Rational::Mod to use %= and % operator overrides * Convert Rational::Rsh and ::Lsh to use >>=, >>, <<=, << operator overrides * Convert Rational::And, ::Or, ::Xor to use &=, &, |=, |, ^=, ^ operator overrides * Convert Rational relational functions to operator overrides * Remove unnecessary precision arguments from Rational class and remove use of explicit Rational constructors in favor of implicit conversions for value types * Remove unnecessary precision variable from RationalMath operations * Replace unnecessary Rational::Not with Xor operation * Remove unnecessary Rational::IsZero() in favor of == 0 comparisons * Fix rounding issues in ratpak that result from using large precisions. * Move assignment stmt out of IsCurrentTooBigForTrig --- src/CalcManager/CEngine/Rational.cpp | 239 ++++++++++++---------- src/CalcManager/CEngine/calc.cpp | 6 +- src/CalcManager/CEngine/scicomm.cpp | 31 ++- src/CalcManager/CEngine/scidisp.cpp | 13 +- src/CalcManager/CEngine/scifunc.cpp | 74 +++---- src/CalcManager/CEngine/scimath.cpp | 87 ++++---- src/CalcManager/CEngine/scioper.cpp | 53 +++-- src/CalcManager/CEngine/sciset.cpp | 22 +- src/CalcManager/Header Files/CalcEngine.h | 2 +- src/CalcManager/Header Files/Rational.h | 54 +++-- src/CalcManager/Header Files/scimath.h | 42 ++-- src/CalcManager/Ratpack/conv.cpp | 49 +++-- src/CalcManager/Ratpack/rat.cpp | 9 +- src/CalcManager/Ratpack/ratpak.h | 6 +- src/CalcManager/Ratpack/support.cpp | 13 +- 15 files changed, 368 insertions(+), 332 deletions(-) diff --git a/src/CalcManager/CEngine/Rational.cpp b/src/CalcManager/CEngine/Rational.cpp index 20bf9903..22a972a3 100644 --- a/src/CalcManager/CEngine/Rational.cpp +++ b/src/CalcManager/CEngine/Rational.cpp @@ -2,7 +2,6 @@ #include "pch.h" #include "Header Files/Rational.h" -#include "Header Files/scimath.h" using namespace std; @@ -50,12 +49,12 @@ namespace CalcEngine destroyrat(pr); } - Rational::Rational(uint64_t ui, int32_t precision) + Rational::Rational(uint64_t ui) { uint32_t hi = HIDWORD(ui); uint32_t lo = LODWORD(ui); - Rational temp = Rational{ hi }.Lsh(32, precision).Or(lo, precision); + Rational temp = (Rational{ hi } << 32) | lo; m_p = Number{ temp.P() }; m_q = Number{ temp.Q() }; @@ -86,19 +85,19 @@ namespace CalcEngine return m_q; } - Rational Rational::Negate() const + Rational Rational::operator-() const { - return Rational{ Number{ -1 * m_p.Sign(), m_p.Exp(), m_p.Mantissa() }, m_q}; + return Rational{ Number{ -1 * m_p.Sign(), m_p.Exp(), m_p.Mantissa() }, m_q }; } - Rational Rational::Add(Rational const& rhs, int32_t precision) const + Rational& Rational::operator+=(Rational const& rhs) { PRAT lhsRat = this->ToPRAT(); PRAT rhsRat = rhs.ToPRAT(); try { - addrat(&lhsRat, rhsRat, precision); + addrat(&lhsRat, rhsRat, RATIONAL_PRECISION); destroyrat(rhsRat); } catch (DWORD error) @@ -108,20 +107,20 @@ namespace CalcEngine throw(error); } - Rational result = Rational{ lhsRat }; + *this = Rational{ lhsRat }; destroyrat(lhsRat); - return result; + return *this; } - Rational Rational::Sub(Rational const& rhs, int32_t precision) const + Rational& Rational::operator-=(Rational const& rhs) { PRAT lhsRat = this->ToPRAT(); PRAT rhsRat = rhs.ToPRAT(); try { - subrat(&lhsRat, rhsRat, precision); + subrat(&lhsRat, rhsRat, RATIONAL_PRECISION); destroyrat(rhsRat); } catch (DWORD error) @@ -131,20 +130,20 @@ namespace CalcEngine throw(error); } - Rational result = Rational{ lhsRat }; + *this = Rational{ lhsRat }; destroyrat(lhsRat); - return result; + return *this; } - Rational Rational::Mul(Rational const& rhs, int32_t precision) const + Rational& Rational::operator*=(Rational const& rhs) { PRAT lhsRat = this->ToPRAT(); PRAT rhsRat = rhs.ToPRAT(); try { - mulrat(&lhsRat, rhsRat, precision); + mulrat(&lhsRat, rhsRat, RATIONAL_PRECISION); destroyrat(rhsRat); } catch (DWORD error) @@ -154,20 +153,20 @@ namespace CalcEngine throw(error); } - Rational result = Rational{ lhsRat }; + *this = Rational{ lhsRat }; destroyrat(lhsRat); - return result; + return *this; } - Rational Rational::Div(Rational const& rhs, int32_t precision) const + Rational& Rational::operator/=(Rational const& rhs) { PRAT lhsRat = this->ToPRAT(); PRAT rhsRat = rhs.ToPRAT(); try { - divrat(&lhsRat, rhsRat, precision); + divrat(&lhsRat, rhsRat, RATIONAL_PRECISION); destroyrat(rhsRat); } catch (DWORD error) @@ -177,13 +176,13 @@ namespace CalcEngine throw(error); } - Rational result = Rational{ lhsRat }; + *this = Rational{ lhsRat }; destroyrat(lhsRat); - return result; + return *this; } - Rational Rational::Mod(Rational const& rhs) const + Rational& Rational::operator%=(Rational const& rhs) { PRAT lhsRat = this->ToPRAT(); PRAT rhsRat = rhs.ToPRAT(); @@ -200,20 +199,20 @@ namespace CalcEngine throw(error); } - Rational result = Rational{ lhsRat }; + *this = Rational{ lhsRat }; destroyrat(lhsRat); - return result; + return *this; } - Rational Rational::Lsh(Rational const& rhs, int32_t precision) const + Rational& Rational::operator<<=(Rational const& rhs) { PRAT lhsRat = this->ToPRAT(); PRAT rhsRat = rhs.ToPRAT(); try { - lshrat(&lhsRat, rhsRat, RATIONAL_BASE, precision); + lshrat(&lhsRat, rhsRat, RATIONAL_BASE, RATIONAL_PRECISION); destroyrat(rhsRat); } catch (DWORD error) @@ -223,20 +222,20 @@ namespace CalcEngine throw(error); } - Rational result = Rational{ lhsRat }; + *this = Rational{ lhsRat }; destroyrat(lhsRat); - return result; + return *this; } - Rational Rational::Rsh(Rational const& rhs, int32_t precision) const + Rational& Rational::operator>>=(Rational const& rhs) { PRAT lhsRat = this->ToPRAT(); PRAT rhsRat = rhs.ToPRAT(); try { - rshrat(&lhsRat, rhsRat, RATIONAL_BASE, precision); + rshrat(&lhsRat, rhsRat, RATIONAL_BASE, RATIONAL_PRECISION); destroyrat(rhsRat); } catch (DWORD error) @@ -246,25 +245,20 @@ namespace CalcEngine throw(error); } - Rational result = Rational{ lhsRat }; + *this = Rational{ lhsRat }; destroyrat(lhsRat); - return result; + return *this; } - Rational Rational::Not(Rational const& chopNum, int32_t precision) const - { - return this->Xor(chopNum, precision); - } - - Rational Rational::And(Rational const& rhs, int32_t precision) const + Rational& Rational::operator&=(Rational const& rhs) { PRAT lhsRat = this->ToPRAT(); PRAT rhsRat = rhs.ToPRAT(); try { - andrat(&lhsRat, rhsRat, RATIONAL_BASE, precision); + andrat(&lhsRat, rhsRat, RATIONAL_BASE, RATIONAL_PRECISION); destroyrat(rhsRat); } catch (DWORD error) @@ -274,19 +268,19 @@ namespace CalcEngine throw(error); } - Rational result = Rational{ lhsRat }; + *this = Rational{ lhsRat }; destroyrat(lhsRat); - return result; + return *this; } - Rational Rational::Or(Rational const& rhs, int32_t precision) const + Rational& Rational::operator|=(Rational const& rhs) { PRAT lhsRat = this->ToPRAT(); PRAT rhsRat = rhs.ToPRAT(); try { - orrat(&lhsRat, rhsRat, RATIONAL_BASE, precision); + orrat(&lhsRat, rhsRat, RATIONAL_BASE, RATIONAL_PRECISION); destroyrat(rhsRat); } catch (DWORD error) @@ -296,19 +290,19 @@ namespace CalcEngine throw(error); } - Rational result = Rational{ lhsRat }; + *this = Rational{ lhsRat }; destroyrat(lhsRat); - return result; + return *this; } - Rational Rational::Xor(Rational const& rhs, int32_t precision) const + Rational& Rational::operator^=(Rational const& rhs) { PRAT lhsRat = this->ToPRAT(); PRAT rhsRat = rhs.ToPRAT(); try { - xorrat(&lhsRat, rhsRat, RATIONAL_BASE, precision); + xorrat(&lhsRat, rhsRat, RATIONAL_BASE, RATIONAL_PRECISION); destroyrat(rhsRat); } catch (DWORD error) @@ -318,107 +312,136 @@ namespace CalcEngine throw(error); } - Rational result = Rational{ lhsRat }; + *this = Rational{ lhsRat }; destroyrat(lhsRat); - return result; + return *this; } - bool Rational::IsZero() const + Rational operator+(Rational lhs, Rational const& rhs) { - return this->P().IsZero(); + lhs += rhs; + return lhs; } - bool Rational::IsLess(Rational const& r, int32_t precision) const + Rational operator-(Rational lhs, Rational const& rhs) { - PRAT thisRat = this->ToPRAT(); - PRAT rRat = r.ToPRAT(); + lhs -= rhs; + return lhs; + } + + Rational operator*(Rational lhs, Rational const& rhs) + { + lhs *= rhs; + return lhs; + } + + Rational operator/(Rational lhs, Rational const& rhs) + { + lhs /= rhs; + return lhs; + } + + Rational operator%(Rational lhs, Rational const& rhs) + { + lhs %= rhs; + return lhs; + } + + Rational operator<<(Rational lhs, Rational const& rhs) + { + lhs <<= rhs; + return lhs; + } + + Rational operator>>(Rational lhs, Rational const& rhs) + { + lhs >>= rhs; + return lhs; + } + + Rational operator&(Rational lhs, Rational const& rhs) + { + lhs &= rhs; + return lhs; + } + + Rational operator|(Rational lhs, Rational const& rhs) + { + lhs |= rhs; + return lhs; + } + + Rational operator^(Rational lhs, Rational const& rhs) + { + lhs ^= rhs; + return lhs; + } + + bool operator==(Rational const& lhs, Rational const& rhs) + { + PRAT lhsRat = lhs.ToPRAT(); + PRAT rhsRat = rhs.ToPRAT(); bool result = false; try { - result = rat_lt(thisRat, rRat, precision); + result = rat_equ(lhsRat, rhsRat, RATIONAL_PRECISION); } catch (DWORD error) { - destroyrat(thisRat); - destroyrat(rRat); + destroyrat(lhsRat); + destroyrat(rhsRat); throw(error); } - destroyrat(thisRat); - destroyrat(rRat); + destroyrat(lhsRat); + destroyrat(rhsRat); return result; } - bool Rational::IsLessEq(Rational const& r, int32_t precision) const + bool operator!=(Rational const& lhs, Rational const& rhs) { - PRAT thisRat = this->ToPRAT(); - PRAT rRat = r.ToPRAT(); + return !(lhs == rhs); + } + + bool operator<(Rational const& lhs, Rational const& rhs) + { + PRAT lhsRat = lhs.ToPRAT(); + PRAT rhsRat = rhs.ToPRAT(); bool result = false; try { - result = rat_le(thisRat, rRat, precision); + result = rat_lt(lhsRat, rhsRat, RATIONAL_PRECISION); } catch (DWORD error) { - destroyrat(thisRat); - destroyrat(rRat); + destroyrat(lhsRat); + destroyrat(rhsRat); throw(error); } - destroyrat(thisRat); - destroyrat(rRat); + destroyrat(lhsRat); + destroyrat(rhsRat); return result; } - bool Rational::IsGreaterEq(Rational const& r, int32_t precision) const + bool operator>(Rational const& lhs, Rational const& rhs) { - PRAT thisRat = this->ToPRAT(); - PRAT rRat = r.ToPRAT(); - - bool result = false; - try - { - result = rat_ge(thisRat, rRat, precision); - } - catch (DWORD error) - { - destroyrat(thisRat); - destroyrat(rRat); - throw(error); - } - - destroyrat(thisRat); - destroyrat(rRat); - - return result; + return rhs < lhs; } - bool Rational::IsEq(Rational const& r, int32_t precision) const + bool operator<=(Rational const& lhs, Rational const& rhs) { - PRAT thisRat = this->ToPRAT(); - PRAT rRat = r.ToPRAT(); + return !(lhs > rhs); + } - bool result = false; - try - { - result = rat_equ(thisRat, rRat, precision); - } - catch (DWORD error) - { - destroyrat(thisRat); - destroyrat(rRat); - throw(error); - } - - destroyrat(thisRat); - destroyrat(rRat); - - return result; + bool operator>=(Rational const& lhs, Rational const& rhs) + { + return !(lhs < rhs); } wstring Rational::ToString(uint32_t radix, NUMOBJ_FMT fmt, int32_t precision) const @@ -441,13 +464,13 @@ namespace CalcEngine return result; } - uint64_t Rational::ToUInt64_t(int32_t precision) const + uint64_t Rational::ToUInt64_t() const { PRAT rat = this->ToPRAT(); uint64_t result; try { - result = rattoUlonglong(rat, RATIONAL_BASE, precision); + result = rattoUlonglong(rat, RATIONAL_BASE, RATIONAL_PRECISION); } catch (DWORD error) { diff --git a/src/CalcManager/CEngine/calc.cpp b/src/CalcManager/CEngine/calc.cpp index e0f7b0e0..eca94efd 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_precision); + m_maxTrigonometricNum = RationalMath::Pow(10, 100); SetRadixTypeAndNumWidth(DEC_RADIX, m_numwidth); SettingsChanged(); @@ -117,8 +117,8 @@ void CCalcEngine::InitChopNumbers() assert(m_chopNumbers.size() == m_maxDecimalValueStrings.size()); for (size_t i = 0; i < m_chopNumbers.size(); i++) { - auto maxVal = m_chopNumbers[i].Div(2, m_precision); - maxVal = RationalMath::Integer(maxVal, m_precision); + auto maxVal = m_chopNumbers[i] / 2; + maxVal = RationalMath::Integer(maxVal); 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 71ea956f..72cfe419 100644 --- a/src/CalcManager/CEngine/scicomm.cpp +++ b/src/CalcManager/CEngine/scicomm.cpp @@ -318,6 +318,7 @@ void CCalcEngine::ProcessCommandWorker(WPARAM wParam) { if (IsCurrentTooBigForTrig()) { + m_currentVal = 0; DisplayError(CALC_E_DOMAIN); return; } @@ -382,7 +383,7 @@ void CCalcEngine::ProcessCommandWorker(WPARAM wParam) CheckAndAddLastBinOpToHistory(false); } - m_lastVal = Rational{}; + m_lastVal = 0; m_bChangeOp = false; m_precedenceOpCount = m_nTempCom = m_nLastCom = m_nOpCode = m_openParenCount = 0; @@ -563,12 +564,12 @@ void CCalcEngine::ProcessCommandWorker(WPARAM wParam) m_nPrecOp[m_precedenceOpCount++] = 0; } - m_lastVal = Rational{}; + m_lastVal = 0; if (IsBinOpCode(m_nLastCom)) { // We want 1 + ( to start as 1 + (0. Any number you type replaces 0. But if it is 1 + 3 (, it is // treated as 1 + (3 - m_currentVal = Rational{}; + m_currentVal = 0; } m_nTempCom = 0; m_nOpCode = 0; @@ -691,7 +692,7 @@ void CCalcEngine::ProcessCommandWorker(WPARAM wParam) m_HistoryCollector.AddOpndToHistory(m_numberString, m_currentVal); } - m_currentVal = m_currentVal.Negate(); + m_currentVal = -(m_currentVal); DisplayNum(); m_HistoryCollector.AddUnaryOpToHistory(IDC_SIGN, m_bInv, m_angletype); @@ -708,7 +709,7 @@ void CCalcEngine::ProcessCommandWorker(WPARAM wParam) else { // Recall immediate memory value. - m_currentVal = Rational{ *m_memoryValue }; + m_currentVal = *m_memoryValue; } CheckAndAddLastBinOpToHistory(); DisplayNum(); @@ -718,7 +719,7 @@ void CCalcEngine::ProcessCommandWorker(WPARAM wParam) { /* MPLUS adds m_currentVal to immediate memory and kills the "mem" */ /* indicator if the result is zero. */ - Rational result = m_memoryValue->Add(m_currentVal, m_precision); + Rational result = *m_memoryValue + m_currentVal; m_memoryValue = make_unique(TruncateNumForIntMath(result)); // Memory should follow the current int mode break; @@ -727,14 +728,14 @@ void CCalcEngine::ProcessCommandWorker(WPARAM wParam) { /* MMINUS subtracts m_currentVal to immediate memory and kills the "mem" */ /* indicator if the result is zero. */ - Rational result = m_memoryValue->Sub(m_currentVal, m_precision); + Rational result = *m_memoryValue - m_currentVal; m_memoryValue = make_unique(TruncateNumForIntMath(result)); break; } case IDC_STORE: case IDC_MCLEAR: - m_memoryValue = make_unique(wParam == IDC_STORE ? TruncateNumForIntMath(m_currentVal) : Rational{}); + m_memoryValue = make_unique(wParam == IDC_STORE ? TruncateNumForIntMath(m_currentVal) : 0); break; case IDC_PI: @@ -1002,13 +1003,7 @@ int CCalcEngine::IdcSetAngleTypeDecMode(int idc) bool CCalcEngine::IsCurrentTooBigForTrig() { - if (m_currentVal.IsGreaterEq(m_maxTrigonometricNum, m_precision)) - { - m_currentVal = Rational{}; - return true; - } - - return false; + return m_currentVal >= m_maxTrigonometricNum; } int CCalcEngine::GetCurrentRadix() @@ -1048,14 +1043,12 @@ wstring CCalcEngine::GetStringForDisplay(Rational const& rat, uint32_t radix) try { - uint64_t w64Bits = tempRat.ToUInt64_t(m_precision); + uint64_t w64Bits = tempRat.ToUInt64_t(); 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(m_chopNumbers[m_numwidth], m_precision); - tempRat = tempRat.Add(1, m_precision); - tempRat = tempRat.Negate(); + tempRat = -((tempRat ^ m_chopNumbers[m_numwidth]) + 1); } result = tempRat.ToString(radix, m_nFE, m_precision); diff --git a/src/CalcManager/CEngine/scidisp.cpp b/src/CalcManager/CEngine/scidisp.cpp index 669fcdbb..2d0e8f39 100644 --- a/src/CalcManager/CEngine/scidisp.cpp +++ b/src/CalcManager/CEngine/scidisp.cpp @@ -57,19 +57,18 @@ CalcEngine::Rational CCalcEngine::TruncateNumForIntMath(CalcEngine::Rational con } // Truncate to an integer. Do not round here. - auto result = RationalMath::Integer(rat, m_precision); + auto result = RationalMath::Integer(rat); // Can be converting a dec negative number to Hex/Oct/Bin rep. Use 2's complement form // Check the range. - if (result.IsLess(0, m_precision)) + if (result < 0) { // if negative make positive by doing a twos complement - result = result.Negate(); - result = result.Sub(1, m_precision); - result = result.Not(m_chopNumbers[m_numwidth], m_precision); + result = -(result) - 1; + result ^= m_chopNumbers[m_numwidth]; } - result = result.And(m_chopNumbers[m_numwidth], m_precision); + result &= m_chopNumbers[m_numwidth]; return result; } @@ -84,7 +83,7 @@ void CCalcEngine::DisplayNum(void) // called. // if (m_bRecord || - !gldPrevious.value.IsEq(m_currentVal, m_precision) || + gldPrevious.value != m_currentVal || gldPrevious.precision != m_precision || gldPrevious.radix != m_radix || gldPrevious.nFE != (int)m_nFE || diff --git a/src/CalcManager/CEngine/scifunc.cpp b/src/CalcManager/CEngine/scifunc.cpp index d3eb62ff..eb513ea8 100644 --- a/src/CalcManager/CEngine/scifunc.cpp +++ b/src/CalcManager/CEngine/scifunc.cpp @@ -32,20 +32,18 @@ CalcEngine::Rational CCalcEngine::SciCalcFunctions(CalcEngine::Rational const& r switch (op) { case IDC_CHOP: - result = m_bInv ? Frac(rat, m_precision) : Integer(rat, m_precision); + result = m_bInv ? Frac(rat) : Integer(rat); break; /* Return complement. */ case IDC_COM: if (m_radix == 10 && !m_fIntegerMode) { - result = RationalMath::Integer(rat, m_precision); - result = result.Add(1, m_precision); - result = result.Negate(); + result = -(RationalMath::Integer(rat) + 1); } else { - result = rat.Xor(m_chopNumbers[m_numwidth], m_precision); + result = rat ^ m_chopNumbers[m_numwidth]; } break; @@ -53,14 +51,14 @@ CalcEngine::Rational CCalcEngine::SciCalcFunctions(CalcEngine::Rational const& r case IDC_ROL: if (m_fIntegerMode) { - result = Integer(rat, m_precision); + result = Integer(rat); - uint64_t w64Bits = result.ToUInt64_t(m_precision); + uint64_t w64Bits = result.ToUInt64_t(); 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_precision }; + result = w64Bits; } break; @@ -68,14 +66,14 @@ CalcEngine::Rational CCalcEngine::SciCalcFunctions(CalcEngine::Rational const& r case IDC_ROR: if (m_fIntegerMode) { - result = Integer(rat, m_precision); + result = Integer(rat); - uint64_t w64Bits = result.ToUInt64_t(m_precision); + uint64_t w64Bits = result.ToUInt64_t(); uint64_t lsb = ((w64Bits & 0x01) == 1) ? 1 : 0; w64Bits >>= 1; //RShift by 1 w64Bits |= (lsb << (m_dwWordBitWidth - 1)); - result = Rational{ w64Bits, m_precision }; + result = w64Bits; } break; @@ -85,12 +83,11 @@ CalcEngine::Rational CCalcEngine::SciCalcFunctions(CalcEngine::Rational const& r // Otherwise, we evaluate it as "X [op] (X * Y%)" if (m_nOpCode == IDC_MUL || m_nOpCode == IDC_DIV) { - result = rat.Div(100, m_precision); + result = rat / 100; } else { - result = m_lastVal.Div(100, m_precision); - result = rat.Mul(result, m_precision); + result = rat * (m_lastVal / 100); } break; } @@ -98,76 +95,76 @@ 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_precision) : Sin(rat, m_angletype, m_precision); + result = m_bInv ? ASin(rat, m_angletype) : Sin(rat, m_angletype); } break; case IDC_SINH: /* Sine- hyperbolic and archyperbolic */ if (!m_fIntegerMode) { - result = m_bInv ? ASinh(rat, m_precision) : Sinh(rat, m_precision); + result = m_bInv ? ASinh(rat) : Sinh(rat); } break; case IDC_COS: /* Cosine, follows convention of sine function. */ if (!m_fIntegerMode) { - result = m_bInv ? ACos(rat, m_angletype, m_precision) : Cos(rat, m_angletype, m_precision); + result = m_bInv ? ACos(rat, m_angletype) : Cos(rat, m_angletype); } break; case IDC_COSH: /* Cosine hyperbolic, follows convention of sine h function. */ if (!m_fIntegerMode) { - result = m_bInv ? ACosh(rat, m_precision) : Cosh(rat, m_precision); + result = m_bInv ? ACosh(rat) : Cosh(rat); } break; case IDC_TAN: /* Same as sine and cosine. */ if (!m_fIntegerMode) { - result = m_bInv ? ATan(rat, m_angletype, m_precision) : Tan(rat, m_angletype, m_precision); + result = m_bInv ? ATan(rat, m_angletype) : Tan(rat, m_angletype); } break; case IDC_TANH: /* Same as sine h and cosine h. */ if (!m_fIntegerMode) { - result = m_bInv ? ATanh(rat, m_precision) : Tanh(rat, m_precision); + result = m_bInv ? ATanh(rat) : Tanh(rat); } break; case IDC_REC: /* Reciprocal. */ - result = Invert(rat, m_precision); + result = Invert(rat); break; case IDC_SQR: /* Square */ - result = Pow(rat, 2, m_precision); + result = Pow(rat, 2); break; case IDC_SQRT: /* Square Root */ - result = Root(rat, 2, m_precision); + result = Root(rat, 2); break; case IDC_CUBEROOT: case IDC_CUB: /* Cubing and cube root functions. */ - result = IDC_CUBEROOT == op ? Root(rat, 3, m_precision) : Pow(rat, 3, m_precision); + result = IDC_CUBEROOT == op ? Root(rat, 3) : Pow(rat, 3); break; case IDC_LOG: /* Functions for common log. */ - result = Log10(rat, m_precision); + result = Log10(rat); break; case IDC_POW10: - result = Pow(10, rat, m_precision); + result = Pow(10, rat); break; case IDC_LN: /* Functions for natural log. */ - result = m_bInv ? Exp(rat, m_precision) : Log(rat, m_precision); + result = m_bInv ? Exp(rat) : Log(rat); break; case IDC_FAC: /* Calculate factorial. Inverse is ineffective. */ - result = Fact(rat, m_precision); + result = Fact(rat); break; case IDC_DEGREES: @@ -180,31 +177,28 @@ CalcEngine::Rational CCalcEngine::SciCalcFunctions(CalcEngine::Rational const& r { if (!m_fIntegerMode) { - Rational shftRat{ m_bInv ? 100 : 60 }; + auto shftRat{ m_bInv ? 100 : 60 }; - Rational degreeRat = Integer(rat, m_precision); + Rational degreeRat = Integer(rat); - Rational minuteRat = rat.Sub(degreeRat, m_precision); - minuteRat = minuteRat.Mul(shftRat, m_precision); + Rational minuteRat = (rat - degreeRat) * shftRat; Rational secondRat = minuteRat; - minuteRat = Integer(minuteRat, m_precision); + minuteRat = Integer(minuteRat); - secondRat = secondRat.Sub(minuteRat, m_precision); - secondRat = secondRat.Mul(shftRat, m_precision); + secondRat = (secondRat - minuteRat) * shftRat; // // degreeRat == degrees, minuteRat == minutes, secondRat == seconds // - shftRat = Rational{ m_bInv ? 60 : 100 }; - secondRat = secondRat.Div(shftRat, m_precision); + shftRat = m_bInv ? 60 : 100; + secondRat /= shftRat; - minuteRat = minuteRat.Add(secondRat, m_precision); - minuteRat = minuteRat.Div(shftRat, m_precision); + minuteRat = (minuteRat + secondRat) / shftRat; - result = degreeRat.Add(minuteRat, m_precision); + result = degreeRat + minuteRat; } break; } diff --git a/src/CalcManager/CEngine/scimath.cpp b/src/CalcManager/CEngine/scimath.cpp index 15908f6b..5062323c 100644 --- a/src/CalcManager/CEngine/scimath.cpp +++ b/src/CalcManager/CEngine/scimath.cpp @@ -2,18 +2,17 @@ // Licensed under the MIT License. #include "pch.h" -#include "Header Files/CalcEngine.h" -#include "Ratpack/ratpak.h" +#include "Header Files/scimath.h" using namespace std; using namespace CalcEngine; -Rational RationalMath::Frac(Rational const& rat, int32_t precision) +Rational RationalMath::Frac(Rational const& rat) { PRAT prat = rat.ToPRAT(); try { - fracrat(&prat, RATIONAL_BASE, precision); + fracrat(&prat, RATIONAL_BASE, RATIONAL_PRECISION); } catch (DWORD error) { @@ -27,12 +26,12 @@ Rational RationalMath::Frac(Rational const& rat, int32_t precision) return result; } -Rational RationalMath::Integer(Rational const& rat, int32_t precision) +Rational RationalMath::Integer(Rational const& rat) { PRAT prat = rat.ToPRAT(); try { - intrat(&prat, RATIONAL_BASE, precision); + intrat(&prat, RATIONAL_BASE, RATIONAL_PRECISION); } catch (DWORD error) { @@ -46,14 +45,14 @@ Rational RationalMath::Integer(Rational const& rat, int32_t precision) return result; } -Rational RationalMath::Pow(Rational const& base, Rational const& pow, int32_t precision) +Rational RationalMath::Pow(Rational const& base, Rational const& pow) { PRAT baseRat = base.ToPRAT(); PRAT powRat = pow.ToPRAT(); try { - powrat(&baseRat, powRat, RATIONAL_BASE, precision); + powrat(&baseRat, powRat, RATIONAL_BASE, RATIONAL_PRECISION); destroyrat(powRat); } catch (DWORD error) @@ -69,18 +68,18 @@ Rational RationalMath::Pow(Rational const& base, Rational const& pow, int32_t pr return result; } -Rational RationalMath::Root(Rational const& base, Rational const& root, int32_t precision) +Rational RationalMath::Root(Rational const& base, Rational const& root) { - return Pow(base, Invert(root, precision), precision); + return Pow(base, Invert(root)); } -Rational RationalMath::Fact(Rational const& rat, int32_t precision) +Rational RationalMath::Fact(Rational const& rat) { PRAT prat = rat.ToPRAT(); try { - factrat(&prat, RATIONAL_BASE, precision); + factrat(&prat, RATIONAL_BASE, RATIONAL_PRECISION); } catch (DWORD error) { @@ -94,13 +93,13 @@ Rational RationalMath::Fact(Rational const& rat, int32_t precision) return result; } -Rational RationalMath::Exp(Rational const& rat, int32_t precision) +Rational RationalMath::Exp(Rational const& rat) { PRAT prat = rat.ToPRAT(); try { - exprat(&prat, RATIONAL_BASE, precision); + exprat(&prat, RATIONAL_BASE, RATIONAL_PRECISION); } catch (DWORD error) { @@ -114,13 +113,13 @@ Rational RationalMath::Exp(Rational const& rat, int32_t precision) return result; } -Rational RationalMath::Log(Rational const& rat, int32_t precision) +Rational RationalMath::Log(Rational const& rat) { PRAT prat = rat.ToPRAT(); try { - lograt(&prat, precision); + lograt(&prat, RATIONAL_PRECISION); } catch (DWORD error) { @@ -134,14 +133,14 @@ Rational RationalMath::Log(Rational const& rat, int32_t precision) return result; } -Rational RationalMath::Log10(Rational const& rat, int32_t precision) +Rational RationalMath::Log10(Rational const& rat) { - return Log(rat, precision).Div(Rational{ ln_ten }, precision); + return Log(rat) / Rational{ ln_ten }; } -Rational RationalMath::Invert(Rational const& rat, int32_t precision) +Rational RationalMath::Invert(Rational const& rat) { - return Rational{ 1 }.Div(rat, precision); + return 1 / rat; } Rational RationalMath::Abs(Rational const& rat) @@ -149,13 +148,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, int32_t precision) +Rational RationalMath::Sin(Rational const& rat, ANGLE_TYPE angletype) { PRAT prat = rat.ToPRAT(); try { - sinanglerat(&prat, angletype, RATIONAL_BASE, precision); + sinanglerat(&prat, angletype, RATIONAL_BASE, RATIONAL_PRECISION); } catch (DWORD error) { @@ -169,13 +168,13 @@ Rational RationalMath::Sin(Rational const& rat, ANGLE_TYPE angletype, int32_t pr return result; } -Rational RationalMath::Cos(Rational const& rat, ANGLE_TYPE angletype, int32_t precision) +Rational RationalMath::Cos(Rational const& rat, ANGLE_TYPE angletype) { PRAT prat = rat.ToPRAT(); try { - cosanglerat(&prat, angletype, RATIONAL_BASE, precision); + cosanglerat(&prat, angletype, RATIONAL_BASE, RATIONAL_PRECISION); } catch (DWORD error) { @@ -189,13 +188,13 @@ Rational RationalMath::Cos(Rational const& rat, ANGLE_TYPE angletype, int32_t pr return result; } -Rational RationalMath::Tan(Rational const& rat, ANGLE_TYPE angletype, int32_t precision) +Rational RationalMath::Tan(Rational const& rat, ANGLE_TYPE angletype) { PRAT prat = rat.ToPRAT(); try { - tananglerat(&prat, angletype, RATIONAL_BASE, precision); + tananglerat(&prat, angletype, RATIONAL_BASE, RATIONAL_PRECISION); } catch (DWORD error) { @@ -209,13 +208,13 @@ Rational RationalMath::Tan(Rational const& rat, ANGLE_TYPE angletype, int32_t pr return result; } -Rational RationalMath::ASin(Rational const& rat, ANGLE_TYPE angletype, int32_t precision) +Rational RationalMath::ASin(Rational const& rat, ANGLE_TYPE angletype) { PRAT prat = rat.ToPRAT(); try { - asinanglerat(&prat, angletype, RATIONAL_BASE, precision); + asinanglerat(&prat, angletype, RATIONAL_BASE, RATIONAL_PRECISION); } catch (DWORD error) { @@ -229,13 +228,13 @@ Rational RationalMath::ASin(Rational const& rat, ANGLE_TYPE angletype, int32_t p return result; } -Rational RationalMath::ACos(Rational const& rat, ANGLE_TYPE angletype, int32_t precision) +Rational RationalMath::ACos(Rational const& rat, ANGLE_TYPE angletype) { PRAT prat = rat.ToPRAT(); try { - acosanglerat(&prat, angletype, RATIONAL_BASE, precision); + acosanglerat(&prat, angletype, RATIONAL_BASE, RATIONAL_PRECISION); } catch (DWORD error) { @@ -249,13 +248,13 @@ Rational RationalMath::ACos(Rational const& rat, ANGLE_TYPE angletype, int32_t p return result; } -Rational RationalMath::ATan(Rational const& rat, ANGLE_TYPE angletype, int32_t precision) +Rational RationalMath::ATan(Rational const& rat, ANGLE_TYPE angletype) { PRAT prat = rat.ToPRAT(); try { - atananglerat(&prat, angletype, RATIONAL_BASE, precision); + atananglerat(&prat, angletype, RATIONAL_BASE, RATIONAL_PRECISION); } catch (DWORD error) { @@ -269,13 +268,13 @@ Rational RationalMath::ATan(Rational const& rat, ANGLE_TYPE angletype, int32_t p return result; } -Rational RationalMath::Sinh(Rational const& rat, int32_t precision) +Rational RationalMath::Sinh(Rational const& rat) { PRAT prat = rat.ToPRAT(); try { - sinhrat(&prat, RATIONAL_BASE, precision); + sinhrat(&prat, RATIONAL_BASE, RATIONAL_PRECISION); } catch (DWORD error) { @@ -289,13 +288,13 @@ Rational RationalMath::Sinh(Rational const& rat, int32_t precision) return result; } -Rational RationalMath::Cosh(Rational const& rat, int32_t precision) +Rational RationalMath::Cosh(Rational const& rat) { PRAT prat = rat.ToPRAT(); try { - coshrat(&prat, RATIONAL_BASE, precision); + coshrat(&prat, RATIONAL_BASE, RATIONAL_PRECISION); } catch (DWORD error) { @@ -309,13 +308,13 @@ Rational RationalMath::Cosh(Rational const& rat, int32_t precision) return result; } -Rational RationalMath::Tanh(Rational const& rat, int32_t precision) +Rational RationalMath::Tanh(Rational const& rat) { PRAT prat = rat.ToPRAT(); try { - tanhrat(&prat, RATIONAL_BASE, precision); + tanhrat(&prat, RATIONAL_BASE, RATIONAL_PRECISION); } catch (DWORD error) { @@ -329,13 +328,13 @@ Rational RationalMath::Tanh(Rational const& rat, int32_t precision) return result; } -Rational RationalMath::ASinh(Rational const& rat, int32_t precision) +Rational RationalMath::ASinh(Rational const& rat) { PRAT prat = rat.ToPRAT(); try { - asinhrat(&prat, RATIONAL_BASE, precision); + asinhrat(&prat, RATIONAL_BASE, RATIONAL_PRECISION); } catch (DWORD error) { @@ -349,13 +348,13 @@ Rational RationalMath::ASinh(Rational const& rat, int32_t precision) return result; } -Rational RationalMath::ACosh(Rational const& rat, int32_t precision) +Rational RationalMath::ACosh(Rational const& rat) { PRAT prat = rat.ToPRAT(); try { - acoshrat(&prat, RATIONAL_BASE, precision); + acoshrat(&prat, RATIONAL_BASE, RATIONAL_PRECISION); } catch (DWORD error) { @@ -369,13 +368,13 @@ Rational RationalMath::ACosh(Rational const& rat, int32_t precision) return result; } -Rational RationalMath::ATanh(Rational const& rat, int32_t precision) +Rational RationalMath::ATanh(Rational const& rat) { PRAT prat = rat.ToPRAT(); try { - atanhrat(&prat, precision); + atanhrat(&prat, RATIONAL_PRECISION); } catch (DWORD error) { diff --git a/src/CalcManager/CEngine/scioper.cpp b/src/CalcManager/CEngine/scioper.cpp index 59dbb572..06fe3450 100644 --- a/src/CalcManager/CEngine/scioper.cpp +++ b/src/CalcManager/CEngine/scioper.cpp @@ -11,69 +11,68 @@ using namespace CalcEngine::RationalMath; CalcEngine::Rational CCalcEngine::DoOperation(int operation, CalcEngine::Rational const& lhs, CalcEngine::Rational const& rhs) { // Remove any variance in how 0 could be represented in rat e.g. -0, 0/n, etc. - auto result = (!lhs.IsZero() ? lhs : Rational{}); + auto result = (lhs != 0 ? lhs : 0); try { switch (operation) { case IDC_AND: - result = result.And(rhs, m_precision); + result &= rhs; break; case IDC_OR: - result = result.Or(rhs, m_precision); + result |= rhs; break; case IDC_XOR: - result = result.Xor(rhs, m_precision); + result ^= rhs; break; case IDC_RSHF: { - if (m_fIntegerMode && result.IsGreaterEq(Rational{ m_dwWordBitWidth }, m_precision)) // Lsh/Rsh >= than current word size is always 0 + if (m_fIntegerMode && result >= m_dwWordBitWidth) // Lsh/Rsh >= than current word size is always 0 { throw CALC_E_NORESULT; } - uint64_t w64Bits = rhs.ToUInt64_t(m_precision); + uint64_t w64Bits = rhs.ToUInt64_t(); bool fMsb = (w64Bits >> (m_dwWordBitWidth - 1)) & 1; Rational holdVal = result; - result = rhs.Rsh(holdVal, m_precision); + result = rhs >> holdVal; if (fMsb) { - result = Integer(result, m_precision); + result = Integer(result); - auto tempRat = m_chopNumbers[m_numwidth].Rsh(holdVal, m_precision); - tempRat = Integer(tempRat, m_precision); + auto tempRat = m_chopNumbers[m_numwidth] >> holdVal; + tempRat = Integer(tempRat); - tempRat = tempRat.Xor(m_chopNumbers[m_numwidth], m_precision); - result = result.Or(tempRat, m_precision); + result |= tempRat ^ m_chopNumbers[m_numwidth]; } break; } case IDC_LSHF: - if (m_fIntegerMode && result.IsGreaterEq(Rational{ m_dwWordBitWidth }, m_precision)) // Lsh/Rsh >= than current word size is always 0 + if (m_fIntegerMode && result >= m_dwWordBitWidth) // Lsh/Rsh >= than current word size is always 0 { throw CALC_E_NORESULT; } - result = rhs.Lsh(result, m_precision); + result = rhs << result; break; case IDC_ADD: - result = result.Add(rhs, m_precision); + result += rhs; break; case IDC_SUB: - result = rhs.Sub(result, m_precision); + result = rhs - result; break; case IDC_MUL: - result = result.Mul(rhs, m_precision); + result *= rhs; break; case IDC_DIV: @@ -85,24 +84,22 @@ CalcEngine::Rational CCalcEngine::DoOperation(int operation, CalcEngine::Rationa if (m_fIntegerMode) { - uint64_t w64Bits = rhs.ToUInt64_t(m_precision); + uint64_t w64Bits = rhs.ToUInt64_t(); bool fMsb = (w64Bits >> (m_dwWordBitWidth - 1)) & 1; if (fMsb) { - result = rhs.Not(m_chopNumbers[m_numwidth], m_precision); - result = result.Add(1, m_precision); + result = (rhs ^ m_chopNumbers[m_numwidth]) + 1; iNumeratorSign = -1; } - w64Bits = temp.ToUInt64_t(m_precision); + w64Bits = temp.ToUInt64_t(); fMsb = (w64Bits >> (m_dwWordBitWidth - 1)) & 1; if (fMsb) { - temp = temp.Not(m_chopNumbers[m_numwidth], m_precision); - temp = temp.Add(1, m_precision); + temp = (temp ^ m_chopNumbers[m_numwidth]) + 1; iDenominatorSign = -1; } @@ -111,28 +108,28 @@ CalcEngine::Rational CCalcEngine::DoOperation(int operation, CalcEngine::Rationa if (operation == IDC_DIV) { iFinalSign = iNumeratorSign * iDenominatorSign; - result = result.Div(temp, m_precision); + result /= temp; } else { iFinalSign = iNumeratorSign; - result = result.Mod(temp); + result %= temp; } if (m_fIntegerMode && iFinalSign == -1) { - result = Integer(result, m_precision).Negate(); + result = -(Integer(result)); } break; } case IDC_PWR: // Calculates rhs to the result(th) power. - result = Pow(rhs, result, m_precision); + result = Pow(rhs, result); break; case IDC_ROOT: // Calculates rhs to the result(th) root. - result = Root(rhs, result, m_precision); + result = Root(rhs, result); break; } } diff --git a/src/CalcManager/CEngine/sciset.cpp b/src/CalcManager/CEngine/sciset.cpp index 716bba18..1ae1dbcb 100644 --- a/src/CalcManager/CEngine/sciset.cpp +++ b/src/CalcManager/CEngine/sciset.cpp @@ -18,16 +18,15 @@ 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_precision); + uint64_t w64Bits = m_currentVal.ToUInt64_t(); 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(m_chopNumbers[m_numwidth], m_precision); - tempResult = tempResult.Add(1, m_precision); + auto tempResult = m_currentVal ^ m_chopNumbers[m_numwidth]; - m_currentVal = tempResult.Negate(); + m_currentVal = -(tempResult + 1); } } @@ -85,16 +84,13 @@ bool CCalcEngine::TryToggleBit(CalcEngine::Rational& rat, DWORD wbitno) return false; // ignore error cant happen } - 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. - // Basic bug is there which doesn't treat 0/ n as 0, or -0 as 0 etc. - result = Rational{}; - } + Rational result = Integer(rat); - auto pow = Pow(2, static_cast(wbitno), m_precision); - rat = result.Xor(pow, m_precision); + // Remove any variance in how 0 could be represented in rat e.g. -0, 0/n, etc. + result = (result != 0 ? result : 0); + + // XOR the result with 2^wbitno power + rat = result ^ Pow(2, static_cast(wbitno)); return true; } diff --git a/src/CalcManager/Header Files/CalcEngine.h b/src/CalcManager/Header Files/CalcEngine.h index 78bac318..626f3954 100644 --- a/src/CalcManager/Header Files/CalcEngine.h +++ b/src/CalcManager/Header Files/CalcEngine.h @@ -14,7 +14,6 @@ * \****************************************************************************/ -#include "scimath.h" #include "CCommand.h" #include "EngineStrings.h" #include "../Command.h" @@ -24,6 +23,7 @@ #include "History.h" // for History Collector #include "CalcInput.h" #include "ICalcDisplay.h" +#include "scimath.h" #include "Rational.h" // The following are NOT real exports of CalcEngine, but for forward declarations diff --git a/src/CalcManager/Header Files/Rational.h b/src/CalcManager/Header Files/Rational.h index aea8ce49..7b73585e 100644 --- a/src/CalcManager/Header Files/Rational.h +++ b/src/CalcManager/Header Files/Rational.h @@ -10,6 +10,9 @@ namespace CalcEngine // RatPack calculations currently support up to Base64. inline constexpr uint32_t RATIONAL_BASE = 10; + // Default Precision to use for Rational calculations + inline constexpr int32_t RATIONAL_PRECISION = 128; + class Rational { public: @@ -18,7 +21,7 @@ namespace CalcEngine Rational(Number const& p, Number const& q) noexcept; Rational(int32_t i); Rational(uint32_t ui); - Rational(uint64_t ui, int32_t precision); + Rational(uint64_t ui); explicit Rational(PRAT prat) noexcept; PRAT ToPRAT() const; @@ -26,29 +29,42 @@ namespace CalcEngine Number const& P() const; Number const& Q() const; - Rational Negate() const; - Rational Add(Rational const& rhs, int32_t precision) const; - Rational Sub(Rational const& rhs, int32_t precision) const; - Rational Mul(Rational const& rhs, int32_t precision) const; - Rational Div(Rational const& rhs, int32_t precision) const; - Rational Mod(Rational const& rhs) const; + Rational operator-() const; + Rational& operator+=(Rational const& rhs); + Rational& operator-=(Rational const& rhs); + Rational& operator*=(Rational const& rhs); + Rational& operator/=(Rational const& rhs); + Rational& operator%=(Rational const& rhs); - Rational Lsh(Rational const& r, int32_t precision) const; - Rational Rsh(Rational const& r, int32_t precision) const; + Rational& operator<<=(Rational const& rhs); + Rational& operator>>=(Rational const& rhs); - 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; + Rational& operator&=(Rational const& rhs); + Rational& operator|=(Rational const& rhs); + Rational& operator^=(Rational const& rhs); - bool IsZero() const; - bool IsLess(Rational const& r, int32_t precision) const; - bool IsLessEq(Rational const& r, int32_t precision) const; - bool IsGreaterEq(Rational const& r, int32_t precision) const; - bool IsEq(Rational const& r, int32_t precision) const; + friend Rational operator+(Rational lhs, Rational const& rhs); + friend Rational operator-(Rational lhs, Rational const& rhs); + friend Rational operator*(Rational lhs, Rational const& rhs); + friend Rational operator/(Rational lhs, Rational const& rhs); + friend Rational operator%(Rational lhs, Rational const& rhs); + + friend Rational operator<<(Rational lhs, Rational const& rhs); + friend Rational operator>>(Rational lhs, Rational const& rhs); + + friend Rational operator&(Rational lhs, Rational const& rhs); + friend Rational operator|(Rational lhs, Rational const& rhs); + friend Rational operator^(Rational lhs, Rational const& rhs); + + friend bool operator==(Rational const& lhs, Rational const& rhs); + friend bool operator!=(Rational const& lhs, Rational const& rhs); + friend bool operator<(Rational const& lhs, Rational const& rhs); + friend bool operator>(Rational const& lhs, Rational const& rhs); + friend bool operator<=(Rational const& lhs, Rational const& rhs); + friend bool operator>=(Rational const& lhs, Rational const& rhs); std::wstring ToString(uint32_t radix, NUMOBJ_FMT format, int32_t precision) const; - uint64_t ToUInt64_t(int32_t precision) const; + uint64_t ToUInt64_t() const; private: Number m_p; diff --git a/src/CalcManager/Header Files/scimath.h b/src/CalcManager/Header Files/scimath.h index e3726eba..06be9e87 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, int32_t precision); - Rational Integer(Rational const& rat, int32_t precision); + Rational Frac(Rational const& rat); + Rational Integer(Rational const& rat); - 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 Pow(Rational const& base, Rational const& pow); + Rational Root(Rational const& base, Rational const& root); + Rational Fact(Rational const& rat); - 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 Exp(Rational const& rat); + Rational Log(Rational const& rat); + Rational Log10(Rational const& rat); - Rational Invert(Rational const& rat, int32_t precision); + Rational Invert(Rational const& rat); Rational Abs(Rational const& rat); - 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 Sin(Rational const& rat, ANGLE_TYPE angletype); + Rational Cos(Rational const& rat, ANGLE_TYPE angletype); + Rational Tan(Rational const& rat, ANGLE_TYPE angletype); + Rational ASin(Rational const& rat, ANGLE_TYPE angletype); + Rational ACos(Rational const& rat, ANGLE_TYPE angletype); + Rational ATan(Rational const& rat, ANGLE_TYPE angletype); - 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); + Rational Sinh(Rational const& rat); + Rational Cosh(Rational const& rat); + Rational Tanh(Rational const& rat); + Rational ASinh(Rational const& rat); + Rational ACosh(Rational const& rat); + Rational ATanh(Rational const& rat); } diff --git a/src/CalcManager/Ratpack/conv.cpp b/src/CalcManager/Ratpack/conv.cpp index 57ec5bbc..05d118fb 100644 --- a/src/CalcManager/Ratpack/conv.cpp +++ b/src/CalcManager/Ratpack/conv.cpp @@ -1259,20 +1259,7 @@ wstring NumberToString(_Inout_ PNUMBER& pnum, int format, uint32_t radix, int32_ //----------------------------------------------------------------------------- wstring RatToString(_Inout_ PRAT& prat, int format, uint32_t radix, int32_t precision) { - // Convert p and q of rational form from internal base to requested base. - // Scale by largest power of BASEX possible. - long scaleby = min(prat->pp->exp, prat->pq->exp); - scaleby = max(scaleby, 0); - - prat->pp->exp -= scaleby; - prat->pq->exp -= scaleby; - - PNUMBER p = nRadixxtonum(prat->pp, radix, precision); - PNUMBER q = nRadixxtonum(prat->pq, radix, precision); - - // finally take the time hit to actually divide. - divnum(&p, q, radix, precision); - destroynum(q); + PNUMBER p = RatToNumber(prat, radix, precision); wstring result = NumberToString(p, format, radix, precision); destroynum(p); @@ -1280,6 +1267,40 @@ wstring RatToString(_Inout_ PRAT& prat, int format, uint32_t radix, int32_t prec return result; } +PNUMBER RatToNumber(_In_ PRAT prat, uint32_t radix, int32_t precision) +{ + PRAT temprat = nullptr; + DUPRAT(temprat, prat); + // Convert p and q of rational form from internal base to requested base. + // Scale by largest power of BASEX possible. + long scaleby = min(temprat->pp->exp, temprat->pq->exp); + scaleby = max(scaleby, 0); + + temprat->pp->exp -= scaleby; + temprat->pq->exp -= scaleby; + + PNUMBER p = nRadixxtonum(temprat->pp, radix, precision); + PNUMBER q = nRadixxtonum(temprat->pq, radix, precision); + + destroyrat(temprat); + + // finally take the time hit to actually divide. + divnum(&p, q, radix, precision); + destroynum(q); + + return p; +} + +// Converts a PRAT to a PNUMBER and back to a PRAT, flattening/simplifying the rational in the process +void flatrat(_Inout_ PRAT& prat, uint32_t radix, int32_t precision) +{ + PNUMBER pnum = RatToNumber(prat, radix, precision); + + destroyrat(prat); + prat = numtorat(pnum, radix); + destroynum(pnum); +} + //----------------------------------------------------------------------------- // // FUNCTION: gcd diff --git a/src/CalcManager/Ratpack/rat.cpp b/src/CalcManager/Ratpack/rat.cpp index ee294dc6..efc448dd 100644 --- a/src/CalcManager/Ratpack/rat.cpp +++ b/src/CalcManager/Ratpack/rat.cpp @@ -73,16 +73,11 @@ void gcdrat( PRAT *pa, uint32_t radix, int32_t precision) void fracrat( PRAT *pa , uint32_t radix, int32_t precision) { - // Only do the intrat operation if number is nonzero. + // Only do the flatrat operation if number is nonzero. // and only if the bottom part is not one. if ( !zernum( (*pa)->pp ) && !equnum( (*pa)->pq, num_one ) ) { - wstring ratStr = RatToString(*pa, FMT_FLOAT, radix, precision); - PNUMBER pnum = StringToNumber(ratStr, radix, precision); - - destroyrat( *pa ); - *pa = numtorat( pnum, radix); - destroynum( pnum ); + flatrat(*pa, radix, precision); } remnum( &((*pa)->pp), (*pa)->pq, BASEX ); diff --git a/src/CalcManager/Ratpack/ratpak.h b/src/CalcManager/Ratpack/ratpak.h index ee376b86..f5a508ee 100644 --- a/src/CalcManager/Ratpack/ratpak.h +++ b/src/CalcManager/Ratpack/ratpak.h @@ -1,4 +1,4 @@ -// Copyright (c) Microsoft Corporation. All rights reserved. +// Copyright (c) Microsoft Corporation. All rights reserved. // Licensed under the MIT License. #pragma once @@ -316,6 +316,10 @@ extern std::wstring NumberToString(_Inout_ PNUMBER& pnum, int format, uint32_t r // returns a text representation of a PRAT extern std::wstring RatToString(_Inout_ PRAT& prat, int format, uint32_t radix, int32_t precision); +// converts a PRAT into a PNUMBER +extern PNUMBER RatToNumber(_In_ PRAT prat, uint32_t radix, int32_t precision); +// flattens a PRAT by converting it to a PNUMBER and back to a PRAT +extern void flatrat(_Inout_ PRAT& prat, uint32_t radix, int32_t precision); extern long numtolong(_In_ PNUMBER pnum, uint32_t radix ); extern long rattolong(_In_ PRAT prat, uint32_t radix, int32_t precision); diff --git a/src/CalcManager/Ratpack/support.cpp b/src/CalcManager/Ratpack/support.cpp index 81e17ec0..65c2b4c3 100644 --- a/src/CalcManager/Ratpack/support.cpp +++ b/src/CalcManager/Ratpack/support.cpp @@ -291,19 +291,18 @@ void intrat( PRAT *px, uint32_t radix, int32_t precision) // and only if the bottom part is not one. if ( !zernum( (*px)->pp ) && !equnum( (*px)->pq, num_one ) ) { - wstring ratStr = RatToString(*px, FMT_FLOAT, radix, precision); - PNUMBER pnum = StringToNumber(ratStr, radix, precision); - - destroyrat( *px ); - *px = numtorat( pnum, radix); - destroynum( pnum ); + flatrat(*px, radix, precision); + // Subtract the fractional part of the rational PRAT pret = nullptr; DUPRAT(pret,*px); modrat( &pret, rat_one ); - + subrat( px, pret, precision); destroyrat( pret ); + + // Simplify the value if possible to resolve rounding errors + flatrat(*px, radix, precision); } } From ddc470949cb62b0a671160822730c631592e34fb Mon Sep 17 00:00:00 2001 From: Josh Koon <45607479+joshkoon@users.noreply.github.com> Date: Mon, 25 Feb 2019 14:04:38 -0800 Subject: [PATCH 08/13] Rename scimath.h/cpp to RationalMath.h/cpp (#36) --- .../CEngine/{scimath.cpp => RationalMath.cpp} | 2 +- src/CalcManager/CalcManager.vcxproj | 4 ++-- src/CalcManager/CalcManager.vcxproj.filters | 12 ++++++------ src/CalcManager/Header Files/CalcEngine.h | 2 +- src/CalcManager/Header Files/Number.h | 1 + src/CalcManager/Header Files/Rational.h | 1 + .../Header Files/{scimath.h => RationalMath.h} | 2 ++ 7 files changed, 14 insertions(+), 10 deletions(-) rename src/CalcManager/CEngine/{scimath.cpp => RationalMath.cpp} (99%) rename src/CalcManager/Header Files/{scimath.h => RationalMath.h} (98%) diff --git a/src/CalcManager/CEngine/scimath.cpp b/src/CalcManager/CEngine/RationalMath.cpp similarity index 99% rename from src/CalcManager/CEngine/scimath.cpp rename to src/CalcManager/CEngine/RationalMath.cpp index 5062323c..46b5a086 100644 --- a/src/CalcManager/CEngine/scimath.cpp +++ b/src/CalcManager/CEngine/RationalMath.cpp @@ -2,7 +2,7 @@ // Licensed under the MIT License. #include "pch.h" -#include "Header Files/scimath.h" +#include "Header Files/RationalMath.h" using namespace std; using namespace CalcEngine; diff --git a/src/CalcManager/CalcManager.vcxproj b/src/CalcManager/CalcManager.vcxproj index 868abfe9..4455336c 100644 --- a/src/CalcManager/CalcManager.vcxproj +++ b/src/CalcManager/CalcManager.vcxproj @@ -281,7 +281,7 @@ - + @@ -300,7 +300,7 @@ - + diff --git a/src/CalcManager/CalcManager.vcxproj.filters b/src/CalcManager/CalcManager.vcxproj.filters index 14a28e88..5ceff3e3 100644 --- a/src/CalcManager/CalcManager.vcxproj.filters +++ b/src/CalcManager/CalcManager.vcxproj.filters @@ -32,9 +32,6 @@ CEngine - - CEngine - CEngine @@ -89,6 +86,9 @@ CEngine + + CEngine + @@ -110,9 +110,6 @@ Header Files - - Header Files - RatPack @@ -164,5 +161,8 @@ Header Files + + Header Files + \ No newline at end of file diff --git a/src/CalcManager/Header Files/CalcEngine.h b/src/CalcManager/Header Files/CalcEngine.h index 626f3954..2e59cdbe 100644 --- a/src/CalcManager/Header Files/CalcEngine.h +++ b/src/CalcManager/Header Files/CalcEngine.h @@ -23,8 +23,8 @@ #include "History.h" // for History Collector #include "CalcInput.h" #include "ICalcDisplay.h" -#include "scimath.h" #include "Rational.h" +#include "RationalMath.h" // The following are NOT real exports of CalcEngine, but for forward declarations // The real exports follows later diff --git a/src/CalcManager/Header Files/Number.h b/src/CalcManager/Header Files/Number.h index f832a840..c67aa108 100644 --- a/src/CalcManager/Header Files/Number.h +++ b/src/CalcManager/Header Files/Number.h @@ -1,4 +1,5 @@ // Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. #pragma once diff --git a/src/CalcManager/Header Files/Rational.h b/src/CalcManager/Header Files/Rational.h index 7b73585e..8ded3c27 100644 --- a/src/CalcManager/Header Files/Rational.h +++ b/src/CalcManager/Header Files/Rational.h @@ -1,4 +1,5 @@ // Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. #pragma once diff --git a/src/CalcManager/Header Files/scimath.h b/src/CalcManager/Header Files/RationalMath.h similarity index 98% rename from src/CalcManager/Header Files/scimath.h rename to src/CalcManager/Header Files/RationalMath.h index 06be9e87..b52c1c5f 100644 --- a/src/CalcManager/Header Files/scimath.h +++ b/src/CalcManager/Header Files/RationalMath.h @@ -1,6 +1,8 @@ // Copyright (c) Microsoft Corporation. All rights reserved. // Licensed under the MIT License. +#pragma once + #include "Rational.h" namespace CalcEngine::RationalMath From 654f09f5448ec14a269f61c72514f6a1c770d341 Mon Sep 17 00:00:00 2001 From: Matt Cooley Date: Mon, 25 Feb 2019 15:41:16 -0800 Subject: [PATCH 09/13] Fix spelling in some comments (#38) --- src/CalcManager/CEngine/CalcInput.cpp | 4 ++-- src/CalcManager/CEngine/History.cpp | 2 +- src/CalcManager/CEngine/calc.cpp | 6 +++--- 3 files changed, 6 insertions(+), 6 deletions(-) diff --git a/src/CalcManager/CEngine/CalcInput.cpp b/src/CalcManager/CEngine/CalcInput.cpp index 707a36e4..6b6ada4c 100644 --- a/src/CalcManager/CEngine/CalcInput.cpp +++ b/src/CalcManager/CEngine/CalcInput.cpp @@ -39,7 +39,7 @@ bool CalcInput::TryToggleSign(bool isIntegerMode, wstring_view maxNumStr) } else { - // When in integer only mode, it isnt always allowed to toggle, as toggling can cause the num to be out of + // When in integer only mode, it isn't always allowed to toggle, as toggling can cause the num to be out of // bounds. For eg. in byte -128 is valid, but when it toggled it becomes 128, which is more than 127. if (isIntegerMode && m_base.IsNegative()) { @@ -74,7 +74,7 @@ bool CalcInput::TryAddDigit(unsigned int value, uint32_t radix, bool isIntegerMo pNumSec = &m_base; maxCount = maxDigits; // Don't include the decimal point in the count. In that way you can enter the maximum allowed precision. - // Precision doesnt include decimal point. + // Precision doesn't include decimal point. if (HasDecimalPt()) { maxCount++; diff --git a/src/CalcManager/CEngine/History.cpp b/src/CalcManager/CEngine/History.cpp index 95347a59..06f9a955 100644 --- a/src/CalcManager/CEngine/History.cpp +++ b/src/CalcManager/CEngine/History.cpp @@ -110,7 +110,7 @@ void CHistoryCollector::RemoveLastOpndFromHistory() TruncateEquationSzFromIch(m_lastOpStartIndex); SetExpressionDisplay(); m_lastOpStartIndex = -1; - // This will not restore the m_lastBinOpStartIndex, as it isnt possible to remove that also later + // This will not restore the m_lastBinOpStartIndex, as it isn't possible to remove that also later } void CHistoryCollector::AddBinOpToHistory(int nOpCode, bool fNoRepetition) diff --git a/src/CalcManager/CEngine/calc.cpp b/src/CalcManager/CEngine/calc.cpp index eca94efd..7be2ff13 100644 --- a/src/CalcManager/CEngine/calc.cpp +++ b/src/CalcManager/CEngine/calc.cpp @@ -44,7 +44,7 @@ void CCalcEngine::InitialOneTimeOnlySetup(CalculationManager::IResourceProvider& { LoadEngineStrings(resourceProvider); - // we must now setup all the ratpak constants and our arrayed pointers + // we must now set up all the ratpak constants and our arrayed pointers // to these constants. ChangeBaseConstants(DEFAULT_RADIX, DEFAULT_MAX_DIGITS, DEFAULT_PRECISION); } @@ -112,8 +112,8 @@ void CCalcEngine::InitChopNumbers() m_chopNumbers[2] = Rational{ rat_word }; m_chopNumbers[3] = Rational{ rat_byte }; - // initialize the max dec number you can support for each of the supported bit length - // this is basically max num in that width / 2 in integer + // initialize the max dec number you can support for each of the supported bit lengths + // this is basically max num in that width / 2 in integer assert(m_chopNumbers.size() == m_maxDecimalValueStrings.size()); for (size_t i = 0; i < m_chopNumbers.size(); i++) { From 9c966fb797f0d76147c122c63edf8d7f95c134c2 Mon Sep 17 00:00:00 2001 From: David Grochocki Date: Mon, 25 Feb 2019 15:56:35 -0800 Subject: [PATCH 10/13] Adding Windows Calculator Roadmap Document (#37) * Create Roadmap.md * Update Roadmap.md * Adding reference to roadmap in README * Update README.md --- README.md | 3 +++ docs/Roadmap.md | 20 ++++++++++++++++++++ 2 files changed, 23 insertions(+) create mode 100644 docs/Roadmap.md diff --git a/README.md b/README.md index 41fe84e4..0689056f 100644 --- a/README.md +++ b/README.md @@ -42,6 +42,9 @@ Want to contribute? The team encourages community feedback and contributions. Pl If Calculator is not working properly, please file a report in the [Feedback Hub](https://insider.windows.com/en-us/fb/?contextid=130). We also welcome [issues submitted on GitHub](https://github.com/Microsoft/calculator/issues). +## Roadmap +For information regarding Windows Calculator plans and release schedule, please see the [Windows Calculator Roadmap](docs/Roadmap.md). + ## Data / Telemetry This project collects usage data and sends it to Microsoft to help improve our products and services. Read our [privacy statement](http://go.microsoft.com/fwlink/?LinkId=521839) to learn more. diff --git a/docs/Roadmap.md b/docs/Roadmap.md new file mode 100644 index 00000000..93b1428e --- /dev/null +++ b/docs/Roadmap.md @@ -0,0 +1,20 @@ +# Windows Calculator Roadmap + +Windows Calculator is under active development by Microsoft. + +## Focus + +In 2019, the Windows Calculator team is focused on: +* Refining our open source development process on GitHub +* Iterating upon the existing app design based on the latest [Fluent Design guidelines](https://developer.microsoft.com/en-us/windows/apps/design) +* Improving testing and diagnostics within the project +* Investigating new features with a focus on addressing top user feedback, including: + * Adding the ability for users to pin Calculator on top of other windows + * Providing additional customization options + * [Your feature idea here] - please review our [new feature development process](https://github.com/Microsoft/calculator/blob/master/docs/NewFeatureProcess.md) to get started! + +We welcome contributions of all kinds from the community, but especially those that support the efforts above. Please see our [contributing guidelines](https://github.com/Microsoft/calculator/blob/master/CONTRIBUTING.md) for more information on how to get involved. + +## Releases + +Windows Calculator is included in every Windows 10 release as a [provisioned Windows app](https://docs.microsoft.com/en-us/windows/application-management/apps-in-windows-10#provisioned-windows-apps). We also deliver updates through the [Microsoft Store](https://www.microsoft.com/store/productId/9WZDNCRFHVN5) approximately monthly. From df02025d2f58f258420eeaafca30750af7ed8f14 Mon Sep 17 00:00:00 2001 From: Brett Waldbaum <39069036+bwaldbaum@users.noreply.github.com> Date: Tue, 26 Feb 2019 16:15:48 -0800 Subject: [PATCH 11/13] Fix license link in README.md The link to the MIT License in README.md was broken. --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 0689056f..023e1660 100644 --- a/README.md +++ b/README.md @@ -62,4 +62,4 @@ email to ensure we received your original message. Further information, includin ## License Copyright (c) Microsoft Corporation. All rights reserved. -Licensed under the [MIT License](.\LICENSE). +Licensed under the [MIT License](./LICENSE). From fa5478ac5e39eee3223408e5850878eb802307e1 Mon Sep 17 00:00:00 2001 From: Brett Waldbaum <39069036+bwaldbaum@users.noreply.github.com> Date: Tue, 26 Feb 2019 17:16:53 -0800 Subject: [PATCH 12/13] Update ManualTests.md Fix line breaks and the Or hotkey markdown. --- docs/ManualTests.md | 14 ++++++++------ 1 file changed, 8 insertions(+), 6 deletions(-) diff --git a/docs/ManualTests.md b/docs/ManualTests.md index 606fefdb..deb8111a 100644 --- a/docs/ManualTests.md +++ b/docs/ManualTests.md @@ -277,8 +277,8 @@ Steps: **All Calculators Test: Hotkeys: Verify Hot Key function.** Steps: 1. Launch the "Calculator" app. -For All Applicable Modes: -Verify the following: + + For All Applicable Modes verify the following: 2. Press **Alt +1** to Enter "Standard" mode *Expected: Move to "Standard" screen.* 3. Press **Alt +2** to Enter "Scientific" mode @@ -305,8 +305,9 @@ Verify the following: *Expected: Function when in small scale window.* 19. Press **Ctrl + Shift + D** to Clear History Panel *Expected: Function when in small scale window.* -20. Press **Spacebar** to Repeat Last Input: -Verify the following in Scientific Mode +20. Press **Spacebar** to Repeat Last Input + + Verify the following in Scientific Mode 21. Press **F3** to Select 'DEG' 22. Press **F4** to Select 'RAD' 23. Press **F5** to Select 'GRAD' @@ -333,7 +334,8 @@ Verify the following in Scientific Mode 44. Press **Y** or **^** to Select 'xʸ' 45. Press **#** to Select 'x³' 46. Press **!** to Select 'n!' -Verify the following in Programmer Mode + + Verify the following in Programmer Mode 47. Press **F2** to Select 'DWORD' 48. Press **F3** to Select 'WORD' 49. Press **F4** to Select 'BYTE' @@ -348,6 +350,6 @@ Verify the following in Programmer Mode 58. Press **<** to Select 'Lsh' 59. Press **>** to Select 'Rsh' 60. Press **%** to Select 'Mod' -61. Press ** | ** to Select 'Or' +61. Press **|** to Select 'Or' 62. Press **~** to Select 'Not' 63. Press **&** to Select 'And' From 28f982a6e19b685511c58258af0b0a66f3759edf Mon Sep 17 00:00:00 2001 From: Matt Cooley Date: Tue, 26 Feb 2019 20:41:04 -0800 Subject: [PATCH 13/13] Apply spell check (#41) --- src/CalcManager/CEngine/CalcInput.cpp | 4 +- src/CalcManager/CEngine/CalcUtils.cpp | 6 +-- src/CalcManager/CEngine/History.cpp | 4 +- src/CalcManager/CEngine/scicomm.cpp | 50 +++++++++---------- src/CalcManager/CEngine/scidisp.cpp | 4 +- src/CalcManager/CEngine/sciset.cpp | 16 +++--- src/CalcManager/CalculatorManager.cpp | 6 +-- src/CalcManager/CalculatorManager.h | 2 +- src/CalcManager/Header Files/CCommand.h | 4 +- src/CalcManager/Header Files/CalcEngine.h | 8 +-- src/CalcManager/Header Files/CalcUtils.h | 6 +-- src/CalcManager/Header Files/EngineStrings.h | 4 +- src/CalcManager/Header Files/History.h | 6 +-- src/CalcManager/Ratpack/CalcErr.h | 8 +-- src/CalcManager/Ratpack/basex.cpp | 12 ++--- src/CalcManager/Ratpack/conv.cpp | 32 ++++++------ src/CalcManager/Ratpack/exp.cpp | 6 +-- src/CalcManager/Ratpack/num.cpp | 12 ++--- src/CalcManager/Ratpack/rat.cpp | 2 +- src/CalcManager/Ratpack/support.cpp | 4 +- src/CalcManager/Ratpack/trans.cpp | 4 +- src/CalcManager/UnitConverter.cpp | 4 +- .../Common/AlwaysSelectedCollectionView.h | 4 +- .../NarratorAnnouncementHostFactory.cpp | 6 +-- .../Common/CalculatorDisplay.cpp | 4 +- src/CalcViewModel/Common/CopyPasteManager.cpp | 2 +- src/CalcViewModel/Common/DateCalculator.cpp | 2 +- .../Common/KeyboardShortcutManager.h | 2 +- src/CalcViewModel/Common/TraceLogger.h | 2 +- .../StandardCalculatorViewModel.cpp | 2 +- src/CalcViewModel/UnitConverterViewModel.h | 2 +- src/Calculator/Common/AppLifecycleLogger.h | 4 +- src/Calculator/Controls/CalculationResult.cpp | 4 +- src/Calculator/Controls/OverflowTextBlock.cpp | 4 +- .../CalculatorProgrammerBitFlipPanel.xaml.cpp | 2 +- src/Calculator/Views/MainPage.xaml.cpp | 4 +- src/Calculator/Views/Memory.xaml.cpp | 2 +- src/Calculator/Views/NumberPad.xaml | 2 +- .../Views/SupplementaryResults.xaml.cpp | 4 +- src/Calculator/WindowFrameService.cpp | 2 +- src/CalculatorUnitTests/CalcInputTest.cpp | 4 +- 41 files changed, 131 insertions(+), 131 deletions(-) diff --git a/src/CalcManager/CEngine/CalcInput.cpp b/src/CalcManager/CEngine/CalcInput.cpp index 6b6ada4c..f7037aa3 100644 --- a/src/CalcManager/CEngine/CalcInput.cpp +++ b/src/CalcManager/CEngine/CalcInput.cpp @@ -59,7 +59,7 @@ bool CalcInput::TryToggleSign(bool isIntegerMode, wstring_view maxNumStr) bool CalcInput::TryAddDigit(unsigned int value, uint32_t radix, bool isIntegerMode, wstring_view maxNumStr, long wordBitWidth, int maxDigits) { // Convert from an integer into a character - // This includes both normal digits and alpha 'digits' for radices > 10 + // This includes both normal digits and alpha 'digits' for radixes > 10 auto chDigit = static_cast((value < 10) ? (L'0' + value) : (L'A' + value - 10)); CalcNumSec* pNumSec; @@ -80,7 +80,7 @@ bool CalcInput::TryAddDigit(unsigned int value, uint32_t radix, bool isIntegerMo maxCount++; } // First leading 0 is not counted in input restriction as the output can be of that form - // See NumberToString algorithm. REVIEW: We dont have such input restriction mimicking based on output of NumberToString for exponent + // See NumberToString algorithm. REVIEW: We don't have such input restriction mimicking based on output of NumberToString for exponent // NumberToString can give 10 digit exponent, but we still restrict the exponent here to be only 4 digits. if (!pNumSec->IsEmpty() && pNumSec->value.front() == L'0') { diff --git a/src/CalcManager/CEngine/CalcUtils.cpp b/src/CalcManager/CEngine/CalcUtils.cpp index e398d8d9..4aa8311d 100644 --- a/src/CalcManager/CEngine/CalcUtils.cpp +++ b/src/CalcManager/CEngine/CalcUtils.cpp @@ -1,4 +1,4 @@ -// Copyright (c) Microsoft Corporation. All rights reserved. +// Copyright (c) Microsoft Corporation. All rights reserved. // Licensed under the MIT License. #include "pch.h" @@ -14,8 +14,8 @@ bool IsBinOpCode(WPARAM opCode) return IsOpInRange(opCode, IDC_AND, IDC_PWR); } -// WARNING: IDC_SIGN is a special unary op but still this doesnt catch this. Caller has to be aware -// of it and catch it themself or not needing this +// WARNING: IDC_SIGN is a special unary op but still this doesn't catch this. Caller has to be aware +// of it and catch it themselves or not needing this bool IsUnaryOpCode(WPARAM opCode) { return IsOpInRange(opCode, IDC_UNARYFIRST, IDC_UNARYLAST); diff --git a/src/CalcManager/CEngine/History.cpp b/src/CalcManager/CEngine/History.cpp index 06f9a955..5724af2b 100644 --- a/src/CalcManager/CEngine/History.cpp +++ b/src/CalcManager/CEngine/History.cpp @@ -129,7 +129,7 @@ void CHistoryCollector::AddBinOpToHistory(int nOpCode, bool fNoRepetition) } // This is expected to be called when a binary op in the last say 1+2+ is changing to another one say 1+2* (+ changed to *) -// It needs to know by this change a Precedence inversion happenned. i.e. previous op was lower or equal to its previous op, but the new +// It needs to know by this change a Precedence inversion happened. i.e. previous op was lower or equal to its previous op, but the new // one isn't. (Eg. 1*2* to 1*2^). It can add explicit brackets to ensure the precedence is inverted. (Eg. (1*2) ^) void CHistoryCollector::ChangeLastBinOp(int nOpCode, bool fPrecInvToHigher) { @@ -196,7 +196,7 @@ bool CHistoryCollector::FOpndAddedToHistory() // AddUnaryOpToHistory // -// This is does the postfix to prefix transalation of the input and adds the text to the history. Eg. doing 2 + 4 (sqrt), +// This is does the postfix to prefix translation of the input and adds the text to the history. Eg. doing 2 + 4 (sqrt), // this routine will ensure the last sqrt call unary operator, actually goes back in history and wraps 4 in sqrt(4) // void CHistoryCollector::AddUnaryOpToHistory(int nOpCode, bool fInv, ANGLE_TYPE angletype) diff --git a/src/CalcManager/CEngine/scicomm.cpp b/src/CalcManager/CEngine/scicomm.cpp index 72cfe419..71bec081 100644 --- a/src/CalcManager/CEngine/scicomm.cpp +++ b/src/CalcManager/CEngine/scicomm.cpp @@ -4,7 +4,7 @@ /****************************Module*Header***********************************\ * Module Name: SCICOMM.C * -* Module Descripton: +* Module Description: * * Warnings: * @@ -28,8 +28,8 @@ using namespace CalcEngine; // NPrecedenceOfOp // -// returns a virtual number for precendence for the operator. We expect binary operator only, otherwise the lowest number -// 0 is returned. Higher the number, higher the precendence of the operator. +// returns a virtual number for precedence for the operator. We expect binary operator only, otherwise the lowest number +// 0 is returned. Higher the number, higher the precedence of the operator. INT NPrecedenceOfOp(int nopCode) { static BYTE rgbPrec[] = { 0,0, IDC_OR,0, IDC_XOR,0, IDC_AND,1, @@ -53,12 +53,12 @@ INT NPrecedenceOfOp(int nopCode) // HandleErrorCommand // // When it is discovered by the state machine that at this point the input is not valid (eg. "1+)"), we want to proceed as though this input never -// occured and may be some feedback to user like Beep. The rest of input can then continue by just ignoring this command. +// occurred and may be some feedback to user like Beep. The rest of input can then continue by just ignoring this command. void CCalcEngine::HandleErrorCommand(WPARAM idc) { if (!IsGuiSettingOpCode(idc)) { - // we would have saved the prev command. Need to unremember this state + // we would have saved the prev command. Need to forget this state m_nTempCom = m_nLastCom; } } @@ -184,23 +184,23 @@ void CCalcEngine::ProcessCommandWorker(WPARAM wParam) if (IsBinOpCode(m_nLastCom)) { INT nPrev; - bool fPrecInvToHigher = false; // Is Precedence Invertion from lower to higher precedence happenning ?? + bool fPrecInvToHigher = false; // Is Precedence Inversion from lower to higher precedence happening ?? m_nOpCode = (INT)wParam; - // Check to see if by changing this binop, a Precedence invertion is happenning. + // Check to see if by changing this binop, a Precedence inversion is happening. // Eg. 1 * 2 + and + is getting changed to ^. The previous precedence rules would have already computed - // 1*2, so we will put additional brackets to cover for precedence invertion and it will become (1 * 2) ^ + // 1*2, so we will put additional brackets to cover for precedence inversion and it will become (1 * 2) ^ // Here * is m_nPrevOpCode, m_currentVal is 2 (by 1*2), m_nLastCom is +, m_nOpCode is ^ if (m_fPrecedence && 0 != m_nPrevOpCode) { nPrev = NPrecedenceOfOp(m_nPrevOpCode); nx = NPrecedenceOfOp(m_nLastCom); ni = NPrecedenceOfOp(m_nOpCode); - if (nx <= nPrev && ni > nPrev) // condition for Precedence Invertion + if (nx <= nPrev && ni > nPrev) // condition for Precedence Inversion { fPrecInvToHigher = true; - m_nPrevOpCode = 0; // Once the precedence invertion has put additional brackets, its no longer required + m_nPrevOpCode = 0; // Once the precedence inversion has put additional brackets, its no longer required } } m_HistoryCollector.ChangeLastBinOp(m_nOpCode, fPrecInvToHigher); @@ -233,7 +233,7 @@ void CCalcEngine::ProcessCommandWorker(WPARAM wParam) m_precedenceVals[m_precedenceOpCount] = m_lastVal; m_nPrecOp[m_precedenceOpCount] = m_nOpCode; - m_HistoryCollector.PushLastOpndStart(); // Eg. 1 + 2 *, Need to remember the start of 2 to do Precedence invertion if need to + m_HistoryCollector.PushLastOpndStart(); // Eg. 1 + 2 *, Need to remember the start of 2 to do Precedence inversion if need to } else { @@ -264,10 +264,10 @@ void CCalcEngine::ProcessCommandWorker(WPARAM wParam) m_lastVal = m_precedenceVals[m_precedenceOpCount]; nx = NPrecedenceOfOp(m_nOpCode); - // Precedence Invertion Higher to lower can happen which needs explicit enclosure of brackets + // Precedence Inversion Higher to lower can happen which needs explicit enclosure of brackets // Eg. 1 + 2 * Or 3 Or. We would have pushed 1+ before, and now last + forces 2 Or 3 to be evaluated // because last Or is less or equal to first + (after 1). But we see that 1+ is in stack and we evaluated to 2 Or 3 - // This is precedence invertion happenned because of operator changed in between. We put extra brackets like + // This is precedence inversion happened because of operator changed in between. We put extra brackets like // 1 + (2 Or 3) if (ni <= nx) { @@ -436,7 +436,7 @@ void CCalcEngine::ProcessCommandWorker(WPARAM wParam) { break; } - // automatic closing of all the parenthesis to get a meaning ful result as well as ensure data integrity + // automatic closing of all the parenthesis to get a meaningful result as well as ensure data integrity m_nTempCom = m_nLastCom; // Put back this last saved command to the prev state so ) can be handled properly ProcessCommand(IDC_CLOSEP); m_nLastCom = m_nTempCom; // Actually this is IDC_CLOSEP @@ -445,7 +445,7 @@ void CCalcEngine::ProcessCommandWorker(WPARAM wParam) if (!m_bNoPrevEqu) { - // It is possible now unary op changed the num in screen, but still m_lastVal hasnt changed. + // It is possible now unary op changed the num in screen, but still m_lastVal hasn't changed. m_lastVal = m_currentVal; } @@ -502,7 +502,7 @@ void CCalcEngine::ProcessCommandWorker(WPARAM wParam) m_nOpCode = m_nPrecOp[--m_precedenceOpCount]; m_lastVal = m_precedenceVals[m_precedenceOpCount]; - // Precedence Invertion check + // Precedence Inversion check ni = NPrecedenceOfOp(m_nPrevOpCode); nx = NPrecedenceOfOp(m_nOpCode); if (ni <= nx) @@ -540,7 +540,7 @@ void CCalcEngine::ProcessCommandWorker(WPARAM wParam) // -IF- the Paren holding array is full and we try to add a paren // -OR- the paren holding array is empty and we try to remove a // paren - // -OR- the the precidence holding array is full + // -OR- the precedence holding array is full if ((m_openParenCount >= MAXPRECDEPTH && nx) || (!m_openParenCount && !nx) || ((m_precedenceOpCount >= MAXPRECDEPTH && m_nPrecOp[m_precedenceOpCount - 1] != 0))) { @@ -612,7 +612,7 @@ void CCalcEngine::ProcessCommandWorker(WPARAM wParam) m_HistoryCollector.AddCloseBraceToHistory(); - // Now get back the operation and opcode at the begining of this parenthesis pair + // Now get back the operation and opcode at the beginning of this parenthesis pair m_openParenCount -= 1; m_lastVal = m_parenVals[m_openParenCount]; @@ -796,7 +796,7 @@ void CCalcEngine::CheckAndAddLastBinOpToHistory(bool addToHistory) { if (m_HistoryCollector.FOpndAddedToHistory()) { - // if lasttime opnd was added but the last command was not a binary operator, then it must have come + // if last time opnd was added but the last command was not a binary operator, then it must have come // from commands which add the operand, like unary operator. So history at this is showing 1 + sqrt(4) // but in reality the sqrt(4) is getting replaced by new number (may be unary op, or MR or SUM etc.) // So erase the last operand @@ -827,7 +827,7 @@ void CCalcEngine::CheckAndAddLastBinOpToHistory(bool addToHistory) } // change the display area from a static text to an editbox, which has the focus can make -// Magnifer (Accessibility tool) work +// Magnifier (Accessibility tool) work void CCalcEngine::SetPrimaryDisplay(const wstring& szText, bool isError) { if (m_pCalcDisplay != nullptr) @@ -848,8 +848,8 @@ void CCalcEngine::DisplayAnnounceBinaryOperator() } // Unary operator Function Name table Element -// since unary operators button names are'nt exactly friendly for history purpose, -// we have this seperate table to get its localized name and for its Inv function if it exists. +// since unary operators button names aren't exactly friendly for history purpose, +// we have this separate table to get its localized name and for its Inv function if it exists. typedef struct { int idsFunc; // index of string for the unary op function. Can be NULL, in which case it same as button name @@ -905,7 +905,7 @@ wstring_view CCalcEngine::OpCodeToUnaryString(int nOpCode, bool fInv, ANGLE_TYPE return GetString(IDS_DEGREES); } - // Correct the trigometric functions with type of angle argument they take + // Correct the trigonometric functions with type of angle argument they take if (ANGLE_RAD == angletype) { switch (nOpCode) @@ -963,7 +963,7 @@ wstring_view CCalcEngine::OpCodeToUnaryString(int nOpCode, bool fInv, ANGLE_TYPE // // Sets the Angle Mode for special unary op IDC's which are used to index to the table rgUfne -// and returns the equivalent plain IDC for trignometric function. If it isnt a trignometric function +// and returns the equivalent plain IDC for trigonometric function. If it isn't a trigonometric function // returns the passed in idc itself. int CCalcEngine::IdcSetAngleTypeDecMode(int idc) { @@ -1047,7 +1047,7 @@ wstring CCalcEngine::GetStringForDisplay(Rational const& rat, uint32_t radix) 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. + // If high bit is set, then get the decimal number in negative 2's complement form. tempRat = -((tempRat ^ m_chopNumbers[m_numwidth]) + 1); } diff --git a/src/CalcManager/CEngine/scidisp.cpp b/src/CalcManager/CEngine/scidisp.cpp index 2d0e8f39..431a3990 100644 --- a/src/CalcManager/CEngine/scidisp.cpp +++ b/src/CalcManager/CEngine/scidisp.cpp @@ -4,7 +4,7 @@ /****************************Module*Header***********************************\ * Module Name: SCIDISP.C * -* Module Descripton: +* Module Description: * * Warnings: * @@ -116,7 +116,7 @@ void CCalcEngine::DisplayNum(void) m_numberString = GetStringForDisplay(m_currentVal, m_radix); } - // Displayed number can go thru transformation. So copy it after transformation + // Displayed number can go through transformation. So copy it after transformation gldPrevious.value = m_currentVal; if ((m_radix == 10) && IsNumberInvalid(m_numberString, MAX_EXPONENT, m_precision, m_radix)) diff --git a/src/CalcManager/CEngine/sciset.cpp b/src/CalcManager/CEngine/sciset.cpp index 1ae1dbcb..01dd3d3b 100644 --- a/src/CalcManager/CEngine/sciset.cpp +++ b/src/CalcManager/CEngine/sciset.cpp @@ -13,7 +13,7 @@ void CCalcEngine::SetRadixTypeAndNumWidth(RADIX_TYPE radixtype, NUM_WIDTH numwid { // When in integer mode, the number is represented in 2's complement form. When a bit width is changing, we can // change the number representation back to sign, abs num form in ratpak. Soon when display sees this, it will - // convert to 2's complement form, but this time all high bits will be propogated. Eg. -127, in byte mode is + // convert to 2's complement form, but this time all high bits will be propagated. Eg. -127, in byte mode is // represented as 1000,0001. This puts it back as sign=-1, 01111111 . But DisplayNum will see this and convert it // back to 1111,1111,1000,0001 when in Word mode. if (m_fIntegerMode) @@ -42,7 +42,7 @@ void CCalcEngine::SetRadixTypeAndNumWidth(RADIX_TYPE radixtype, NUM_WIDTH numwid m_dwWordBitWidth = DwWordBitWidthFromeNumWidth(numwidth); } - // inform ratpak that a change in base or precision has occured + // inform ratpak that a change in base or precision has occurred BaseOrPrecisionChanged(); // display the correct number for the new state (ie convert displayed @@ -130,8 +130,8 @@ int CCalcEngine::QuickLog2(int iNum) // word size, and base. This number is conservative towards the small side // such that there may be some extra bits left over. For example, base 8 requires 3 bits per digit. // A word size of 32 bits allows for 10 digits with a remainder of two bits. Bases -// that require variable numnber of bits (non-power-of-two bases) are approximated -// by the next highest power-of-two base (again, to be conservative and gaurentee +// that require variable number of bits (non-power-of-two bases) are approximated +// by the next highest power-of-two base (again, to be conservative and guarantee // there will be no over flow verse the current word size for numbers entered). // Base 10 is a special case and always uses the base 10 precision (m_nPrecisionSav). void CCalcEngine::UpdateMaxIntDigits() @@ -160,10 +160,10 @@ void CCalcEngine::ChangeBaseConstants(uint32_t radix, int maxIntDigits, int32_t { if (10 == radix) { - ChangeConstants(radix, precision); // Base 10 precesion for internal computing still needs to be 32, to - // take care of decimals preceisly. For eg. to get the HI word of a qword, we do a rsh, which depends on getting - // 18446744073709551615 / 4294967296 = 4294967295.9999917... This is important it works this and doesnt reduce - // the precision to number of digits allowed to enter. In otherwords precision and # of allowed digits to be + ChangeConstants(radix, precision); // Base 10 precision for internal computing still needs to be 32, to + // take care of decimals precisely. For eg. to get the HI word of a qword, we do a rsh, which depends on getting + // 18446744073709551615 / 4294967296 = 4294967295.9999917... This is important it works this and doesn't reduce + // the precision to number of digits allowed to enter. In other words, precision and # of allowed digits to be // entered are different. } else diff --git a/src/CalcManager/CalculatorManager.cpp b/src/CalcManager/CalculatorManager.cpp index d768e7af..1d62e010 100644 --- a/src/CalcManager/CalculatorManager.cpp +++ b/src/CalcManager/CalculatorManager.cpp @@ -600,8 +600,8 @@ namespace CalculationManager } /// -/// Helper function that selects a memeory from the vector and set it to CCalcEngine -/// Saved RAT number needs to be copied and passed in, as CCalcEngine destoried the passed in RAT +/// Helper function that selects a memory from the vector and set it to CCalcEngine +/// Saved RAT number needs to be copied and passed in, as CCalcEngine destroyed the passed in RAT /// /// Index of the target memory void CalculatorManager::MemorizedNumberSelect(_In_ unsigned int indexOfMemory) @@ -615,7 +615,7 @@ namespace CalculationManager /// /// Helper function that needs to be executed when memory is modified - /// When memory is modified, destory the old RAT and put the new RAT in vector + /// When memory is modified, destroy the old RAT and put the new RAT in vector /// /// Index of the target memory void CalculatorManager::MemorizedNumberChanged(_In_ unsigned int indexOfMemory) diff --git a/src/CalcManager/CalculatorManager.h b/src/CalcManager/CalculatorManager.h index f66664e8..9f60c534 100644 --- a/src/CalcManager/CalculatorManager.h +++ b/src/CalcManager/CalculatorManager.h @@ -60,7 +60,7 @@ namespace CalculationManager static const unsigned int m_maximumMemorySize = 100; - // For persistance + // For persistence std::vector m_savedCommands; std::vector m_savedPrimaryValue; std::vector m_serializedMemory; diff --git a/src/CalcManager/Header Files/CCommand.h b/src/CalcManager/Header Files/CCommand.h index 36e505ad..1944061b 100644 --- a/src/CalcManager/Header Files/CCommand.h +++ b/src/CalcManager/Header Files/CCommand.h @@ -1,10 +1,10 @@ -// Copyright (c) Microsoft Corporation. All rights reserved. +// Copyright (c) Microsoft Corporation. All rights reserved. // Licensed under the MIT License. /****************************Module*Header*********************************** * Module Name: CCommand.h * -* Module Descripton: +* Module Description: * Resource ID's for the Engine Commands exposed. * * Warnings: diff --git a/src/CalcManager/Header Files/CalcEngine.h b/src/CalcManager/Header Files/CalcEngine.h index 2e59cdbe..a0a44ffd 100644 --- a/src/CalcManager/Header Files/CalcEngine.h +++ b/src/CalcManager/Header Files/CalcEngine.h @@ -5,7 +5,7 @@ /****************************Module*Header***********************************\ * Module Name: CalcEngine.h * -* Module Descripton: +* Module Description: * The class definition for the Calculator's engine class CCalcEngine * * Warnings: @@ -69,7 +69,7 @@ public: wchar_t DecimalSeparator() const; // Static methods for the instance - static void InitialOneTimeOnlySetup(CalculationManager::IResourceProvider& resourceProvider); // Once per load time to call to intialize all shared global variables + static void InitialOneTimeOnlySetup(CalculationManager::IResourceProvider& resourceProvider); // Once per load time to call to initialize all shared global variables // returns the ptr to string representing the operator. Mostly same as the button, but few special cases for x^y etc. static std::wstring_view GetString(int ids) { return s_engineStrings[ids]; } static std::wstring_view OpCodeToString(int nOpCode) { return GetString(IdStrFromCmdId(nOpCode)); } @@ -82,10 +82,10 @@ private: CalculationManager::IResourceProvider* const m_resourceProvider; int m_nOpCode; /* ID value of operation. */ int m_nPrevOpCode; // opcode which computed the number in m_currentVal. 0 if it is already bracketed or plain number or - // if it hasnt yet been computed + // if it hasn't yet been computed bool m_bChangeOp; /* Flag for changing operation. */ bool m_bRecord; // Global mode: recording or displaying - bool m_bSetCalcState; //Falg for setting teh engine result state + bool m_bSetCalcState; //Flag for setting the engine result state CalcEngine::CalcInput m_input; // Global calc input object for decimal strings eNUMOBJ_FMT m_nFE; /* Scientific notation conversion flag. */ CalcEngine::Rational m_maxTrigonometricNum; diff --git a/src/CalcManager/Header Files/CalcUtils.h b/src/CalcManager/Header Files/CalcUtils.h index b6524a28..1e0dcae3 100644 --- a/src/CalcManager/Header Files/CalcUtils.h +++ b/src/CalcManager/Header Files/CalcUtils.h @@ -1,4 +1,4 @@ -// Copyright (c) Microsoft Corporation. All rights reserved. +// Copyright (c) Microsoft Corporation. All rights reserved. // Licensed under the MIT License. #pragma once @@ -6,8 +6,8 @@ bool IsOpInRange(WPARAM op, uint32_t x, uint32_t y); bool IsBinOpCode(WPARAM opCode); -// WARNING: IDC_SIGN is a special unary op but still this doesnt catch this. Caller has to be aware -// of it and catch it themself or not needing this +// WARNING: IDC_SIGN is a special unary op but still this doesn't catch this. Caller has to be aware +// of it and catch it themselves or not needing this bool IsUnaryOpCode(WPARAM opCode); bool IsDigitOpCode(WPARAM opCode); bool IsGuiSettingOpCode(WPARAM opCode); diff --git a/src/CalcManager/Header Files/EngineStrings.h b/src/CalcManager/Header Files/EngineStrings.h index 0f40533a..7a420c8c 100644 --- a/src/CalcManager/Header Files/EngineStrings.h +++ b/src/CalcManager/Header Files/EngineStrings.h @@ -1,10 +1,10 @@ -// Copyright (c) Microsoft Corporation. All rights reserved. +// Copyright (c) Microsoft Corporation. All rights reserved. // Licensed under the MIT License. /****************************Module*Header*********************************** * Module Name: EngineStrings.h * -* Module Descripton: +* Module Description: * Resource String ID's for the private strings used by Engine. Internal to Engine related code * not required by the clients * diff --git a/src/CalcManager/Header Files/History.h b/src/CalcManager/Header Files/History.h index 5deb5fff..39be04ef 100644 --- a/src/CalcManager/Header Files/History.h +++ b/src/CalcManager/Header Files/History.h @@ -1,4 +1,4 @@ -// Copyright (c) Microsoft Corporation. All rights reserved. +// Copyright (c) Microsoft Corporation. All rights reserved. // Licensed under the MIT License. #pragma once @@ -11,7 +11,7 @@ static constexpr size_t MAXPRECDEPTH = 25; // Helper class really a internal class to CCalcEngine, to accumulate each history line of text by collecting the -// operands, operator, unary operator etc. Since it is a seperate entity, it can be unit tested on its own but does +// operands, operator, unary operator etc. Since it is a separate entity, it can be unit tested on its own but does // rely on CCalcEngine calling it in appropriate order. class CHistoryCollector { public: @@ -38,7 +38,7 @@ private: std::shared_ptr m_pHistoryDisplay; ICalcDisplay *m_pCalcDisplay; - int m_iCurLineHistStart; // index of the begginning of the current equation + int m_iCurLineHistStart; // index of the beginning of the current equation // a sort of state, set to the index before 2 after 2 in the expression 2 + 3 say. Useful for auto correct portion of history and for // attaching the unary op around the last operand int m_lastOpStartIndex; // index of the beginning of the last operand added to the history diff --git a/src/CalcManager/Ratpack/CalcErr.h b/src/CalcManager/Ratpack/CalcErr.h index 7e9025a4..b420a766 100644 --- a/src/CalcManager/Ratpack/CalcErr.h +++ b/src/CalcManager/Ratpack/CalcErr.h @@ -1,4 +1,4 @@ -// Copyright (c) Microsoft Corporation. All rights reserved. +// Copyright (c) Microsoft Corporation. All rights reserved. // Licensed under the MIT License. // CalcErr.h @@ -6,7 +6,7 @@ // Defines the error codes thrown by ratpak and caught by Calculator // // -// Ratpak errors are 32 bit values layed out as follows: +// Ratpak errors are 32 bit values laid out as follows: // // 3 3 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1 // 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 @@ -31,8 +31,8 @@ // // Code - is the actual error code // -// This format is based losely on an OLE HRESULT and is compatible with the -// SUCCEEDED and FAILED marcos as well as the HRESULT_CODE macro +// This format is based loosely on an OLE HRESULT and is compatible with the +// SUCCEEDED and FAILED macros as well as the HRESULT_CODE macro // CALC_E_DIVIDEBYZERO // diff --git a/src/CalcManager/Ratpack/basex.cpp b/src/CalcManager/Ratpack/basex.cpp index 4fc77212..d36d7031 100644 --- a/src/CalcManager/Ratpack/basex.cpp +++ b/src/CalcManager/Ratpack/basex.cpp @@ -1,4 +1,4 @@ -// Copyright (c) Microsoft Corporation. All rights reserved. +// Copyright (c) Microsoft Corporation. All rights reserved. // Licensed under the MIT License. //----------------------------------------------------------------------------- @@ -42,7 +42,7 @@ void __inline mulnumx( PNUMBER *pa, PNUMBER b ) // If b is not one we multiply if ( (*pa)->cdigit > 1 || (*pa)->mant[0] != 1 || (*pa)->exp != 0 ) { - // pa and b are both nonone. + // pa and b are both non-one. _mulnumx( pa, b ); } else @@ -71,7 +71,7 @@ void __inline mulnumx( PNUMBER *pa, PNUMBER b ) // // DESCRIPTION: Does the number equivalent of *pa *= b. // Assumes the base is BASEX of both numbers. This algorithm is the -// same one you learned in gradeschool, except the base isn't 10 it's +// same one you learned in grade school, except the base isn't 10 it's // BASEX. // //---------------------------------------------------------------------------- @@ -148,7 +148,7 @@ void _mulnumx( PNUMBER *pa, PNUMBER b ) } } - // prevent different kinds of zeros, by stripping leading duplicate zeroes. + // prevent different kinds of zeros, by stripping leading duplicate zeros. // digits are in order of increasing significance. while ( c->cdigit > 1 && c->mant[c->cdigit-1] == 0 ) { @@ -342,7 +342,7 @@ void _divnumx( PNUMBER *pa, PNUMBER b, int32_t precision) if ( !cdigits ) { - // A zero, make sure no wierd exponents creep in + // A zero, make sure no weird exponents creep in c->exp = 0; c->cdigit = 1; } @@ -351,7 +351,7 @@ void _divnumx( PNUMBER *pa, PNUMBER b, int32_t precision) c->cdigit = cdigits; c->exp -= cdigits; // prevent different kinds of zeros, by stripping leading duplicate - // zeroes. digits are in order of increasing significance. + // zeros. digits are in order of increasing significance. while ( c->cdigit > 1 && c->mant[c->cdigit-1] == 0 ) { c->cdigit--; diff --git a/src/CalcManager/Ratpack/conv.cpp b/src/CalcManager/Ratpack/conv.cpp index 05d118fb..52609911 100644 --- a/src/CalcManager/Ratpack/conv.cpp +++ b/src/CalcManager/Ratpack/conv.cpp @@ -33,7 +33,7 @@ long g_ratio; // int(log(2L^BASEXPWR)/log(radix)) // Default decimal separator wchar_t g_decimalSeparator = L'.'; -// Used to strip trailing zeroes, and prevent combinatorial explosions +// Used to strip trailing zeros, and prevent combinatorial explosions bool stripzeroesnum(_Inout_ PNUMBER pnum, long starting); void SetDecimalSeparator(wchar_t decimalSeparator) @@ -121,7 +121,7 @@ void _destroyrat( _In_ PRAT prat ) // // RETURN: pointer to a number // -// DESCRIPTION: allocates and zeroes out number type. +// DESCRIPTION: allocates and zeros out number type. // //----------------------------------------------------------------------------- @@ -480,7 +480,7 @@ PRAT StringToRat(bool mantissaIsNegative, wstring_view mantissa, bool exponentIs // ZR '0' // NZ '1'..'9' 'A'..'Z' 'a'..'z' '@' '_' // SG '+' '-' -// EX 'e' '^' e is used for radix 10, ^ for all other radixs. +// EX 'e' '^' e is used for radix 10, ^ for all other radixes. // //----------------------------------------------------------------------------- static constexpr uint8_t DP = 0; @@ -911,8 +911,8 @@ unsigned long rattoUlong( _In_ PRAT prat, uint32_t radix, int32_t precision) // DESCRIPTION: returns the 64 bit (irrespective of which processor this is running in) representation of the // number input. Assumes that the number is in the internal // base. Can throw exception if the number exceeds 2^64 -// Implementation by getting the HI & LO 32 bit words and concating them, as the -// internal base choosen happens to be 2^32, this is easier. +// Implementation by getting the HI & LO 32 bit words and concatenating them, as the +// internal base chosen happens to be 2^32, this is easier. //----------------------------------------------------------------------------- ULONGLONG rattoUlonglong( _In_ PRAT prat, uint32_t radix, int32_t precision) @@ -981,7 +981,7 @@ long numtolong( _In_ PNUMBER pnum, uint32_t radix ) // // RETURN: true if stripping done, modifies number in place. // -// DESCRIPTION: Strips off trailing zeroes. +// DESCRIPTION: Strips off trailing zeros. // //----------------------------------------------------------------------------- @@ -1001,7 +1001,7 @@ bool stripzeroesnum(_Inout_ PNUMBER pnum, long starting) cdigits = starting; } - // Check we haven't gone too far, and we are still looking at zeroes. + // Check we haven't gone too far, and we are still looking at zeros. while ( ( cdigits > 0 ) && !(*pmant) ) { // move to next significant digit and keep track of digits we can @@ -1011,7 +1011,7 @@ bool stripzeroesnum(_Inout_ PNUMBER pnum, long starting) fstrip = true; } - // If there are zeroes to remove. + // If there are zeros to remove. if ( fstrip ) { // Remove them. @@ -1061,7 +1061,7 @@ wstring NumberToString(_Inout_ PNUMBER& pnum, int format, uint32_t radix, int32_ // 10 for maximum exponent size. int cchNum = (precision + 16); - // If there is a chance a round has to occour, round. + // If there is a chance a round has to occur, round. // - if number is zero no rounding // - if number of digits is less than the maximum output no rounding PNUMBER round = nullptr; @@ -1087,7 +1087,7 @@ wstring NumberToString(_Inout_ PNUMBER& pnum, int format, uint32_t radix, int32_ if (format == FMT_FLOAT) { - // Figure out if the exponent will fill more space than the nonexponent field. + // Figure out if the exponent will fill more space than the non-exponent field. if ((length - exponent > precision) || (exponent > precision + 3)) { if (exponent >= -MAX_ZEROS_AFTER_DECIMAL) @@ -1097,15 +1097,15 @@ wstring NumberToString(_Inout_ PNUMBER& pnum, int format, uint32_t radix, int32_ } else { - // Case where too many zeroes are to the right or left of the + // Case where too many zeros are to the right or left of the // decimal pt. And we are forced to switch to scientific form. format = FMT_SCIENTIFIC; } } else if (length + abs(exponent) < precision && round) { - // Minimum loss of precision occours with listing leading zeros - // if we need to make room for zeroes sacrifice some digits. + // Minimum loss of precision occurs with listing leading zeros + // if we need to make room for zeros sacrifice some digits. round->exp -= exponent; } } @@ -1118,7 +1118,7 @@ wstring NumberToString(_Inout_ PNUMBER& pnum, int format, uint32_t radix, int32_ if (stripzeroesnum(pnum, offset)) { // WARNING: nesting/recursion, too much has been changed, need to - // refigure format. + // re-figure format. return NumberToString(pnum, oldFormat, radix, precision); } } @@ -1165,7 +1165,7 @@ wstring NumberToString(_Inout_ PNUMBER& pnum, int format, uint32_t radix, int32_ // Begin building the result string wstringstream resultStream{}; - // Make sure negative zeroes aren't allowed. + // Make sure negative zeros aren't allowed. if ((pnum->sign == -1) && (length > 0)) { resultStream << L'-'; @@ -1399,7 +1399,7 @@ PNUMBER longfactnum(long inlong, uint32_t radix) // ARGUMENTS: // long integer to factorialize. // long integer representing base of answer. -// unsignd long integer for radix +// unsigned long integer for radix // // RETURN: Factorial of input in base PNUMBER form. // diff --git a/src/CalcManager/Ratpack/exp.cpp b/src/CalcManager/Ratpack/exp.cpp index 19545663..ec87204a 100644 --- a/src/CalcManager/Ratpack/exp.cpp +++ b/src/CalcManager/Ratpack/exp.cpp @@ -1,4 +1,4 @@ -// Copyright (c) Microsoft Corporation. All rights reserved. +// Copyright (c) Microsoft Corporation. All rights reserved. // Licensed under the MIT License. //----------------------------------------------------------------------------- @@ -235,7 +235,7 @@ void log10rat( PRAT *px, int32_t precision) } // -// return if the given x is even number. The assumption here is its numberator is 1 and we are testing the numerator is +// return if the given x is even number. The assumption here is its numerator is 1 and we are testing the numerator is // even or not bool IsEven(PRAT x, uint32_t radix, int32_t precision) { @@ -291,7 +291,7 @@ void powrat(PRAT *px, PRAT y, uint32_t radix, int32_t precision) catch (...) { // If calculating the power using numerator/denominator - // failed, fallback to the less accurate method of + // failed, fall back to the less accurate method of // passing in the original y powratcomp(px, y, radix, precision); } diff --git a/src/CalcManager/Ratpack/num.cpp b/src/CalcManager/Ratpack/num.cpp index 07c93b05..76fa91a1 100644 --- a/src/CalcManager/Ratpack/num.cpp +++ b/src/CalcManager/Ratpack/num.cpp @@ -1,4 +1,4 @@ -// Copyright (c) Microsoft Corporation. All rights reserved. +// Copyright (c) Microsoft Corporation. All rights reserved. // Licensed under the MIT License. //----------------------------------------------------------------------------- @@ -150,7 +150,7 @@ void _addnum( PNUMBER *pa, PNUMBER b, uint32_t radix) } else { - // In this particular case an overflow or underflow has occoured + // In this particular case an overflow or underflow has occurred // and all the digits need to be complemented, at one time an // attempt to handle this above was made, it turned out to be much // slower on average. @@ -167,7 +167,7 @@ void _addnum( PNUMBER *pa, PNUMBER b, uint32_t radix) } } - // Remove leading zeroes, remember digits are in order of + // Remove leading zeros, remember digits are in order of // increasing significance. i.e. 100 would be 0,0,1 while ( c->cdigit > 1 && *(--pchc) == 0 ) { @@ -188,7 +188,7 @@ void _addnum( PNUMBER *pa, PNUMBER b, uint32_t radix) // // DESCRIPTION: Does the number equivalent of *pa *= b. // Assumes radix is the radix of both numbers. This algorithm is the -// same one you learned in gradeschool. +// same one you learned in grade school. // //---------------------------------------------------------------------------- @@ -200,7 +200,7 @@ void __inline mulnum( PNUMBER *pa, PNUMBER b, uint32_t radix) if ( b->cdigit > 1 || b->mant[0] != 1 || b->exp != 0 ) { // If b is one we don't multiply exactly. if ( (*pa)->cdigit > 1 || (*pa)->mant[0] != 1 || (*pa)->exp != 0 ) - { // pa and b are both nonone. + { // pa and b are both non-one. _mulnum( pa, b, radix); } else @@ -285,7 +285,7 @@ void _mulnum( PNUMBER *pa, PNUMBER b, uint32_t radix) } } - // prevent different kinds of zeros, by stripping leading duplicate zeroes. + // prevent different kinds of zeros, by stripping leading duplicate zeros. // digits are in order of increasing significance. while ( c->cdigit > 1 && c->mant[c->cdigit-1] == 0 ) { diff --git a/src/CalcManager/Ratpack/rat.cpp b/src/CalcManager/Ratpack/rat.cpp index efc448dd..11668b74 100644 --- a/src/CalcManager/Ratpack/rat.cpp +++ b/src/CalcManager/Ratpack/rat.cpp @@ -237,7 +237,7 @@ void addrat( PRAT *pa, PRAT b, int32_t precision) (*pa)->pq = bot; trimit(pa, precision); - // Get rid of negative zeroes here. + // Get rid of negative zeros here. (*pa)->pp->sign *= (*pa)->pq->sign; (*pa)->pq->sign = 1; } diff --git a/src/CalcManager/Ratpack/support.cpp b/src/CalcManager/Ratpack/support.cpp index 65c2b4c3..d747b4d1 100644 --- a/src/CalcManager/Ratpack/support.cpp +++ b/src/CalcManager/Ratpack/support.cpp @@ -474,7 +474,7 @@ void scale( PRAT *px, PRAT scalefact, uint32_t radix, int32_t precision ) DUPRAT(pret,*px); // Logscale is a quick way to tell how much extra precision is needed for - // scaleing by scalefact. + // scaling by scalefact. long logscale = g_ratio * ( (pret->pp->cdigit+pret->pp->exp) - (pret->pq->cdigit+pret->pq->exp) ); if ( logscale > 0 ) @@ -509,7 +509,7 @@ void scale2pi( PRAT *px, uint32_t radix, int32_t precision ) DUPRAT(pret,*px); // Logscale is a quick way to tell how much extra precision is needed for - // scaleing by 2 pi. + // scaling by 2 pi. long logscale = g_ratio * ( (pret->pp->cdigit+pret->pp->exp) - (pret->pq->cdigit+pret->pq->exp) ); if ( logscale > 0 ) diff --git a/src/CalcManager/Ratpack/trans.cpp b/src/CalcManager/Ratpack/trans.cpp index 1bbfee6d..ad82a94d 100644 --- a/src/CalcManager/Ratpack/trans.cpp +++ b/src/CalcManager/Ratpack/trans.cpp @@ -1,4 +1,4 @@ -// Copyright (c) Microsoft Corporation. All rights reserved. +// Copyright (c) Microsoft Corporation. All rights reserved. // Licensed under the MIT License. //---------------------------------------------------------------------------- @@ -134,7 +134,7 @@ void sinanglerat( _Inout_ PRAT *pa, ANGLE_TYPE angletype, uint32_t radix, int32_ // // ARGUMENTS: x PRAT representation of number to take the cosine of // -// RETURN: cosin of x in PRAT form. +// RETURN: cosine of x in PRAT form. // // EXPLANATION: This uses Taylor series // diff --git a/src/CalcManager/UnitConverter.cpp b/src/CalcManager/UnitConverter.cpp index a3109386..587a311c 100644 --- a/src/CalcManager/UnitConverter.cpp +++ b/src/CalcManager/UnitConverter.cpp @@ -1,4 +1,4 @@ -// Copyright (c) Microsoft Corporation. All rights reserved. +// Copyright (c) Microsoft Corporation. All rights reserved. // Licensed under the MIT License. #include "pch.h" @@ -1024,7 +1024,7 @@ void UnitConverter::Calculate() } /// -/// Trims out any trailing zeroes or decimals in the given input string +/// Trims out any trailing zeros or decimals in the given input string /// /// wstring to trim void UnitConverter::TrimString(wstring& returnString) diff --git a/src/CalcViewModel/Common/AlwaysSelectedCollectionView.h b/src/CalcViewModel/Common/AlwaysSelectedCollectionView.h index e04f1360..2174fdf4 100644 --- a/src/CalcViewModel/Common/AlwaysSelectedCollectionView.h +++ b/src/CalcViewModel/Common/AlwaysSelectedCollectionView.h @@ -1,4 +1,4 @@ -// Copyright (c) Microsoft Corporation. All rights reserved. +// Copyright (c) Microsoft Corporation. All rights reserved. // Licensed under the MIT License. #pragma once @@ -61,7 +61,7 @@ namespace CalculatorApp { namespace Common } } - // Implementented methods + // Implemented methods virtual bool MoveCurrentTo(Platform::Object^ item) = Windows::UI::Xaml::Data::ICollectionView::MoveCurrentTo { if (item) diff --git a/src/CalcViewModel/Common/Automation/NarratorAnnouncementHostFactory.cpp b/src/CalcViewModel/Common/Automation/NarratorAnnouncementHostFactory.cpp index 5c62a3bd..ed773149 100644 --- a/src/CalcViewModel/Common/Automation/NarratorAnnouncementHostFactory.cpp +++ b/src/CalcViewModel/Common/Automation/NarratorAnnouncementHostFactory.cpp @@ -1,4 +1,4 @@ -// Copyright (c) Microsoft Corporation. All rights reserved. +// Copyright (c) Microsoft Corporation. All rights reserved. // Licensed under the MIT License. #include "pch.h" @@ -23,8 +23,8 @@ int NarratorAnnouncementHostFactory::Initialize() } // For now, there are two type of announcement hosts. -// We'd prefer to use Notification if it's available and fallback to LiveRegion -// if not. The availabilty of the host depends on the version of the OS the app is running on. +// We'd prefer to use Notification if it's available and fall back to LiveRegion +// if not. The availability of the host depends on the version of the OS the app is running on. // When the app switches to min version RS3, the LiveRegionHost can be removed and we will always // use NotificationHost. // TODO - MSFT 12735088 diff --git a/src/CalcViewModel/Common/CalculatorDisplay.cpp b/src/CalcViewModel/Common/CalculatorDisplay.cpp index 6001b647..705da22c 100644 --- a/src/CalcViewModel/Common/CalculatorDisplay.cpp +++ b/src/CalcViewModel/Common/CalculatorDisplay.cpp @@ -1,7 +1,7 @@ -// Copyright (c) Microsoft Corporation. All rights reserved. +// Copyright (c) Microsoft Corporation. All rights reserved. // Licensed under the MIT License. -// This class provides the concrete implemenation for the ICalcDisplay interface +// This class provides the concrete implementation for the ICalcDisplay interface // that is declared in the Calculation Manager Library. #include "pch.h" #include "CalculatorDisplay.h" diff --git a/src/CalcViewModel/Common/CopyPasteManager.cpp b/src/CalcViewModel/Common/CopyPasteManager.cpp index 31e36d4e..c8f9c5f0 100644 --- a/src/CalcViewModel/Common/CopyPasteManager.cpp +++ b/src/CalcViewModel/Common/CopyPasteManager.cpp @@ -88,7 +88,7 @@ task CopyPasteManager::GetStringToPaste(ViewMode mode, CategoryGroupTyp // Retrieve the text in the clipboard auto dataPackageView = Clipboard::GetContent(); - // TODO: Suport all formats supported by ClipboardHasText + // TODO: Support all formats supported by ClipboardHasText //-- add support to avoid pasting of expressions like 12 34(as of now we allow 1234) //-- add support to allow pasting for expressions like .2 , -.2 //-- add support to allow pasting for expressions like 1.3e12(as of now we allow 1.3e+12) diff --git a/src/CalcViewModel/Common/DateCalculator.cpp b/src/CalcViewModel/Common/DateCalculator.cpp index ac0dbbe9..79092216 100644 --- a/src/CalcViewModel/Common/DateCalculator.cpp +++ b/src/CalcViewModel/Common/DateCalculator.cpp @@ -154,7 +154,7 @@ void DateCalculationEngine::GetDateDifference(_In_ DateTime date1, _In_ DateTime if (tempDaysDiff < 0) { - // pivotDate has gone over the end date; start from the begining of this unit + // pivotDate has gone over the end date; start from the beginning of this unit differenceInDates[unitIndex] -= 1; pivotDate = tempPivotDate; pivotDate = AdjustCalendarDate(pivotDate, dateUnit, static_cast(differenceInDates[unitIndex])); diff --git a/src/CalcViewModel/Common/KeyboardShortcutManager.h b/src/CalcViewModel/Common/KeyboardShortcutManager.h index d747655b..6e3f210b 100644 --- a/src/CalcViewModel/Common/KeyboardShortcutManager.h +++ b/src/CalcViewModel/Common/KeyboardShortcutManager.h @@ -32,7 +32,7 @@ namespace CalculatorApp // Sometimes, like with popups, escape is treated as special and even // though it is handled we get it passed through to us. In those cases - // we need to be able to ignore it (looking at e->Hanlded isn't sufficient + // we need to be able to ignore it (looking at e->Handled isn't sufficient // because that always returns true). // The onlyOnce flag is used to indicate whether we should only ignore the // next escape, or keep ignoring until you explicitly HonorEscape. diff --git a/src/CalcViewModel/Common/TraceLogger.h b/src/CalcViewModel/Common/TraceLogger.h index c995b985..b0213b2c 100644 --- a/src/CalcViewModel/Common/TraceLogger.h +++ b/src/CalcViewModel/Common/TraceLogger.h @@ -104,7 +104,7 @@ namespace CalculatorApp TraceLogger(); // Any new Log method should - // a) decide the level of logging. This will help us in limiting recording of events only upto a certain level. See this link for guidance https://msdn.microsoft.com/en-us/library/windows/desktop/aa363742(v=vs.85).aspx + // a) decide the level of logging. This will help us in limiting recording of events only up to a certain level. See this link for guidance https://msdn.microsoft.com/en-us/library/windows/desktop/aa363742(v=vs.85).aspx // We're using Verbose level for events that are called frequently and needed only for debugging or capturing perf for specific scenarios // b) should decide whether or not to log to telemetry and pass TraceLoggingKeyword(MICROSOFT_KEYWORD_TELEMETRY) accordingly // c) Should accept a variable number of additional data arguments if needed diff --git a/src/CalcViewModel/StandardCalculatorViewModel.cpp b/src/CalcViewModel/StandardCalculatorViewModel.cpp index 12d74eab..78ad7dd2 100644 --- a/src/CalcViewModel/StandardCalculatorViewModel.cpp +++ b/src/CalcViewModel/StandardCalculatorViewModel.cpp @@ -616,7 +616,7 @@ void StandardCalculatorViewModel::OnButtonPressed(Object^ parameter) // Also, the Primary Display Value should not show in exponential format. // Hence the check below to ensure parity with Desktop Calculator. // Clear the FE mode if the switching to StandardMode, since 'C'/'CE' in StandardMode - // doesn't honour the FE button. + // doesn't honor the FE button. if (IsFToEChecked) { IsFToEChecked = false; diff --git a/src/CalcViewModel/UnitConverterViewModel.h b/src/CalcViewModel/UnitConverterViewModel.h index 3b0987de..6aef9dc4 100644 --- a/src/CalcViewModel/UnitConverterViewModel.h +++ b/src/CalcViewModel/UnitConverterViewModel.h @@ -74,7 +74,7 @@ namespace CalculatorApp Platform::String^ get() { return ref new Platform::String(m_original.abbreviation.c_str()); } } - // This method is used to return the desired autonamtion name for default unit in UnitConveter combo box. + // This method is used to return the desired automation name for default unit in UnitConveter combo box. Platform::String^ ToString() override { return AccessibleName; diff --git a/src/Calculator/Common/AppLifecycleLogger.h b/src/Calculator/Common/AppLifecycleLogger.h index 8ed94a46..d1d88bad 100644 --- a/src/Calculator/Common/AppLifecycleLogger.h +++ b/src/Calculator/Common/AppLifecycleLogger.h @@ -1,4 +1,4 @@ -// Copyright (c) Microsoft Corporation. All rights reserved. +// Copyright (c) Microsoft Corporation. All rights reserved. // Licensed under the MIT License. #pragma once @@ -29,7 +29,7 @@ namespace CalculatorApp AppLifecycleLogger(); // Any new Log method should - // a) decide the level of logging. This will help us in limiting recording of events only upto a certain level. See this link for guidance https://msdn.microsoft.com/en-us/library/windows/desktop/aa363742(v=vs.85).aspx + // a) decide the level of logging. This will help us in limiting recording of events only up to a certain level. See this link for guidance https://msdn.microsoft.com/en-us/library/windows/desktop/aa363742(v=vs.85).aspx // We're using Verbose level for events that are called frequently and needed only for debugging or capturing perf for specific scenarios // b) should decide whether or not to log to telemetry and pass TraceLoggingKeyword(MICROSOFT_KEYWORD_TELEMETRY) accordingly // c) Should accept a variable number of additional data arguments if needed diff --git a/src/Calculator/Controls/CalculationResult.cpp b/src/Calculator/Controls/CalculationResult.cpp index 50e0d899..22f938af 100644 --- a/src/Calculator/Controls/CalculationResult.cpp +++ b/src/Calculator/Controls/CalculationResult.cpp @@ -1,4 +1,4 @@ -// Copyright (c) Microsoft Corporation. All rights reserved. +// Copyright (c) Microsoft Corporation. All rights reserved. // Licensed under the MIT License. #include "pch.h" @@ -154,7 +154,7 @@ void CalculationResult::OnIsInErrorPropertyChanged(bool /*oldValue*/, bool newVa if (newValue) { // If there's an error message we need to override the normal display font - // with the font appropiate for this language. This is because the error + // with the font appropriate for this language. This is because the error // message is localized and therefore can contain characters that are not // available in the normal font. // We use UIText as the font type because this is the most common font type to use diff --git a/src/Calculator/Controls/OverflowTextBlock.cpp b/src/Calculator/Controls/OverflowTextBlock.cpp index 30a714ae..b5633eaa 100644 --- a/src/Calculator/Controls/OverflowTextBlock.cpp +++ b/src/Calculator/Controls/OverflowTextBlock.cpp @@ -1,4 +1,4 @@ -// Copyright (c) Microsoft Corporation. All rights reserved. +// Copyright (c) Microsoft Corporation. All rights reserved. // Licensed under the MIT License. #include "pch.h" @@ -201,7 +201,7 @@ void OverflowTextBlock::UnregisterEventHandlers() auto borderContainer = safe_cast(GetTemplateChild("expressionborder")); - // Adding an extra check, incase the returned template is null + // Adding an extra check, in case the returned template is null if (borderContainer != nullptr) { borderContainer->PointerEntered -= m_pointerEnteredEventToken; diff --git a/src/Calculator/Views/CalculatorProgrammerBitFlipPanel.xaml.cpp b/src/Calculator/Views/CalculatorProgrammerBitFlipPanel.xaml.cpp index 4c83ba52..a6b8bfeb 100644 --- a/src/Calculator/Views/CalculatorProgrammerBitFlipPanel.xaml.cpp +++ b/src/Calculator/Views/CalculatorProgrammerBitFlipPanel.xaml.cpp @@ -166,7 +166,7 @@ void CalculatorProgrammerBitFlipPanel::OnBitToggled(_In_ Object^ sender, _In_ Ro // Any input from the Numpad may also result in toggling the bit as their state is bound to the BinaryDisplayValue. // Also, if the mode is switched to other Calculator modes when the BitFlip panel is open, // a race condition exists in which the IsProgrammerMode property is still true and the UpdatePrimaryResult() is called, - // which continously alters the Display Value and the state of the Bit Flip buttons. + // which continuously alters the Display Value and the state of the Bit Flip buttons. if ((Model->IsBitFlipChecked) && Model->IsProgrammer) { diff --git a/src/Calculator/Views/MainPage.xaml.cpp b/src/Calculator/Views/MainPage.xaml.cpp index a0079dc0..1b7541ce 100644 --- a/src/Calculator/Views/MainPage.xaml.cpp +++ b/src/Calculator/Views/MainPage.xaml.cpp @@ -116,7 +116,7 @@ void MainPage::OnNavigatedTo(NavigationEventArgs^ e) void MainPage::WindowSizeChanged(_In_ Platform::Object^ /*sender*/, _In_ Windows::UI::Core::WindowSizeChangedEventArgs^ e) { - // We dont use layout aware page's view states, we have our own + // We don't use layout aware page's view states, we have our own UpdateViewState(); } @@ -321,7 +321,7 @@ void MainPage::EnsureCalculator() CalcHolder->Child = m_calculator; - // Calculator's "default" state is visibile, but if we get delay loaded + // Calculator's "default" state is visible, but if we get delay loaded // when in converter, we should not be visible. This is not a problem for converter // since it's default state is hidden. ShowHideControls(this->Model->Mode); diff --git a/src/Calculator/Views/Memory.xaml.cpp b/src/Calculator/Views/Memory.xaml.cpp index a4797c13..ab69417b 100644 --- a/src/Calculator/Views/Memory.xaml.cpp +++ b/src/Calculator/Views/Memory.xaml.cpp @@ -48,7 +48,7 @@ void Memory::MemoryListItemClick(_In_ Object^ sender, _In_ ItemClickEventArgs^ e { MemoryItemViewModel^ memorySlot = safe_cast(e->ClickedItem); - // Incase the memory list is clicked and enter is pressed, + // In case the memory list is clicked and enter is pressed, // On Item clicked event gets fired and e->ClickedItem is Null. if (memorySlot != nullptr) { diff --git a/src/Calculator/Views/NumberPad.xaml b/src/Calculator/Views/NumberPad.xaml index 8792a6e8..d5673fd8 100644 --- a/src/Calculator/Views/NumberPad.xaml +++ b/src/Calculator/Views/NumberPad.xaml @@ -102,7 +102,7 @@