Arithmetic.hpp

Go to the documentation of this file.

//          Copyright Dominic Koepke 2019 - 2023.
// Distributed under the Boost Software License, Version 1.0.
//    (See accompanying file LICENSE_1_0.txt or copy at
//          https://www.boost.org/LICENSE_1_0.txt)
 
#ifndef SL_UTILITY_FUNCTIONAL_ARITHMETIC_HPP
#define SL_UTILITY_FUNCTIONAL_ARITHMETIC_HPP
 
#include "Simple-Utility/concepts/operators.hpp"
#include "Simple-Utility/functional/Transform.hpp"
 
namespace sl::functional::arithmetic
{
    inline constexpr auto plus = envelop<Transform>(
        []<class TLhs, class TRhs>(TLhs&& lhs, TRhs&& rhs) -> decltype(std::forward<TLhs>(lhs) + std::forward<TRhs>(rhs))
        {
            static_assert(concepts::plus_with<TLhs, TRhs>, "Arguments are not usable as operands of binary operator +.");
 
            return std::forward<TLhs>(lhs) + std::forward<TRhs>(rhs);
        });
 
    inline constexpr auto minus = envelop<Transform>(
        []<class TLhs, class TRhs>(TLhs&& lhs, TRhs&& rhs) -> decltype(std::forward<TLhs>(lhs) - std::forward<TRhs>(rhs))
        {
            static_assert(concepts::minus_with<TLhs, TRhs>, "Arguments are not usable as operands of binary operator -.");
 
            return std::forward<TLhs>(lhs) - std::forward<TRhs>(rhs);
        });
 
    inline constexpr auto multiplies = envelop<Transform>(
        []<class TLhs, class TRhs>(TLhs&& lhs, TRhs&& rhs) -> decltype(std::forward<TLhs>(lhs) * std::forward<TRhs>(rhs))
        {
            static_assert(concepts::multiplies_with<TLhs, TRhs>, "Arguments are not usable as operands of binary operator *.");
 
            return std::forward<TLhs>(lhs) * std::forward<TRhs>(rhs);
        });
 
    inline constexpr auto divides = envelop<Transform>(
        []<class TLhs, class TRhs>(TLhs&& lhs, TRhs&& rhs) -> decltype(std::forward<TLhs>(lhs) / std::forward<TRhs>(rhs))
        {
            static_assert(concepts::divides_with<TLhs, TRhs>, "Arguments are not usable as operands of binary operator /.");
 
            return std::forward<TLhs>(lhs) / std::forward<TRhs>(rhs);
        });
 
    inline constexpr auto modulus = envelop<Transform>(
        []<class TLhs, class TRhs>(TLhs&& lhs, TRhs&& rhs) -> decltype(std::forward<TLhs>(lhs) % std::forward<TRhs>(rhs))
        {
            static_assert(concepts::modulus_with<TLhs, TRhs>, "Arguments are not usable as operands of binary operator %.");
 
            return std::forward<TLhs>(lhs) % std::forward<TRhs>(rhs);
        });
 
    inline constexpr auto negate = envelop<Transform>(
        []<class T>(T&& value) -> decltype(-std::forward<T>(value))
        {
            static_assert(concepts::negate<T>, "Argument is not usable as operand of unary operator -.");
 
            return -std::forward<T>(value);
        });;
 
}
 
#endif