sequence.hpp File Reference

#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/basic/type_traits.hpp>
#include <prc/core/container/type_traits.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/sub.hpp>

Go to the source code of this file.

Classes
class	pRC::Sequence< T, Seq >
class	pRC::Sequence< Size, Ns... >

Namespaces
namespace	pRC

Functions
template<class T , T... Seq>
	pRC::Sequence (std::integer_sequence< T, Seq... > const) -> Sequence< T, Seq... >
template<Size... Ns>
	pRC::Sequence (Sizes< Ns... > const) -> Sequence< Size, Ns... >
template<class T , T... As, T... Bs, If< IsInvocable< Add, T, T > > = 0, If< IsSatisfied<(sizeof...(As)==sizeof...(Bs))> > = 0>
static constexpr auto	pRC::operator+ (Sequence< T, As... > const, Sequence< T, Bs... > const)
template<class T , T... As, T B, If< IsInvocable< Add, T, T > > = 0>
static constexpr auto	pRC::operator+ (Sequence< T, As... > const, Constant< T, B > const)
template<class T , T A, T... Bs, If< IsInvocable< Add, T, T > > = 0>
static constexpr auto	pRC::operator+ (Constant< T, A > const, Sequence< T, Bs... > const)
template<class T , T... As, T... Bs, If< IsInvocable< Sub, T, T > > = 0, If< IsSatisfied<(sizeof...(As)==sizeof...(Bs))> > = 0>
static constexpr auto	pRC::operator- (Sequence< T, As... > const, Sequence< T, Bs... > const)
template<class T , T... As, T B, If< IsInvocable< Sub, T, T > > = 0>
static constexpr auto	pRC::operator- (Sequence< T, As... > const, Constant< T, B > const)
template<class T , T... As, T... Bs, If< IsInvocable< Mul, T, T > > = 0, If< IsSatisfied<(sizeof...(As)==sizeof...(Bs))> > = 0>
static constexpr auto	pRC::operator* (Sequence< T, As... > const, Sequence< T, Bs... > const)
template<class T , T... As, T B, If< IsInvocable< Mul, T, T > > = 0>
static constexpr auto	pRC::operator* (Sequence< T, As... > const, Constant< T, B > const)
template<class T , T A, T... Bs, If< IsInvocable< Mul, T, T > > = 0>
static constexpr auto	pRC::operator* (Constant< T, A > const, Sequence< T, Bs... > const)
template<class T , T... As, T... Bs, If< IsInvocable< Div, T, T > > = 0, If< IsSatisfied<(sizeof...(As)==sizeof...(Bs))> > = 0>
static constexpr auto	pRC::operator/ (Sequence< T, As... > const, Sequence< T, Bs... > const)
template<class T , T... As, T B, If< IsInvocable< Div, T, T > > = 0>
static constexpr auto	pRC::operator/ (Sequence< T, As... > const, Constant< T, B > const)
template<class T , T... As, T... Bs, If< IsInvocable< Mod, T, T > > = 0, If< IsSatisfied<(sizeof...(As)==sizeof...(Bs))> > = 0>
static constexpr auto	pRC::operator% (Sequence< T, As... > const, Sequence< T, Bs... > const)
template<class T , T... As, T B, If< IsInvocable< Mod, T, T > > = 0>
static constexpr auto	pRC::operator% (Sequence< T, As... > const, Constant< T, B > const)
template<class T , T... Is, If< IsInvocable< Minus, T > > = 0>
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<class T , T... As, T... Bs, If< IsSatisfied<(sizeof...(As)==sizeof...(Bs))> > = 0>
static constexpr auto	pRC::operator== (Sequence< T, As... > const, Sequence< T, Bs... > const)
template<class T , T... As, T B>
static constexpr auto	pRC::operator== (Sequence< T, As... > const, Constant< T, B > const)
template<class T , T A, T... Bs>
static constexpr auto	pRC::operator== (Constant< T, A > const, Sequence< T, Bs... > const)
template<class T , T... As, T... Bs, If< IsSatisfied<(sizeof...(As)==sizeof...(Bs))> > = 0>
static constexpr auto	pRC::operator!= (Sequence< T, As... > const, Sequence< T, Bs... > const)
template<class T , T... As, T B>
static constexpr auto	pRC::operator!= (Sequence< T, As... > const, Constant< T, B > const)
template<class T , T A, T... Bs>
static constexpr auto	pRC::operator!= (Constant< T, A > const, Sequence< T, Bs... > const)
template<class T , T... As, T... Bs, If< IsInvocable< LessEqual, T, T > > = 0, If< IsSatisfied<(sizeof...(As)==sizeof...(Bs))> > = 0>
static constexpr auto	pRC::operator<= (Sequence< T, As... > const, Sequence< T, Bs... > const)
template<class T , T... As, T B, If< IsInvocable< LessEqual, T, T > > = 0>
static constexpr auto	pRC::operator<= (Sequence< T, As... > const, Constant< T, B > const)
template<class T , T A, T... Bs, If< IsInvocable< LessEqual, T, T > > = 0>
static constexpr auto	pRC::operator<= (Constant< T, A > const, Sequence< T, Bs... > const)
template<class T , T... As, T... Bs, If< IsInvocable< GreaterEqual, T, T > > = 0, If< IsSatisfied<(sizeof...(As)==sizeof...(Bs))> > = 0>
static constexpr auto	pRC::operator>= (Sequence< T, As... > const, Sequence< T, Bs... > const)
template<class T , T... As, T B, If< IsInvocable< GreaterEqual, T, T > > = 0>
static constexpr auto	pRC::operator>= (Sequence< T, As... > const, Constant< T, B > const)
template<class T , T A, T... Bs, If< IsInvocable< GreaterEqual, T, T > > = 0>
static constexpr auto	pRC::operator>= (Constant< T, A > const, Sequence< T, Bs... > const)
template<class T , T... As, T... Bs, If< IsInvocable< Equal, T, T > > = 0, If< IsSatisfied<(sizeof...(As)==sizeof...(Bs))> > = 0>
static constexpr auto	pRC::operator< (Sequence< T, As... > const, Sequence< T, Bs... > const)
template<class T , T... As, T B, If< IsInvocable< Equal, T, T > > = 0>
static constexpr auto	pRC::operator< (Sequence< T, As... > const, Constant< T, B > const)
template<class T , T A, T... Bs, If< IsInvocable< Equal, T, T > > = 0>
static constexpr auto	pRC::operator< (Constant< T, A > const, Sequence< T, Bs... > const)
template<class T , T... As, T... Bs, If< IsInvocable< Equal, T, T > > = 0, If< IsSatisfied<(sizeof...(As)==sizeof...(Bs))> > = 0>
static constexpr auto	pRC::operator> (Sequence< T, As... > const, Sequence< T, Bs... > const)
template<class T , T... As, T B, If< IsInvocable< Equal, T, T > > = 0>
static constexpr auto	pRC::operator> (Sequence< T, As... > const, Constant< T, B > const)
template<class T , T A, T... Bs, If< IsInvocable< Equal, T, T > > = 0>
static constexpr auto	pRC::operator> (Constant< T, A > const, Sequence< T, Bs... > const)
template<class T , T... Seq, class F , class... Xs, If< IsInvocable< F, Xs..., Constant< T, Seq >... > > = 0>
static constexpr decltype(auto)	pRC::expand (Sequence< T, Seq... > const, F &&f, Xs &&...args)
	forwards the values in a pRC::Sequence to a function as parameters
