chore: moved concept Number to the general 'math' partition

Author: TheRustifyer

zero/ifc/math/general.cppm

@@ -5,12 +5,32 @@
 
 export module math:general;
 
-/// Forward declarations of the 'Numbers types'
+import std;
+import math.symbols;
+
+/// Forward declarations of the 'Numbers types', so they can be shared across different
+/// module partitions of 'math'
 export namespace zero::math {
     class Natural;
     class Integer;
     class Rational;
     class Irrational;
     class Real;
     class Complex;
+
+    /// Concept to act as an interface for the abstract concept of 'number' in mathematics.
+    /// In particular, this interface represents a kind of number that belongs to a concrete set of numbers,
+    /// for example, the naturals, the integers, the reals, the complex numbers...
+    template <typename T>
+    concept Number = (
+        std::is_same_v<T, Natural> ||
+        std::is_same_v<T, Integer> ||
+        std::is_same_v<T, Rational> ||
+        std::is_same_v<T, Irrational> ||
+        std::is_same_v<T, Real> ||
+        std::is_same_v<T, Complex>
+    ) && requires {
+        T::symbol;  /* Check if 'T' has a static member named 'symbol' */
+        { T::symbol } -> std::same_as<const MathSymbol&>;  // Check if 'T::symbol' has the type MathSymbol
+    };
 }

zero/ifc/math/numbers/detail.cpp

@@ -12,34 +12,6 @@ import :numbers.rationals;
 using namespace zero::math;
 
             /*++++++++ Operator overloads implementations ++++++++++*/
-
-/*+++++++++++++++++ Naturals +++++++++++++++++*/
-// Arithmetic
-/* [[nodiscard]] Natural Natural::operator+(const Natural rhs) const noexcept {
-    return Natural(_number + rhs.number());
-}
-/// TODO: should we do something about the values < 1?
-/// Definetly yes, and now that we have a common base via CRTP,
-/// we can override the impl on naturals to provide custom behaviour
-///
-[[nodiscard]] Natural Natural::operator-(const Natural rhs) const noexcept  {
-    return Natural(_number - rhs.number());
-}
-
-[[nodiscard]] Natural Natural::operator*(const Natural rhs) const noexcept {
-    return Natural(_number * rhs.number());
-}
-[[nodiscard]] Rational Natural::operator/(const Natural rhs) const noexcept {
-    return {static_cast<signed int>(_number), static_cast<signed int>(rhs.number())};
-} */
-// Equality
-/* [[nodiscard]] bool Natural::operator==(const Natural rhs) const noexcept {
-    return _number == rhs.number();
-}
-[[nodiscard]] bool Natural::operator==(const unsigned int rhs) const noexcept {
-    return _number == rhs;
-} */
-
 /*+++++++++++++++++ Integers +++++++++++++++++*/
 
 // Arithmetic

zero/ifc/math/numbers/general.cppm

@@ -2,48 +2,51 @@
 export module math:numbers.general;
 
 import std;
+
 import :general;
