diff --git a/src/CalcManager/CEngine/calc.cpp b/src/CalcManager/CEngine/calc.cpp
index 561a0045..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();
@@ -118,7 +118,7 @@ void CCalcEngine::InitChopNumbers()
     for (size_t i = 0; i < m_chopNumbers.size(); i++)
     {
         auto maxVal = m_chopNumbers[i] / 2;
-        maxVal = RationalMath::Integer(maxVal, m_precision);
+        maxVal = RationalMath::Integer(maxVal);
 
         m_maxDecimalValueStrings[i] = maxVal.ToString(10, FMT_FLOAT, m_precision);
     }
diff --git a/src/CalcManager/CEngine/scidisp.cpp b/src/CalcManager/CEngine/scidisp.cpp
index 2784cfee..ebeb188f 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_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.
diff --git a/src/CalcManager/CEngine/scifunc.cpp b/src/CalcManager/CEngine/scifunc.cpp
index abfd3e1b..eb513ea8 100644
--- a/src/CalcManager/CEngine/scifunc.cpp
+++ b/src/CalcManager/CEngine/scifunc.cpp
@@ -32,14 +32,14 @@ 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) + 1);
+                result = -(RationalMath::Integer(rat) + 1);
             }
             else
             {
@@ -51,7 +51,7 @@ 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();
                 uint64_t msb = (w64Bits >> (m_dwWordBitWidth - 1)) & 1;
@@ -66,7 +66,7 @@ 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();
                 uint64_t lsb = ((w64Bits & 0x01) == 1) ? 1 : 0;
@@ -95,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:
@@ -179,13 +179,13 @@ CalcEngine::Rational CCalcEngine::SciCalcFunctions(CalcEngine::Rational const& r
             {
                 auto shftRat{ m_bInv ? 100 : 60 };
 
-                Rational degreeRat = Integer(rat, m_precision);
+                Rational degreeRat = Integer(rat);
 
                 Rational minuteRat = (rat - degreeRat) * shftRat;
 
                 Rational secondRat = minuteRat;
 
-                minuteRat = Integer(minuteRat, m_precision);
+                minuteRat = Integer(minuteRat);
 
                 secondRat = (secondRat - minuteRat) * shftRat;
 
diff --git a/src/CalcManager/CEngine/scimath.cpp b/src/CalcManager/CEngine/scimath.cpp
index d0afa000..fc25a8c5 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, 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 +27,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 +46,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 +69,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 +94,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 +114,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,12 +134,12 @@ 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) / Rational{ ln_ten };
+    return Log(rat) / Rational{ ln_ten };
 }
 
-Rational RationalMath::Invert(Rational const& rat, int32_t precision)
+Rational RationalMath::Invert(Rational const& rat)
 {
     return 1 / rat;
 }
@@ -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, 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 +169,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 +189,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 +209,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 +229,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 +249,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 +269,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 +289,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 +309,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 +329,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 +349,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 +369,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 3eac0d1d..8981c122 100644
--- a/src/CalcManager/CEngine/scioper.cpp
+++ b/src/CalcManager/CEngine/scioper.cpp
@@ -44,10 +44,10 @@ CalcEngine::Rational CCalcEngine::DoOperation(int operation, CalcEngine::Rationa
 
             if (fMsb)
             {
-                result = Integer(result, m_precision);
+                result = Integer(result);
 
                 auto tempRat = m_chopNumbers[m_numwidth] >> holdVal;
-                tempRat = Integer(tempRat, m_precision);
+                tempRat = Integer(tempRat);
 
                 result |= tempRat ^ m_chopNumbers[m_numwidth];
             }
@@ -118,18 +118,18 @@ CalcEngine::Rational CCalcEngine::DoOperation(int operation, CalcEngine::Rationa
 
             if (m_fIntegerMode && iFinalSign == -1)
             {
-                result = -(Integer(result, m_precision));
+                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 8a42ca57..52dc5c95 100644
--- a/src/CalcManager/CEngine/sciset.cpp
+++ b/src/CalcManager/CEngine/sciset.cpp
@@ -84,7 +84,7 @@ bool CCalcEngine::TryToggleBit(CalcEngine::Rational& rat, DWORD wbitno)
         return false; // ignore error cant happen
     }
 
-    Rational result = Integer(rat, m_precision);
+    Rational result = Integer(rat);
     if (result.IsZero())
     {
         // This is the same work around happenning in SciCalcFunctions. Ought to move to intrat function itself.
@@ -92,8 +92,8 @@ bool CCalcEngine::TryToggleBit(CalcEngine::Rational& rat, DWORD wbitno)
         result = 0;
     }
 
-    auto pow = Pow(2, static_cast<int32_t>(wbitno), m_precision);
-    rat = result ^ pow;
+    // XOR the result with 2^wbitno power
+    rat = result ^ Pow(2, static_cast<int32_t>(wbitno));
 
     return true;
 }
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);
 }