template<class T , T N>
static constexpr auto	pRC::makeSeries ()
template<class T >
static constexpr auto	pRC::makeSeriesFor ()
template<class T , class... Ts, If< IsSatisfied<(sizeof...(Ts) > 0)> >
static constexpr auto	pRC::makeSeriesFor ()
template<class T , T First, T Last, Direction D = Direction::Forwards, T Step = T(1), If< IsSatisfied<(D==Direction::Forwards||D==Direction::Backwards)> > = 0, If< IsSatisfied<((Last - First) % Step==0)> > = 0>
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, If< IsInvocable< F, T, T > > = 0>
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<Index... Ps, class T , T... Is, If< IsSatisfied<(sizeof...(Is)==sizeof...(Ps))> > = 0, If< IsSatisfied<((Ps< sizeof...(Is)) &&...)> > = 0, If< IsUnique< Constant< Index, Ps >... > > = 0>
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 First, T... Is, If< IsSatisfied<(D==Direction::Leftwards||D==Direction::Rightwards)> > = 0>
static constexpr auto	pRC::rotate (Sequence< T, First, Is... > const)
template<Direction D, Size Step, class T , If< IsSatisfied<(D==Direction::Leftwards||D==Direction::Rightwards)> > = 0>
static constexpr auto	pRC::rotate (Sequence< T > const)
template<Index O = 0, class T , T... Is, class... Seqs, If< IsSatisfied<((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, If< IsInvocable< F, T, T > > = 0, If< IsSatisfied<((Sequence< T, As... >::size()==Seqs::size()) &&... &&(Sequence< T, As... >::size()==Sequence< T, Bs... >::size()))> >
static constexpr auto	pRC::pick (Sequence< T, As... > const, Sequence< T, Bs... > const, Seqs const ...)
template<Index D, Index... Ds, class T , T... Is, If< IsSatisfied<(sizeof...(Ds)< sizeof...(Is))> > = 0, If< IsSatisfied<(max(D, Ds...)< sizeof...(Is))> > = 0, If< IsUnique< Constant< Index, D >, Constant< Index, Ds >... > > = 0>
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, If< IsSatisfied<(sizeof...(Ss)< sizeof...(Is))> > = 0, If< IsSatisfied<(max(S, Ss...)< sizeof...(Is))> > = 0, If< IsUnique< Constant< Index, S >, Constant< Index, Ss >... > > = 0>
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, If< IsSatisfied<(sizeof...(Is) % B==0)> > = 0, If< IsSatisfied<(P< B)> > = 0>
static constexpr auto	pRC::cut (Sequence< T, Is... > const)
template<Index I, Index L, class T , T... Is, If< IsSatisfied<(L<=sizeof...(Is))> > = 0, If< IsSatisfied<(I< L)> > = 0>
static constexpr auto	pRC::trim (Sequence< T, Is... > const)
template<class F = Less, class T , T I, T... Is, If< IsInvocableResult< Bool, F, T, T > > = 0>
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, If< IsSatisfied<(sizeof...(Froms)==sizeof...(Tos) &&sizeof...(Froms)==sizeof...(Ps))> > = 0>
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, If< IsSatisfied<(sizeof...(Froms)==sizeof...(Tos))> > = 0>
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 >())