dyn_index.hpp

Go to the documentation of this file.

#ifndef VEG_META_INT_DYN_HPP_GC385NKBS
#define VEG_META_INT_DYN_HPP_GC385NKBS

#include "proxsuite/linalg/veg/util/assert.hpp"
#include "proxsuite/linalg/veg/internal/fix_index.hpp"
#include "proxsuite/linalg/veg/internal/narrow.hpp"
#include "proxsuite/linalg/veg/util/compare.hpp"
#include "proxsuite/linalg/veg/internal/prologue.hpp"

namespace proxsuite {
namespace linalg {
namespace veg {

template<Ternary T>
struct Boolean;

template<>
struct Boolean<maybe>
{
 using type = maybe_c;

 constexpr Boolean() = default;
 constexpr Boolean /* NOLINT(hicpp-explicit-conversions) */ (bool _val)
 VEG_NOEXCEPT : val{ _val }
 {
 }
 template<Ternary T>
 VEG_INLINE constexpr Boolean /* NOLINT(hicpp-explicit-conversions)
 */
 (Boolean<T> /*arg*/) VEG_NOEXCEPT : val(T == yes)
 {
 }

 VEG_NODISCARD VEG_INLINE constexpr friend auto operator!(Boolean arg)
 VEG_NOEXCEPT->Boolean
 {
 return { !arg.val };
 }
 VEG_NODISCARD VEG_INLINE explicit constexpr operator bool() const VEG_NOEXCEPT
 {
 return val;
 }

private:
 bool val = false;
};

struct Dyn
{
 constexpr Dyn() = default;
 constexpr Dyn /* NOLINT(hicpp-explicit-conversions) */ (isize val)
 VEG_NOEXCEPT : m_val(val)
 {
 }
 template<isize N>
 constexpr Dyn /* NOLINT(hicpp-explicit-conversions) */ (Fix<N> /*arg*/)
 VEG_NOEXCEPT : m_val(N)
 {
 }

 VEG_NODISCARD VEG_INLINE explicit constexpr operator isize() const
 VEG_NOEXCEPT
 {
 return m_val;
 }
 VEG_NODISCARD VEG_INLINE constexpr auto operator+() const VEG_NOEXCEPT->Dyn
 {
 return *this;
 }
 VEG_NODISCARD VEG_INLINE constexpr auto operator-() const VEG_NOEXCEPT->Dyn
 {
 return Dyn{ -m_val };
 }

#define VEG_OP(Op, Name, TypeName) \
 VEG_TEMPLATE((typename R), \
 requires(VEG_CONCEPT(index<R>)), \
 VEG_NODISCARD VEG_INLINE constexpr auto \
 operator Op, \
 (b, R)) \
 const VEG_NOEXCEPT->typename _detail::binary_traits<Dyn, R>::TypeName \
 { \
 return _detail::binary_traits<Dyn, R>::Name##_fn(*this, b); \
 } \
 VEG_NOM_SEMICOLON

 VEG_OP(+, add, Add);
 VEG_OP(-, sub, Sub);
 VEG_OP(*, mul, Mul);

#undef VEG_OP

 VEG_TEMPLATE(
 (typename R),
 requires(VEG_CONCEPT(index<R>) &&
 VEG_CONCEPT(index<typename _detail::binary_traits<Dyn, R>::Div>)),
 VEG_NODISCARD VEG_INLINE constexpr auto
 operator/,
 (b, R))
 const VEG_NOEXCEPT->typename _detail::binary_traits<Dyn, R>::Div
 {
 return _detail::binary_traits<Dyn, R>::div_fn(*this, b);
 }

 VEG_TEMPLATE(
 (typename R),
 requires(VEG_CONCEPT(index<R>) &&
 VEG_CONCEPT(index<typename _detail::binary_traits<Dyn, R>::Mod>)),
 VEG_NODISCARD VEG_INLINE constexpr auto
 operator%,
 (b, R))
 const VEG_NOEXCEPT->typename _detail::binary_traits<Dyn, R>::Mod
 {
 return _detail::binary_traits<Dyn, R>::mod_fn(*this, b);
 }

#define VEG_CMP(Name, TypeName, Op) \
 VEG_TEMPLATE((typename R), \
 requires(VEG_CONCEPT(index<R>)), \
 VEG_NODISCARD VEG_INLINE constexpr auto \
 operator Op, /* NOLINT */ \
 (b, R)) \
 const VEG_NOEXCEPT->typename _detail::binary_traits<Dyn, R>::TypeName \
 { \
 return _detail::binary_traits<Dyn, R>::cmp_##Name##_fn(*this, b); \
 } \
 VEG_NOM_SEMICOLON

