based

Opinionated utility library
git clone git://git.dimitrijedobrota.com/based.git
Log | Files | Refs | README | LICENSE | HACKING | CONTRIBUTING | CODE_OF_CONDUCT | BUILDING
commit e40197a1ba5b00fd5924606f51386efdad65fc6f
parent 927ba815575d69920bce3f172b922d917e95cc06
author Dimitrije Dobrota < mail@dimitrijedobrota.com >
date Thu, 27 Mar 2025 13:44:02 +0100

Redifine Integer in terms of operation it supports

Diffstat:
M include/based/functional.hpp | ++ --
A include/based/integer.hpp | ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
M include/based/type_traits.hpp | ++++++++++++++ -

3 files changed, 88 insertions(+), 3 deletions(-)

diff --git a/ include/based/functional.hpp b/ include/based/functional.hpp

@@ -134,8 +134,8 @@ orbit_structure_nonterminating_orbit(const domain_t<F>& x, F f)

template<Transformation F, Integer N>
codomain_t<F> power_unary(codomain_t<F> x, N n, F f)
{
while (n != N {0}) {
n = n - N {1};
while (!zero(n)) {
n = predecesor(n);
x = f(x);
}
return x;

diff --git a/ include/based/integer.hpp b/ include/based/integer.hpp

@@ -0,0 +1,72 @@

#pragma once

namespace based
{

template<typename T>
T successor(T n)
{
return n + T {1};
}

template<typename T>
T predecesor(T n)
{
return n - T {1};
}

template<typename T>
T twice(T n)
{
return n * T {2};
}

template<typename T>
T half(T n)
{
return n / T {2};
}

template<typename T>
bool positive(T n)
{
return n > T {0};
}

template<typename T>
bool negative(T n)
{
return n < T {0};
}

template<typename T>
bool zero(T n)
{
return n == T {0};
}

template<typename T>
bool one(T n)
{
return n == T {1};
}

template<typename T>
bool two(T n)
{
return n == T {2};
}

template<typename T>
bool even(T n)
{
return n % T{2} == T{0};
}

template<typename T>
bool odd(T n)
{
return n % T{2} != T{0};
}

} // namespace based

diff --git a/ include/based/type_traits.hpp b/ include/based/type_traits.hpp

@@ -4,11 +4,24 @@

#include <tuple>
#include <type_traits>

#include "based/integer.hpp"

namespace based
{

template<typename T>
concept Integer = std::integral<T>;
concept Integer = requires(T n) {
successor(n);
predecesor(n);
twice(n);
half(n);
positive(n);
negative(n);
zero(n);
one(n);
even(n);
odd(n);
};

template<typename T>
concept Regular = std::regular<T>;