Refactor numbers

include/fintamath/numbers/Complex.hpp

@@ -28,19 +28,21 @@ class Complex : public INumberCRTP<Complex> {
 
   Complex &operator=(Complex &&rhs) noexcept = default;
 
-  explicit Complex(const std::string &str);
-
-  explicit Complex(const INumber &inReal, const INumber &inImag);
-
-  explicit Complex(int64_t inReal, int64_t inImag);
-
   Complex(const Integer &rhs);
 
   Complex(const Rational &rhs);
 
   Complex(const Real &rhs);
 
-  Complex(int64_t rhs);
+  Complex(std::integral auto rhs) : re(std::make_unique<Integer>(rhs)) {}
+
+  explicit Complex(std::integral auto inReal, std::integral auto inImag)
+      : re(std::make_unique<Integer>(inReal)),
+        im(std::make_unique<Integer>(inImag)) {}
+
+  explicit Complex(const INumber &inReal, const INumber &inImag);
+
+  explicit Complex(const std::string &str);
 
   std::string toString() const override;
 

include/fintamath/numbers/Integer.hpp

@@ -25,15 +25,12 @@ class Integer : public INumberCRTP<Integer> {
 public:
   Integer() = default;
 
+  Integer(std::integral auto rhs) : backend(rhs) {}
+
   Integer(Backend inBackend);
 
   explicit Integer(std::string str);
 
-  explicit Integer(std::integral auto val) : backend(val) {
-  }
-
-  Integer(int64_t val);
-
   std::string toString() const override;
 
   int sign() const;

include/fintamath/numbers/Rational.hpp

@@ -20,13 +20,13 @@ class Rational : public INumberCRTP<Rational> {
 public:
   Rational() = default;
 
-  explicit Rational(const std::string &str);
-
-  explicit Rational(Integer inNumer, Integer inDenom);
+  Rational(std::integral auto rhs) : numer(rhs) {}
 
   Rational(Integer rhs);
 
-  Rational(int64_t rhs);
+  explicit Rational(Integer inNumer, Integer inDenom);
+
+  explicit Rational(const std::string &str);
 
   std::string toString() const override;
 
@@ -62,7 +62,9 @@ class Rational : public INumberCRTP<Rational> {
 
   static void toCommonDenominators(Rational &lhs, Rational &rhs);
 
+private:
   Integer numer = 0;
+
   Integer denom = 1;
 };
 

include/fintamath/numbers/Real.hpp

@@ -43,13 +43,15 @@ class Real : public INumberCRTP<Real> {
 
   Real(Backend inBackend);
 
-  explicit Real(std::string str);
+  Real(std::integral auto rhs)
+      : backend(rhs),
+        isNegative(rhs < 0) {}
 
-  Real(const Rational &val);
+  Real(const Rational &rhs);
 
-  Real(const Integer &val);
+  Real(const Integer &rhs);
 
-  Real(int64_t val);
+  explicit Real(std::string str);
 
   std::string toString() const override;
 
@@ -99,8 +101,6 @@ class Real : public INumberCRTP<Real> {
 
   void updatePrecision(const Real &rhs);
 
-  void validateNewPrecision(unsigned precision) const;
-
 private:
   Backend backend;
 

src/fintamath/numbers/Complex.cpp

@@ -44,19 +44,6 @@ Complex::Complex(const std::string &str) {
   }
 }
 
-Complex::Complex(const INumber &inReal, const INumber &inImag) {
-  if (is<Complex>(inReal) || is<Complex>(inImag)) {
-    throw InvalidInputException("Nested complex numbers are not allowed");
-  }
-
-  re = cast<INumber>(inReal.toMinimalObject());
-  im = cast<INumber>(inImag.toMinimalObject());
-}
-
-Complex::Complex(int64_t inReal, int64_t inImag) : re(std::make_unique<Integer>(inReal)),
-                                                   im(std::make_unique<Integer>(inImag)) {
-}
-
 Complex::Complex(const Integer &rhs) : re(cast<INumber>(rhs.toMinimalObject())) {
 }
 
@@ -66,7 +53,13 @@ Complex::Complex(const Rational &rhs) : re(cast<INumber>(rhs.toMinimalObject()))
 Complex::Complex(const Real &rhs) : re(cast<INumber>(rhs.toMinimalObject())) {
 }
 
-Complex::Complex(int64_t rhs) : re(std::make_unique<Integer>(rhs)) {
+Complex::Complex(const INumber &inReal, const INumber &inImag) {
+  if (is<Complex>(inReal) || is<Complex>(inImag)) {
+    throw InvalidInputException("Nested complex numbers are not allowed");
+  }
+
+  re = cast<INumber>(inReal.toMinimalObject());
+  im = cast<INumber>(inImag.toMinimalObject());
 }
 
 std::string Complex::toString() const {

src/fintamath/numbers/Integer.cpp

@@ -34,9 +34,6 @@ Integer::Integer(std::string str) {
   }
 }
 
-Integer::Integer(const int64_t val) : backend(val) {
-}
-
 std::string Integer::toString() const {
   return backend.str();
 }

src/fintamath/numbers/Rational.cpp

@@ -19,6 +19,16 @@ namespace fintamath {
 
 FINTAMATH_CLASS_IMPLEMENTATION(Rational)
 
+Rational::Rational(Integer rhs) : numer(std::move(rhs)) {
+}
+
+Rational::Rational(Integer inNumer, Integer inDenom)
+    : numer(std::move(inNumer)),
+      denom(std::move(inDenom)) {
+
+  toIrreducibleRational();
+}
+
 Rational::Rational(const std::string &str) {
   if (str.empty()) {
     throw InvalidInputException(str);
@@ -66,19 +76,6 @@ Rational::Rational(const std::string &str) {
   }
 }
 
-Rational::Rational(Integer inNumer, Integer inDenom)
-    : numer(std::move(inNumer)),
-      denom(std::move(inDenom)) {
-
-  toIrreducibleRational();
-}
-
-Rational::Rational(Integer rhs) : numer(std::move(rhs)) {
-}
-
-Rational::Rational(const int64_t rhs) : numer(rhs) {
-}
-
 const Integer &Rational::numerator() const {
   return numer;
 }

src/fintamath/numbers/Real.cpp

@@ -1,6 +1,7 @@
 #include "fintamath/numbers/Real.hpp"
 
 #include <algorithm>
+#include <cassert>
 #include <compare>
 #include <cstddef>
 #include <cstdint>
@@ -66,17 +67,12 @@ Real::Real(std::string str) : Real() {
   }
 }
 
-Real::Real(const Rational &val) {
-  *this = Real(val.numerator()) / Real(val.denominator());
-}
-
-Real::Real(const Integer &val) : backend(val.getBackend()),
-                                 isNegative(val < 0) {
-}
+Real::Real(const Rational &rhs)
+    : Real(Real(rhs.numerator()) / Real(rhs.denominator())) {}
 
-Real::Real(const int64_t val) : backend(val),
-                                isNegative(val < 0) {
-}
+Real::Real(const Integer &rhs)
+    : backend(rhs.getBackend()),
+      isNegative(rhs < 0) {}
 
 std::string Real::toString() const {
   std::string res = toString(outputPrecision);
@@ -89,7 +85,7 @@ std::string Real::toString() const {
 }
 
 std::string Real::toString(unsigned precision) const {
-  validateNewPrecision(precision);
+  assert(precision <= outputPrecision);
 
   if (precision == 0) {
     precision++;
@@ -154,7 +150,7 @@ unsigned Real::getOutputPrecision() const {
 }
 
 void Real::setOutputPrecision(const unsigned precision) {
-  validateNewPrecision(precision);
+  assert(precision <= outputPrecision);
   outputPrecision = precision;
 }
 
@@ -250,14 +246,6 @@ void Real::updatePrecision(const Real &rhs) {
   outputPrecision = std::min(outputPrecision, rhs.outputPrecision);
 }
 
-void Real::validateNewPrecision(const unsigned precision) const {
-  if (precision > outputPrecision) {
-    // TODO: use std::format
-    throw InvalidInputException("Precision must be less than or equal to " +
-                                std::to_string(outputPrecision));
-  }
-}
-
 Real::ScopedSetPrecision::ScopedSetPrecision(const unsigned precision) {
   setPrecision(precision);
 }

tests/src/numbers/RealTests.cpp

@@ -866,7 +866,7 @@ TEST(RealTests, toStringPrecisionPrecisionTest) {
 
   Real::ScopedSetPrecision setPrecision(10);
   val = Real("1.3");
-  EXPECT_THROW(val.toString(20), InvalidInputException);
+  EXPECT_DEBUG_DEATH(val.toString(20), "");
 }
 
 TEST(RealTests, getOutputPrecisionTest) {
@@ -886,8 +886,8 @@ TEST(RealTests, setOutputPrecisionTest) {
   a.setOutputPrecision(5);
   EXPECT_EQ(a.getOutputPrecision(), 5);
 
-  EXPECT_THROW(a.setOutputPrecision(6), InvalidInputException);
-  EXPECT_THROW(a.setOutputPrecision(10), InvalidInputException);
+  EXPECT_DEBUG_DEATH(a.setOutputPrecision(6), "");
+  EXPECT_DEBUG_DEATH(a.setOutputPrecision(10), "");
 }
 
 TEST(RealTests, updatePrecisionTest) {