 VEG_CMP(eq, CmpEq, ==);
 VEG_CMP(neq, CmpNEq, !=);
 VEG_CMP(lt, CmpLT, <);
 VEG_CMP(le, CmpLE, <=);
 VEG_CMP(gt, CmpGT, >);
 VEG_CMP(ge, CmpGE, >=);

#undef VEG_CMP
private:
 isize m_val = 0;
};

template<Ternary T>
VEG_INLINE constexpr Boolean<T>::Boolean(Boolean<maybe> /*b*/,
 Unsafe /*tag*/) VEG_NOEXCEPT
{
}
template<Ternary T>
VEG_INLINE constexpr Boolean<T>::Boolean // NOLINT(hicpp-explicit-conversions)
 (Boolean<maybe> b) VEG_NOEXCEPT
 : Boolean(((void)VEG_INTERNAL_ASSERT_PRECONDITION(b.val == (T == yes)), b),
 unsafe)
{
}

template<isize N>
VEG_INLINE constexpr Fix<N>::Fix(Dyn /*arg*/, Unsafe /*tag*/) VEG_NOEXCEPT
{
}
template<isize N>
VEG_INLINE constexpr Fix<N>::Fix // NOLINT(hicpp-explicit-conversions)
 (Dyn arg) VEG_NOEXCEPT
 : Fix((VEG_INTERNAL_ASSERT_PRECONDITION(isize(arg) == N), arg), unsafe)
{
}

namespace _detail {

template<>
struct binary_traits<Dyn, Dyn>
{
#define VEG_OP(Name, TypeName, Op) \
 using TypeName /* NOLINT(bugprone-macro-parentheses) */ = Dyn; \
 VEG_NODISCARD VEG_INLINE static constexpr auto Name##_fn(Dyn a, Dyn b) \
 VEG_NOEXCEPT->TypeName \
 { \
 return { isize(usize(isize(a)) Op usize(isize(b))) }; \
 } \
 static_assert(true, "")

#define VEG_CMP(Name, TypeName, Op) \
 using TypeName /* NOLINT(bugprone-macro-parentheses) */ = Boolean<maybe>; \
 VEG_NODISCARD VEG_INLINE static constexpr auto Name##_fn(Dyn a, Dyn b) \
 VEG_NOEXCEPT->TypeName \
 { \
 return (isize(a) Op isize(b)); \
 } \
 static_assert(true, "")

 VEG_OP(add, Add, +);
 VEG_OP(sub, Sub, -);
 VEG_OP(mul, Mul, *);
 VEG_CMP(cmp_eq, CmpEq, ==);
 VEG_CMP(cmp_neq, CmpNEq, !=);
 VEG_CMP(cmp_lt, CmpLT, <);
 VEG_CMP(cmp_le, CmpLE, <=);
 VEG_CMP(cmp_gt, CmpGT, >);
 VEG_CMP(cmp_ge, CmpGE, >=);

 using Div = Dyn;
 using Mod = Dyn;

 VEG_NODISCARD static constexpr auto div_fn(Dyn a, Dyn b) VEG_NOEXCEPT -> Div
 {
 return VEG_INTERNAL_ASSERT_PRECONDITION(isize(b) != isize(0)),
 isize(a) / isize(b);
 }
 VEG_NODISCARD static constexpr auto mod_fn(Dyn a, Dyn b) VEG_NOEXCEPT -> Mod
 {

 return VEG_INTERNAL_ASSERT_PRECONDITION(isize(b) != isize(0)),
 isize(a) % isize(b);
 }

#undef VEG_OP
#undef VEG_CMP
};

template<isize N>
struct binary_traits<Fix<N>, Dyn> : binary_traits<Dyn, Dyn>
{};

template<>
struct binary_traits<Fix<0>, Dyn> : binary_traits<Dyn, Dyn>
{
 using Mul = Fix<0>;
 VEG_NODISCARD
 constexpr VEG_INLINE static auto mul_fn(Fix<0> /*a*/, Dyn /*b*/) VEG_NOEXCEPT
 -> Mul
 {
 return {};
 }
};

template<isize N>
struct binary_traits<Dyn, Fix<N>> : binary_traits<Dyn, Dyn>
{
 using Mul = typename binary_traits<Fix<N>, Dyn>::Mul;
 VEG_INLINE static constexpr auto mul_fn(Dyn a, Fix<N> /*b*/) VEG_NOEXCEPT
 -> Mul
 {
 return binary_traits<Fix<N>, Dyn>::mul_fn({}, a);
 }

 using Div = meta::if_t<N == 0, void, Dyn>;
 using Mod = meta::if_t<N == 0, void, Dyn>;

 VEG_NODISCARD VEG_INLINE static constexpr auto div_fn(Dyn a, Fix<N> /*b*/)
 VEG_NOEXCEPT -> Div
 {
 return Div(isize(a) / N);
 }
 VEG_NODISCARD VEG_INLINE static constexpr auto mod_fn(Dyn a, Fix<N> /*b*/)
 VEG_NOEXCEPT -> Mod
 {
 return Mod(isize(a) % N);
 }
};

} // namespace _detail

inline namespace literals {
VEG_INLINE constexpr auto
operator"" _v(unsigned long long n) VEG_NOEXCEPT->Dyn
{
 return isize(n);
}
} // namespace literals

template<>
struct fmt::Debug<Boolean<maybe>>
{
 static void to_string(fmt::Buffer& out, Ref<Boolean<maybe>> val)
 {
 out.insert(out.size(), "maybe[", 6);
 Debug<bool>::to_string(out, ref(bool(val.get())));
 out.insert(out.size(), "]", 1);
 }
};

template<>
struct fmt::Debug<Dyn>
{
 static void to_string(fmt::Buffer& out, Ref<Dyn> val)
 {
 out.insert(out.size(), "Dyn[", 4);
 Debug<isize>::to_string(out, ref(isize(val.get())));
 out.insert(out.size(), "]", 1);
 }
};
} // namespace veg
} // namespace linalg
} // namespace proxsuite

#include "proxsuite/linalg/veg/internal/epilogue.hpp"
#endif /* end of include guard VEG_META_INT_DYN_HPP_GC385NKBS */