Linalg

.pre-commit-config.yaml

@@ -31,6 +31,6 @@ repos:
         types_or: [c++, c]
 
   - repo: https://github.com/fsfe/reuse-tool
-    rev: v5.0.2
+    rev: v5.1.1
     hooks:
       - id: reuse

CMakePresets.json

@@ -21,7 +21,11 @@
     {
       "name": "desktop",
       "description": "Configure with hosted system toolchain",
-      "inherits": ["_root-config"]
+      "inherits": ["_root-config"],
+      "cacheVariables": {
+        "TETL_BUILD_CONTRACT_CHECKS": true,
+        "TETL_BUILD_CONTRACT_CHECKS_SAFE": true
+      }
     },
     {
       "name": "avr-gcc",

examples/all_headers.cpp

@@ -33,7 +33,6 @@ import etl;
     #include <etl/execution.hpp>
     #include <etl/expected.hpp>
     #include <etl/flat_set.hpp>
-    #include <etl/format.hpp>
     #include <etl/functional.hpp>
     #include <etl/inplace_vector.hpp>
     #include <etl/ios.hpp>

fuzzing/Makefile

@@ -12,20 +12,20 @@ bin:
 
 .PHONY: build
 build: bin
-	$(CXX) $(CXXFLAGS) -I ../include -o bin/fuzz_algorithm src/fuzz_algorithm.cpp
-	$(CXX) $(CXXFLAGS) -I ../include -o bin/fuzz_bitset src/fuzz_bitset.cpp
-	$(CXX) $(CXXFLAGS) -I ../include -o bin/fuzz_from_chars src/fuzz_from_chars.cpp
-	$(CXX) $(CXXFLAGS) -I ../include -o bin/fuzz_string_view src/fuzz_string_view.cpp
-	$(CXX) $(CXXFLAGS) -I ../include -o bin/fuzz_to_chars src/fuzz_to_chars.cpp
+	$(CXX) $(CXXFLAGS) -I ../include -o bin/algorithm.fuzz src/algorithm.fuzz.cpp
+	$(CXX) $(CXXFLAGS) -I ../include -o bin/bitset.fuzz src/bitset.fuzz.cpp
+	$(CXX) $(CXXFLAGS) -I ../include -o bin/from_chars.fuzz src/from_chars.fuzz.cpp
+	$(CXX) $(CXXFLAGS) -I ../include -o bin/string_view.fuzz src/string_view.fuzz.cpp
+	$(CXX) $(CXXFLAGS) -I ../include -o bin/to_chars.fuzz src/to_chars.fuzz.cpp
 
 .PHONY: fuzz
 fuzz: build
 	$(LCOV) -c -i -d . --base-directory . -o bin/base_cov.info --ignore-errors inconsistent
-	LLVM_PROFILE_FILE="bin/%p-%m.profraw" ./bin/fuzz_algorithm -max_total_time=$(MAXTIME)
-	LLVM_PROFILE_FILE="bin/%p-%m.profraw" ./bin/fuzz_bitset -max_total_time=$(MAXTIME)
-	LLVM_PROFILE_FILE="bin/%p-%m.profraw" ./bin/fuzz_from_chars -max_total_time=$(MAXTIME)
-	LLVM_PROFILE_FILE="bin/%p-%m.profraw" ./bin/fuzz_string_view -max_total_time=$(MAXTIME)
-	LLVM_PROFILE_FILE="bin/%p-%m.profraw" ./bin/fuzz_to_chars -max_total_time=$(MAXTIME)
+	LLVM_PROFILE_FILE="bin/%p-%m.profraw" ./bin/algorithm.fuzz -max_total_time=$(MAXTIME)
+	LLVM_PROFILE_FILE="bin/%p-%m.profraw" ./bin/bitset.fuzz -max_total_time=$(MAXTIME)
+	LLVM_PROFILE_FILE="bin/%p-%m.profraw" ./bin/from_chars.fuzz -max_total_time=$(MAXTIME)
+	LLVM_PROFILE_FILE="bin/%p-%m.profraw" ./bin/string_view.fuzz -max_total_time=$(MAXTIME)
+	LLVM_PROFILE_FILE="bin/%p-%m.profraw" ./bin/to_chars.fuzz -max_total_time=$(MAXTIME)
 	$(LCOV) -c -d . --base-directory . -o bin/fuzz_cov.info --ignore-errors inconsistent
 	$(LCOV) -a bin/base_cov.info -a bin/fuzz_cov.info -o bin/cov.info --ignore-errors inconsistent
 	$(LCOV) --remove bin/cov.info "*clang*" -o bin/cov.info --ignore-errors inconsistent

include/etl/_bitset/basic_bitset.hpp

@@ -87,22 +87,22 @@ struct basic_bitset {
     }
 
     /// Returns the number of bits that the bitset holds.
-    [[nodiscard]] constexpr auto size() const noexcept -> etl::size_t
+    [[nodiscard]] static constexpr auto size() noexcept -> etl::size_t
     {
         return Bits;
     }
 
     /// Returns true if the bit at position \p pos is set.
     /// \pre `pos < size()`
-    [[nodiscard]] constexpr auto operator[](etl::size_t pos) const -> bool
+    [[nodiscard]] constexpr auto unchecked_at(etl::size_t pos) const -> bool
     {
         TETL_PRECONDITION(pos < size());
         return unchecked_test(pos);
     }
 
     /// Returns a reference to the bit at position \p pos
     /// \pre `pos < size()`
-    [[nodiscard]] constexpr auto operator[](etl::size_t pos) -> reference
+    [[nodiscard]] constexpr auto unchecked_at(etl::size_t pos) -> reference
     {
         TETL_PRECONDITION(pos < size());
         return reference{_words[word_index(pos)], offset_in_word(pos)};

include/etl/_bitset/bitset.hpp

@@ -160,7 +160,7 @@ struct bitset {
     [[nodiscard]] constexpr auto operator[](size_t const pos) -> reference
     {
         TETL_PRECONDITION(pos < size());
-        return _bits[pos];
+        return _bits.unchecked_at(pos);
     }
 
     /// Returns the value of the bit at the position pos. Perfoms no
@@ -170,7 +170,7 @@ struct bitset {
     [[nodiscard]] constexpr auto operator[](size_t const pos) const -> bool
     {
         TETL_PRECONDITION(pos < size());
-        return _bits[pos];
+        return _bits.unchecked_at(pos);
     }
 
     /// Returns the value of the bit at the position pos. Perfoms no

include/etl/_cmath/acos.hpp

@@ -64,7 +64,7 @@ inline constexpr struct acos {
 }
 [[nodiscard]] constexpr auto acos(integral auto arg) noexcept -> double
 {
-    return etl::detail::acos(double(arg));
+    return etl::detail::acos(static_cast<double>(arg));
 }
 
 /// @}

include/etl/_cmath/acosh.hpp

@@ -66,7 +66,7 @@ inline constexpr struct acosh {
 }
 [[nodiscard]] constexpr auto acosh(integral auto arg) noexcept -> double
 {
-    return etl::detail::acosh(double(arg));
+    return etl::detail::acosh(static_cast<double>(arg));
 }
 
 /// @}

include/etl/_cmath/asin.hpp

@@ -64,7 +64,7 @@ inline constexpr struct asin {
 }
 [[nodiscard]] constexpr auto asin(integral auto arg) noexcept -> double
 {
-    return etl::detail::asin(double(arg));
+    return etl::detail::asin(static_cast<double>(arg));
 }
 
 /// @}

include/etl/_cmath/asinh.hpp

@@ -66,7 +66,7 @@ inline constexpr struct asinh {
 }
 [[nodiscard]] constexpr auto asinh(integral auto arg) noexcept -> double
 {
-    return etl::detail::asinh(double(arg));
+    return etl::detail::asinh(static_cast<double>(arg));
 }
 
 /// @}

include/etl/_cmath/atan.hpp

@@ -64,7 +64,7 @@ inline constexpr struct atan {
 }
 [[nodiscard]] constexpr auto atan(integral auto arg) noexcept -> double
 {
-    return etl::detail::atan(double(arg));
+    return etl::detail::atan(static_cast<double>(arg));
 }
 
 /// @}

include/etl/_cmath/atan2.hpp

@@ -8,34 +8,58 @@
 
 namespace etl {
 
+namespace detail {
+
+inline constexpr struct atan2 {
+    template <typename Float>
+    [[nodiscard]] constexpr auto operator()(Float x, Float y) const noexcept -> Float
+    {
+        if (not is_constant_evaluated()) {
+#if __has_builtin(__builtin_atan2f)
+            if constexpr (etl::same_as<Float, float>) {
+                return __builtin_atan2f(x, y);
+            }
+#endif
+#if __has_builtin(__builtin_atan2)
+            if constexpr (etl::same_as<Float, double>) {
+                return __builtin_atan2(x, y);
+            }
+#endif
+        }
+        return etl::detail::gcem::atan2(x, y);
+    }
+} atan2;
+
+} // namespace detail
+
 /// \ingroup cmath
 /// @{
 
 /// Computes the arc tangent of y/x using the signs of arguments to determine the correct quadrant.
 /// \details https://en.cppreference.com/w/cpp/numeric/math/atan2
 [[nodiscard]] constexpr auto atan2(float x, float y) noexcept -> float
 {
-    return etl::detail::gcem::atan2(x, y);
+    return etl::detail::atan2(x, y);
 }
 
 [[nodiscard]] constexpr auto atan2f(float x, float y) noexcept -> float
 {
-    return etl::detail::gcem::atan2(x, y);
+    return etl::detail::atan2(x, y);
 }
 
 [[nodiscard]] constexpr auto atan2(double x, double y) noexcept -> double
 {
-    return etl::detail::gcem::atan2(x, y);
+    return etl::detail::atan2(x, y);
 }
 
 [[nodiscard]] constexpr auto atan2(long double x, long double y) noexcept -> long double
 {
-    return etl::detail::gcem::atan2(x, y);
+    return etl::detail::atan2(x, y);
 }
 
 [[nodiscard]] constexpr auto atan2l(long double x, long double y) noexcept -> long double
 {
-    return etl::detail::gcem::atan2(x, y);
+    return etl::detail::atan2(x, y);
 }
 
 /// @}

include/etl/_cmath/atanh.hpp

@@ -9,34 +9,60 @@
 
 namespace etl {
 
+namespace detail {
+
+inline constexpr struct atanh {
+    template <typename Float>
+    [[nodiscard]] constexpr auto operator()(Float arg) const noexcept -> Float
+    {
+#if not defined(__AVR__)
+        if (not is_constant_evaluated()) {
+    #if __has_builtin(__builtin_atanhf)
+            if constexpr (etl::same_as<Float, float>) {
+                return __builtin_atanhf(arg);
+            }
+    #endif
+    #if __has_builtin(__builtin_atanh)
+            if constexpr (etl::same_as<Float, double>) {
+                return __builtin_atanh(arg);
+            }
+    #endif
+        }
+#endif
+        return etl::detail::gcem::atanh(arg);
+    }
+} atanh;
+
+} // namespace detail
+
 /// \ingroup cmath
 /// @{
 
 /// Computes the inverse hyperbolic tangent of arg.
 /// \details https://en.cppreference.com/w/cpp/numeric/math/atanh
 [[nodiscard]] constexpr auto atanh(float arg) noexcept -> float
 {
-    return etl::detail::gcem::atanh(arg);
+    return etl::detail::atanh(arg);
 }
 [[nodiscard]] constexpr auto atanhf(float arg) noexcept -> float
 {
-    return etl::detail::gcem::atanh(arg);
+    return etl::detail::atanh(arg);
 }
 [[nodiscard]] constexpr auto atanh(double arg) noexcept -> double
 {
-    return etl::detail::gcem::atanh(arg);
+    return etl::detail::atanh(arg);
 }
 [[nodiscard]] constexpr auto atanh(long double arg) noexcept -> long double
 {
-    return etl::detail::gcem::atanh(arg);
+    return etl::detail::atanh(arg);
 }
 [[nodiscard]] constexpr auto atanhl(long double arg) noexcept -> long double
 {
-    return etl::detail::gcem::atanh(arg);
+    return etl::detail::atanh(arg);
 }
 [[nodiscard]] constexpr auto atanh(integral auto arg) noexcept -> double
 {
-    return etl::detail::gcem::atanh(double(arg));
+    return etl::detail::atanh(static_cast<double>(arg));
 }
 
 /// @}

include/etl/_cmath/ceil.hpp

@@ -9,34 +9,58 @@
 
 namespace etl {
 
+namespace detail {
+
+inline constexpr struct ceil {
+    template <typename Float>
+    [[nodiscard]] constexpr auto operator()(Float arg) const noexcept -> Float
+    {
+        if (not is_constant_evaluated()) {
+#if __has_builtin(__builtin_ceilf)
+            if constexpr (etl::same_as<Float, float>) {
+                return __builtin_ceilf(arg);
+            }
+#endif
+#if __has_builtin(__builtin_ceil)
+            if constexpr (etl::same_as<Float, double>) {
+                return __builtin_ceil(arg);
+            }
+#endif
+        }
+        return etl::detail::gcem::ceil(arg);
+    }
+} ceil;
+
+} // namespace detail
+
 /// \ingroup cmath
 /// @{
 
 /// Computes the smallest integer value not less than arg.
 /// \details https://en.cppreference.com/w/cpp/numeric/math/ceil
 [[nodiscard]] constexpr auto ceil(float arg) noexcept -> float
 {
-    return etl::detail::gcem::ceil(arg);
+    return etl::detail::ceil(arg);
 }
 [[nodiscard]] constexpr auto ceilf(float arg) noexcept -> float
 {
-    return etl::detail::gcem::ceil(arg);
+    return etl::detail::ceil(arg);
 }
 [[nodiscard]] constexpr auto ceil(double arg) noexcept -> double
 {
-    return etl::detail::gcem::ceil(arg);
+    return etl::detail::ceil(arg);
 }
 [[nodiscard]] constexpr auto ceil(long double arg) noexcept -> long double
 {
-    return etl::detail::gcem::ceil(arg);
+    return etl::detail::ceil(arg);
 }
 [[nodiscard]] constexpr auto ceill(long double arg) noexcept -> long double
 {
-    return etl::detail::gcem::ceil(arg);
+    return etl::detail::ceil(arg);
 }
 [[nodiscard]] constexpr auto ceil(integral auto arg) noexcept -> double
 {
-    return etl::detail::gcem::ceil(double(arg));
+    return etl::detail::ceil(static_cast<double>(arg));
 }
 
 /// @}

include/etl/_cmath/cos.hpp

@@ -64,7 +64,7 @@ inline constexpr struct cos {
 }
 [[nodiscard]] constexpr auto cos(integral auto arg) noexcept -> double
 {
-    return etl::detail::cos(double(arg));
+    return etl::detail::cos(static_cast<double>(arg));
 }
 
 /// @}