+
 import math.ops;
 import math.symbols;
 
 export namespace zero::math {
-    template<typename Derived>
+    template<typename Derived> // can't constraint it with Number since ATM only fwd decls
     class NumberBase {
         // TODO: ensure in our concept (or create another) that all the Number(s) contains
         // a fixed name member (like _value or _number), normalized, so we can access it
     private:
         friend Derived;
         NumberBase() = default;
 
-        auto _self() -> Derived& {
+        inline constexpr auto _self() -> Derived& {
             return static_cast<Derived&>(*this);
         }
 
-        auto _self() const -> const Derived& {
+        inline constexpr auto _self() const -> const Derived& {
             return static_cast<const Derived&>(*this);
         }
     public:
         // Addition
-        [[nodiscard]] Derived operator+(const Derived& rhs) const noexcept {
+        [[nodiscard]] constexpr auto operator+(const Derived& rhs) const noexcept -> Derived {
             return Derived(_self().number() + rhs.number());
         }
 
         // Subtraction
-        [[nodiscard]] Derived operator-(const Derived& rhs) const noexcept {
+        [[nodiscard]] constexpr auto operator-(const Derived& rhs) const noexcept -> Derived {
             return Derived(_self().number() - rhs.number());
         }
 
         // Multiplication
-        [[nodiscard]] Derived operator*(const Derived& rhs) const noexcept {
+        [[nodiscard]] constexpr auto operator*(const Derived& rhs) const noexcept -> Derived {
             return Derived(_self().number() * rhs.number());
         }
 
         // Division
-        [[nodiscard]] Derived operator/(const Derived& rhs) const noexcept {
+        // TODO: removed the noexcept, since division by Zero must return std::expect or just throw
+        [[nodiscard]] constexpr auto operator/(const Derived& rhs) const -> Derived {
             return Derived(_self().number() / rhs.number());
         }
 
-        [[nodiscard]] constexpr bool operator==(const Derived& rhs) const noexcept {
+        [[nodiscard]] constexpr auto operator==(const Derived& rhs) const noexcept -> Derived {
             return _self().number() == rhs.number();
         }
     };

zero/ifc/math/numbers/integers.cppm

@@ -5,7 +5,7 @@ import math.ops;
 import math.symbols;
 
 import :general;
-import :numbers.concepts;
+import :numbers.general;
 import :numbers.naturals;
 
 export namespace zero::math {
@@ -16,7 +16,9 @@ export namespace zero::math {
     public:
         constexpr static MathSymbol symbol { MathSymbol::Integers };
 
-        [[nodiscard]] constexpr explicit Integer(signed int value) noexcept : _number(value) {}
+        // TODO: explicit templated constructor constrained by Numerical?
+        // TODO: document in the public API that any decimal number will be truncated
+        [[nodiscard]] constexpr explicit Integer(const signed int value) noexcept : _number(value) {}
         [[nodiscard]] explicit Integer(const Natural value) noexcept
             : _number(static_cast<signed int>(value.number())) {}
 

zero/ifc/math/numbers/naturals.cppm

@@ -3,14 +3,14 @@ export module math:numbers.naturals;
 import std;
 import math.symbols;
 
+import :general;
 import :numbers.general;
-import :numbers.concepts;
 
 export namespace zero::math {
     /// A positive integer number
     class Natural: public NumberBase<Natural> {
     private:
-        // TODO. shouldn't be unsigned. we may decide what kind of thing we do
+        // TODO: shouldn't be unsigned. we may decide what kind of thing we do
         // with signedness
         unsigned int _number;
     public:
@@ -21,6 +21,13 @@ export namespace zero::math {
         /// @returns an {@link unsigned int}, which is the value stored in the type, being only a positive integer number
         [[nodiscard]] constexpr unsigned int number() const noexcept { return _number; }
 
+        /// TODO: should we do something about the values < 1?
+        /// Definetly yes, and now that we have a common base via CRTP,
+        /// we can override the impl on naturals to provide custom behaviour
+        ///
+        /* [[nodiscard]] Natural Natural::operator-(const Natural rhs) const noexcept  {
+            return Natural(_number - rhs.number());
+        } */
         /// @overload
         [[nodiscard]] bool operator==(unsigned int rhs) const noexcept {
             return _number == rhs;

zero/ifc/math/numbers/numbers.cppm

@@ -5,10 +5,6 @@ export module math:numbers;
 import std;
 import math.symbols;
 
-export import :numbers.concepts;
-import :numbers.general;
-import :numbers.detail;
-
 export import :numbers.naturals;
 export import :numbers.integers;
 export import :numbers.rationals;

zero/ifc/math/numbers/numbers_concepts.cppm

@@ -5,8 +5,7 @@ import math.ops;
 import math.symbols;
 
 import :general;
-import :numbers.concepts;
-
+import :numbers.general;
 import :numbers.naturals;
 import :numbers.integers;
 

zero/ifc/math/numbers/rationals.cppm

@@ -19,7 +19,7 @@ using namespace zero::math;
 
 export namespace zero::physics {
     /* Base units */
-    template<Ratio r, Symbol s>
+template<Ratio r, Symbol s>
     struct base_unit {
         using ratio = r;
         using symbol = s;

zero/ifc/physics/quantities/units.cppm

@@ -79,7 +79,6 @@ interfaces = [
         { file = 'math/linear_algebra/root.cppm', module_name = 'math.linear_algebra' },
         # Numbers - Core
         { file = 'math/numbers/general.cppm', partition = { module = 'math', partition_name = 'numbers.general' } },
-        { file = 'math/numbers/numbers_concepts.cppm', partition = { module = 'math', partition_name = 'numbers.concepts' } },
         { file = 'math/numbers/naturals.cppm', partition = { module = 'math', partition_name = 'numbers.naturals' } },
         { file = 'math/numbers/integers.cppm', partition = { module = 'math', partition_name = 'numbers.integers' } },
         { file = 'math/numbers/rationals.cppm', partition = { module = 'math', partition_name = 'numbers.rationals' } },