sequence.hpp File Reference

#include <prc/core/basic/concepts.hpp>
#include <prc/core/basic/direction.hpp>
#include <prc/core/basic/functions/isqrt.hpp>
#include <prc/core/basic/functions/max.hpp>
#include <prc/core/basic/limits.hpp>
#include <prc/core/functors/add.hpp>
#include <prc/core/functors/div.hpp>
#include <prc/core/functors/equal.hpp>
#include <prc/core/functors/greater.hpp>
#include <prc/core/functors/greater_equal.hpp>
#include <prc/core/functors/less.hpp>
#include <prc/core/functors/less_equal.hpp>
#include <prc/core/functors/minus.hpp>
#include <prc/core/functors/mod.hpp>
#include <prc/core/functors/mul.hpp>
#include <prc/core/functors/not_equal.hpp>
#include <prc/core/functors/sub.hpp>
#include <prc/core/log/log.hpp>

Go to the source code of this file.

Classes
class	pRC::Sequence< T, Seq >

Namespaces
namespace	pRC

Concepts
concept	pRC::IsSequence
concept	pRC::IsSizes

Typedefs
template<Size... Ns>
using	pRC::Sizes = Sequence<Size, Ns...>

Functions
template<class T , T... As, T... Bs> requires IsInvocable<Add, T, T> && (sizeof...(As) == sizeof...(Bs))
static constexpr auto	pRC::operator+ (Sequence< T, As... > const, Sequence< T, Bs... > const)
template<class T , T... As, T B> requires IsInvocable<Add, T, T>
static constexpr auto	pRC::operator+ (Sequence< T, As... > const, Constant< T, B > const)
template<class T , T A, T... Bs> requires IsInvocable<Add, T, T>
static constexpr auto	pRC::operator+ (Constant< T, A > const, Sequence< T, Bs... > const)
template<class T , T... As, T... Bs> requires IsInvocable<Sub, T, T> && (sizeof...(As) == sizeof...(Bs))
static constexpr auto	pRC::operator- (Sequence< T, As... > const, Sequence< T, Bs... > const)
template<class T , T... As, T B> requires IsInvocable<Sub, T, T>
static constexpr auto	pRC::operator- (Sequence< T, As... > const, Constant< T, B > const)
template<class T , T A, T... Bs> requires IsInvocable<Sub, T, T>
static constexpr auto	pRC::operator- (Constant< T, A > const, Sequence< T, Bs... > const)
template<class T , T... As, T... Bs> requires IsInvocable<Mul, T, T> && (sizeof...(As) == sizeof...(Bs))
static constexpr auto	pRC::operator* (Sequence< T, As... > const, Sequence< T, Bs... > const)
template<class T , T... As, T B> requires IsInvocable<Mul, T, T>
static constexpr auto	pRC::operator* (Sequence< T, As... > const, Constant< T, B > const)
template<class T , T A, T... Bs> requires IsInvocable<Mul, T, T>
static constexpr auto	pRC::operator* (Constant< T, A > const, Sequence< T, Bs... > const)
template<class T , T... As, T... Bs> requires IsInvocable<Div, T, T> && (sizeof...(As) == sizeof...(Bs))
static constexpr auto	pRC::operator/ (Sequence< T, As... > const, Sequence< T, Bs... > const)
template<class T , T... As, T B> requires IsInvocable<Div, T, T>
static constexpr auto	pRC::operator/ (Sequence< T, As... > const, Constant< T, B > const)
template<class T , T A, T... Bs> requires IsInvocable<Div, T, T>
static constexpr auto	pRC::operator/ (Constant< T, A > const, Sequence< T, Bs... > const)
template<class T , T... As, T... Bs> requires IsInvocable<Mod, T, T> && (sizeof...(As) == sizeof...(Bs))
static constexpr auto	pRC::operator% (Sequence< T, As... > const, Sequence< T, Bs... > const)
template<class T , T... As, T B> requires IsInvocable<Mod, T, T>
static constexpr auto	pRC::operator% (Sequence< T, As... > const, Constant< T, B > const)
template<class T , T A, T... Bs> requires IsInvocable<Mod, T, T>
static constexpr auto	pRC::operator% (Constant< T, A > const, Sequence< T, Bs... > const)
template<class T , T... Is> requires IsInvocable<Minus, T>
static constexpr auto	pRC::operator- (Sequence< T, Is... > const)
template<class T , T... As, T... Bs>
static constexpr auto	pRC::operator, (Sequence< T, As... > const, Sequence< T, Bs... > const)
template<IsSequence A, IsSequence B>
static constexpr auto	pRC::operator== (A const, B const)
template<class T , T... As, T B> requires IsInvocable<Equal, T, T>
static constexpr auto	pRC::operator== (Sequence< T, As... > const, Constant< T, B > const)
template<class T , T A, T... Bs> requires IsInvocable<Equal, T, T>
static constexpr auto	pRC::operator== (Constant< T, A > const, Sequence< T, Bs... > const)
template<IsSequence A, IsSequence B>
static constexpr auto	pRC::operator!= (A const, B const)
template<class T , T... As, T B> requires IsInvocable<NotEqual, T, T>
static constexpr auto	pRC::operator!= (Sequence< T, As... > const, Constant< T, B > const)
template<class T , T A, T... Bs> requires IsInvocable<NotEqual, T, T>
static constexpr auto	pRC::operator!= (Constant< T, A > const, Sequence< T, Bs... > const)
template<class T , T... As, T... Bs> requires IsInvocable<LessEqual, T, T> && (sizeof...(As) == sizeof...(Bs))
static constexpr auto	pRC::operator<= (Sequence< T, As... > const, Sequence< T, Bs... > const)
template<class T , T... As, T B> requires IsInvocable<LessEqual, T, T>
static constexpr auto	pRC::operator<= (Sequence< T, As... > const, Constant< T, B > const)
template<class T , T A, T... Bs> requires IsInvocable<LessEqual, T, T>
static constexpr auto	pRC::operator<= (Constant< T, A > const, Sequence< T, Bs... > const)
template<class T , T... As, T... Bs> requires IsInvocable<GreaterEqual, T, T> && (sizeof...(As) == sizeof...(Bs))
static constexpr auto	pRC::operator>= (Sequence< T, As... > const, Sequence< T, Bs... > const)
template<class T , T... As, T B> requires IsInvocable<GreaterEqual, T, T>
static constexpr auto	pRC::operator>= (Sequence< T, As... > const, Constant< T, B > const)
template<class T , T A, T... Bs> requires IsInvocable<GreaterEqual, T, T>
static constexpr auto	pRC::operator>= (Constant< T, A > const, Sequence< T, Bs... > const)
template<class T , T... As, T... Bs> requires IsInvocable<Less, T, T> && (sizeof...(As) == sizeof...(Bs))
static constexpr auto	pRC::operator< (Sequence< T, As... > const, Sequence< T, Bs... > const)
template<class T , T... As, T B> requires IsInvocable<Less, T, T>
static constexpr auto	pRC::operator< (Sequence< T, As... > const, Constant< T, B > const)
template<class T , T A, T... Bs> requires IsInvocable<Less, T, T>
static constexpr auto	pRC::operator< (Constant< T, A > const, Sequence< T, Bs... > const)
template<class T , T... As, T... Bs> requires IsInvocable<Greater, T, T> && (sizeof...(As) == sizeof...(Bs))
static constexpr auto	pRC::operator> (Sequence< T, As... > const, Sequence< T, Bs... > const)
template<class T , T... As, T B> requires IsInvocable<Greater, T, T>
static constexpr auto	pRC::operator> (Sequence< T, As... > const, Constant< T, B > const)
template<class T , T A, T... Bs> requires IsInvocable<Greater, T, T>
static constexpr auto	pRC::operator> (Constant< T, A > const, Sequence< T, Bs... > const)
template<class T , T... Seq, class F , class... Xs> requires IsInvocable<F, Xs..., Constant<T, Seq>...>
static constexpr decltype(auto)	pRC::expand (Sequence< T, Seq... > const, F &&f, Xs &&...args)
template<class T , T N>
static constexpr auto	pRC::makeSeries ()
template<class T >
static constexpr auto	pRC::makeSeriesFor ()
template<class T , class... Ts> requires (sizeof...(Ts) > 0)
static constexpr auto	pRC::makeSeriesFor ()
template<class T , T First, T Last, Direction D = Direction::Forwards, T Step = T(1)> requires (D == Direction::Forwards)
static constexpr auto	pRC::makeRange ()
template<class T , T First, T Last, Direction D = Direction::Forwards, T Step = T(1)> requires (D == Direction::Backwards)
static constexpr auto	pRC::makeRange ()
template<class T , Size N, T V>
static constexpr auto	pRC::makeConstantSequence ()
template<class F , class T , T I1, T I2, T... Is> requires IsInvocable<F, T, T>
static constexpr auto	pRC::reduce (Sequence< T, I1, I2, Is... > const)
template<class F , class T , T I>
static constexpr auto	pRC::reduce (Sequence< T, I > const)
template<class F , class T >
static constexpr auto	pRC::reduce (Sequence< T > const)
template<Index... Ps, class T , T... Is> requires ((sizeof...(Is) == sizeof...(Ps))) && (((Ps < sizeof...(Is)) && ...))
static constexpr auto	pRC::permute (Sequence< T, Is... > const)
template<class T , T... Is>
static constexpr auto	pRC::reverse (Sequence< T, Is... > const)
template<Direction D, Size Step, class T , T... Is> requires (D == Direction::Leftwards || D == Direction::Rightwards)
static constexpr auto	pRC::rotate (Sequence< T, Is... > const)
template<Index O = 0, class T , T... Is, class... Seqs> requires ((Sequence<T, Is...>::size() == Seqs::size()) && ...)
static constexpr auto	pRC::zip (Sequence< T, Is... > const, Seqs const ...)
template<class F , class T , T... Is>
static constexpr auto	pRC::filter (Sequence< T, Is... > const)
template<class F , class T , T... As, T... Bs, class... Seqs> requires IsInvocable<F, T, T> && (sizeof...(As) == sizeof...(Bs)) && ((sizeof...(As) == Seqs::Dimension) && ...)
static constexpr auto	pRC::pick (Sequence< T, As... > const, Sequence< T, Bs... > const, Seqs const ...)
template<Index D, Index... Ds, class T , T... Is> requires (sizeof...(Ds) < sizeof...(Is) && max(D, Ds...) < sizeof...(Is))
static constexpr auto	pRC::chip (Sequence< T, Is... > const)
template<class T , T... Is>
static constexpr auto	pRC::chip (Sequence< T, Is... > const)
template<Index S, Index... Ss, class T , T... Is> requires (sizeof...(Ss) < sizeof...(Is) && max(S, Ss...) < sizeof...(Is))
static constexpr auto	pRC::select (Sequence< T, Is... > const)
template<class T , T... Is>
static constexpr auto	pRC::select (Sequence< T, Is... > const)
template<Index B, Index P, class T , T... Is> requires (sizeof...(Is) % B == 0 && P < B)
static constexpr auto	pRC::cut (Sequence< T, Is... > const)
template<Index I, Index L, class T , T... Is> requires (L <= sizeof...(Is) && I < L)
static constexpr auto	pRC::trim (Sequence< T, Is... > const)
template<class F = Less, class T , T I, T... Is> requires IsPredicate<F, T, T>
static constexpr auto	pRC::sort (Sequence< T, I, Is... > const)
template<class T , T From, T... Froms, T To, T... Tos, T P, T... Ps> requires (sizeof...(Froms) == sizeof...(Tos) && sizeof...(Froms) == sizeof...(Ps))
static constexpr auto	pRC::getPermutation (Sequence< T, From, Froms... > const, Sequence< T, To, Tos... > const, Sequence< T, P, Ps... > const)
template<class T , T... Froms, T... Tos> requires (sizeof...(Froms) == sizeof...(Tos))
static constexpr auto	pRC::getPermutation (Sequence< T, Froms... > const, Sequence< T, Tos... > const)
template<class T , T... Froms>
static constexpr auto	pRC::getPermutation (Sequence< T, Froms... > const)
template<class T , T N, T... Ps>
static constexpr auto	pRC::integerFactorization (Constant< T, N > const, Sequence< T, Ps... > const =Sequence< T >())