pRC Namespace Reference

Namespaces
namespace	Hardware
namespace	Logging
namespace	Operator
namespace	Optimizer
namespace	Solver
namespace	TensorTrain
namespace	TensorViews

Classes
struct	Abs
struct	AbsoluteError
struct	Acos
struct	Acosh
struct	Add
struct	Adjoint
struct	Apply
struct	Arg
struct	Asin
struct	Asinh
struct	Atan
struct	Atan2
struct	Atanh
struct	Backwards
class	BFloat16
struct	Block
struct	Broadcast
struct	Cast
struct	Ceil
struct	Chip
class	CommonArray
class	CommonArray< A, T >
class	CommonArray< A, T, N, Ns... >
class	CommonArray< Allocation::Heap, T, N >
class	CommonArray< Allocation::Stack, T, N >
struct	CommonType
struct	CommonType< Complex< T >, Complex< U >, If< HasCommon< T, U > > >
struct	CommonType< Complex< T >, U, If< All< IsValue< U >, HasCommon< T, U > > > >
struct	CommonType< T, Complex< U >, If< All< IsValue< T >, HasCommon< T, U > > > >
struct	CommonType< TA, TB, If< All< IsFloat< TA >, IsFloat< TB > > > >
struct	CommonType< TA, TB, If< All< IsFloat< TA >, IsInteger< TB > > > >
struct	CommonType< TA, TB, If< All< IsInteger< TA >, IsFloat< TB > > > >
struct	CommonType< TA, TB, If< All< IsSignedInteger< TA >, IsSignedInteger< TB > > > >
struct	CommonType< TA, TB, If< All< IsSignedInteger< TA >, IsUnsignedInteger< TB > > > >
struct	CommonType< TA, TB, If< All< IsUnsignedInteger< TA >, IsSignedInteger< TB > > > >
struct	CommonType< TA, TB, If< All< IsUnsignedInteger< TA >, IsUnsignedInteger< TB > > > >
struct	CommonType< TA, VB, If< All< IsTensor< TA >, IsTensorView< VB >, HasCommon< TA, ResultOf< Eval, VB > > > > >
struct	CommonType< Tensor< TA, Ns... >, Tensor< TB, Ns... >, If< HasCommon< TA, TB > > >
struct	CommonType< VA, TB, If< All< IsTensorView< VA >, IsTensor< TB >, HasCommon< ResultOf< Eval, VA >, TB > > > >
struct	CommonType< VA, VB, If< All< IsTensorView< VA >, IsTensorView< VB >, HasCommon< ResultOf< Eval, VA >, ResultOf< Eval, VB > > > > >
struct	CommonTypes
struct	CommonTypes< T >
struct	CommonTypes< TA, TB >
class	Complex
struct	Complexify
struct	Conj
struct	Contract
struct	Cos
struct	Cosh
class	CRTP
struct	Delta
class	Deque
struct	DetectCommonType
struct	Detector
struct	Detector< Void< Op< Args... > >, Op, Args... >
struct	Diagonal
struct	DirectSum
struct	Div
struct	Enumerate
struct	Equal
struct	Eval
struct	Exclude
struct	Exp
struct	ExtractDiagonal
struct	False
struct	Flatten
class	Float
struct	Floor
struct	FMod
struct	Fold
struct	Folding
struct	FromDiagonal
class	GaussianDistribution
class	GaussianDistribution< T, If< IsFloat< T > > >
struct	Greater
struct	GreaterEqual
struct	HadamardProduct
struct	Identity
struct	Identity< Float< 16 > >
struct	Identity< T, If< IsBool< T > > >
struct	Identity< T, If< IsComplex< T > > >
struct	Identity< T, If< IsIntegral< T > > >
struct	Identity< T, If< IsTensor< T > > >
struct	Identity< T, If< IsTensorView< T > > >
struct	Identity< T, If< IsValue< T > > >
struct	Identity< T, If< TensorTrain::IsOperator< T > > >
struct	Identity< T, If< TensorTrain::IsOperatorView< T > > >
struct	Identity< Void<> >
struct	Imag
class	Indices
struct	Inflate
struct	InnerProduct
class	Integer
struct	IsApprox
struct	IsArray
struct	IsArray< CommonArray< A, T, Ns... > >
struct	IsArray< T const >
struct	IsComplex
struct	IsComplex< Complex< T > >
struct	IsComplex< T const >
struct	IsDeque
struct	IsDeque< Deque< T, N > >
struct	IsDeque< T const >
struct	IsDiagonal
struct	IsDistribution
struct	IsDistribution< GaussianDistribution< T, V > >
struct	IsDistribution< LaplaceDistribution< T > >
struct	IsDistribution< T const >
struct	IsDistribution< UniformDistribution< T, V > >
struct	IsFinite
struct	IsFloat
struct	IsFloat< Float< W > >
struct	IsFloat< T const >
struct	IsIdentity
struct	IsIndices
struct	IsIndices< Indices< N > >
struct	IsIndices< T const >
struct	IsLowerTriangular
struct	IsNaN
struct	IsOffDiagonal
struct	IsRandomEngine
struct	IsRandomEngine< T const >
struct	IsRandomEngine< Threefry< R, U > >
struct	IsSame
struct	IsSame< T >
struct	IsSame< T, T >
struct	IsSame< T, U >
struct	IsSame< T, U, Ts... >
struct	IsSelfAdjoint
struct	IsSequence
struct	IsSequence< Sequence< T, Seq... > >
struct	IsSequence< T const >
struct	IsSignedInteger
struct	IsSignedInteger< SignedInteger< W > >
struct	IsSignedInteger< T const >
struct	IsStrictlyLowerTriangular
struct	IsStrictlyUpperTriangular
struct	IsString
struct	IsString< String< N > >
struct	IsString< T const >
struct	IsSubscripts
struct	IsSubscripts< Subscripts< Ns... > >
struct	IsSubscripts< T const >
struct	IsSymmetric
struct	IsTensor
struct	IsTensor< T const >
struct	IsTensor< Tensor< T, Ns... > >
struct	IsTensorView
struct	IsUnique
struct	IsUnique< T >
struct	IsUnit
struct	IsUnitary
struct	IsUnitLowerTriangular
struct	IsUnitUpperTriangular
struct	IsUnsignedInteger
struct	IsUnsignedInteger< T const >
struct	IsUnsignedInteger< UnsignedInteger< W > >
struct	IsUpperTriangular
struct	IsZero
class	JacobiRotation
struct	KroneckerProduct
class	LaplaceDistribution
class	LaplaceDistribution< T, If< IsFloat< T > > >
struct	Less
struct	LessEqual
struct	Linearize
class	Lock
struct	Log
struct	Log10
struct	Log2
struct	LogicalAnd
struct	LogicalNot
struct	LogicalOr
struct	Loop
struct	LowerTriangular
struct	Matricize
struct	Max
struct	Mean
struct	Min
struct	Minus
struct	Mod
struct	Mul
struct	Narrow
struct	Norm
struct	NotEqual
struct	NotFn
struct	NumericLimits
struct	NumericLimits< Float< 16 > >
struct	NumericLimits< T const >
struct	NumericLimits< T, If< IsIntegral< T > > >
struct	NumericLimits< T, If< IsValue< T > > >
struct	OffDiagonal
struct	OuterProduct
class	Parameter
class	Parameter< Context::CompileTime, T, SA, SN, SD >
class	Parameter< Context::RunTime, T, SA, SN, SD >
struct	Permute
struct	Plus
struct	Pow
struct	Random
struct	Random< Complex< T >, D< T >, If< All< IsValue< T >, IsDistribution< D< T > > > > >
struct	Random< T, D< T >, If< All< IsValue< T >, IsDistribution< D< T > > > > >
struct	Random< Tensor< T, Ns... >, D< typename T::Value >, If< IsDistribution< D< typename T::Value > > > >
struct	Random< TensorTrain::Operator< T, M, N, Ranks >, D< typename T::Value >, If< IsDistribution< D< typename T::Value > > > >
struct	Random< TensorTrain::Tensor< T, N, Ranks >, D< typename T::Value >, If< IsDistribution< D< typename T::Value > > > >
struct	Rcp
struct	Real
class	RecursiveLambda
struct	Reduce
struct	RelativeError
struct	Reshape
struct	Restrict
struct	Reverse
struct	Rotate
struct	Round
struct	Scalar
struct	ScalarProduct
class	SeedSequence
class	Sequence
class	Sequence< Size, Ns... >
struct	Sign
struct	Sin
struct	Sinh
struct	Slice
struct	Sqrt
struct	Square
struct	Squeeze
class	Stopwatch
struct	StrictlyLowerTriangular
struct	StrictlyUpperTriangular
struct	Stride
class	String
struct	Sub
struct	Subscript
class	Subscripts
struct	Swap
struct	Tan
struct	Tanh
class	Tensor
class	Tensor< Bool, Ns... >
struct	TensorProduct
class	Threefry
struct	Trace
struct	Transform
struct	Transpose
struct	True
struct	Trunc
struct	Unfolding
class	UniformDistribution
class	UniformDistribution< T, If< Any< IsFloat< T >, IsInteger< T > > > >
struct	Unit
struct	Unit< T, If< Any< IsBool< T >, IsIntegral< T > > > >
struct	Unit< T, If< IsComplex< T > > >
struct	Unit< T, If< IsTensor< T > > >
struct	Unit< T, If< IsTensorView< T > > >
struct	Unit< T, If< IsValue< T > > >
struct	Unit< T, If< TensorTrain::IsOperator< T > > >
struct	Unit< T, If< TensorTrain::IsOperatorView< T > > >
struct	Unit< T, If< TensorTrain::IsTensor< T > > >
struct	Unit< T, If< TensorTrain::IsTensorView< T > > >
struct	Unit< Void<> >
struct	UnitLowerTriangular
struct	UnitUpperTriangular
struct	UpperTriangular
struct	View
struct	Where
struct	Zero
struct	Zero< Float< 16 > >
struct	Zero< T, If< IsBool< T > > >
struct	Zero< T, If< IsComplex< T > > >
struct	Zero< T, If< IsIntegral< T > > >
struct	Zero< T, If< IsTensor< T > > >
struct	Zero< T, If< IsTensorView< T > > >
struct	Zero< T, If< IsValue< T > > >
struct	Zero< T, If< TensorTrain::IsOperator< T > > >
struct	Zero< T, If< TensorTrain::IsOperatorView< T > > >
struct	Zero< T, If< TensorTrain::IsTensor< T > > >
struct	Zero< T, If< TensorTrain::IsTensorView< T > > >
struct	Zero< Void<> >

Typedefs
template<class... Ts>
using	Common = typename CommonTypes<Ts...>::Type
template<class... Ts>
using	HasCommon = IsDetected<Common, Ts...>
using	Mutex = std::mutex
template<class... Ts>
using	Void = void
using	Bool = bool
using	Size = std::size_t
using	Index = Size
using	Seed = std::uint32_t
template<class T , T V>
using	Constant = std::integral_constant<T, V>
template<class T >
using	IsReference = std::is_reference<T>
template<class T >
using	IsPointer = std::is_pointer<T>
template<class T >
using	IsConst = std::is_const<T>
template<class T >
using	RemoveReference = std::remove_reference_t<T>
template<class T >
using	RemoveConst = std::remove_const_t<T>
template<class T >
using	RemoveConstReference = RemoveConst<RemoveReference<T>>
template<class T >
using	AddConst = std::add_const_t<T>
template<class B = True<>>
using	If = std::enable_if_t<B{}, int>
template<Bool B>
using	IsSatisfied = Constant<Bool, B>
template<class B >
using	Not = std::negation<B>
template<class... Bs>
using	All = std::conjunction<Bs...>
template<class... Bs>
using	Any = std::disjunction<Bs...>
template<class... Bs>
using	None = All<Not<Bs>...>
template<class T >
using	IsDefined = decltype(isDefined(declval<T *>()))
template<class B , class T , class F >
using	Conditional = std::conditional_t<B{}, T, F>
template<class F , class... Args>
using	IsInvocable = std::is_invocable<F, Args...>
template<class R , class F , class... Args>
using	IsInvocableResult = std::is_invocable_r<R, F, Args...>
template<class F , class... Args>
using	ResultOf = std::invoke_result_t<F, Args...>
template<class T , class... Args>
using	IsConstructible = std::is_constructible<T, Args...>
template<class T , class U = T>
using	IsAssignable = std::is_assignable<T, U>
template<class F , class T >
using	IsConvertible = std::is_convertible<F, T>
template<class B , class D >
using	IsBaseOf = std::is_base_of<B, D>
template<class T >
using	IsStandardLayout = std::is_standard_layout<T>
template<template< class... > class Op, class... Args>
using	IsDetected = Detector<void, Op, Args...>
template<class T >
using	IsEnum = std::is_enum<T>
template<class T >
using	UnderlyingType = std::underlying_type_t<T>
template<class T >
using	IsBool = IsSame<RemoveConst<T>, Bool>
template<class T >
using	IsIntegral = All<std::is_integral<T>, Not<IsBool<T>>>
template<class T >
using	IsSignedIntegral = All<IsIntegral<T>, std::is_signed<T>>
template<class T >
using	IsUnsignedIntegral = All<IsIntegral<T>, std::is_unsigned<T>>
template<class T >
using	IsSize = IsSame<RemoveConst<T>, Size>
template<class T >
using	IsIndex = IsSame<RemoveConst<T>, Index>
template<class T >
using	IsSeed = IsSame<RemoveConst<T>, Seed>
template<Size... Ns>
using	Sizes = Sequence<Size, Ns...>
template<class T >
using	IsSizes = All<IsSequence<T>, IsSame<Size, typename T::Type>>
template<class T , Size... Ns>
using	StackArray = CommonArray<Allocation::Stack, T, Ns...>
template<class T , Size... Ns>
using	HeapArray = CommonArray<Allocation::Heap, T, Ns...>
template<class T , Size... Ns>
using	Array
template<class T >
using	IsSubscriptable = IsInvocable<Subscript, T, Index>
using	RandomEngine = Threefry<20>
template<class T >
using	IsTensorish = Any<IsTensor<T>, IsTensorView<T>>
template<Size W = sizeof(int) * 8>
using	SignedInteger = Integer<true, W>
template<Size W = sizeof(int) * 8>
using	UnsignedInteger = Integer<false, W>
template<class T >
using	IsInteger = Any<IsSignedInteger<T>, IsUnsignedInteger<T>>
template<class T >
using	IsValue = Any<IsFloat<T>, IsInteger<T>>

Enumerations
enum class	LogLevel {   Error , Warning , Info , Debug ,   Trace }
enum class	DebugLevel { None , Low , Mid , High }
enum class	Context { CompileTime , RunTime }
enum class	Direction {   Leftwards , RightToLeft = Leftwards , Rightwards , LeftToRight = Rightwards ,   Upwards , Up = Upwards , Downwards , Down = Downwards ,   Forwards , Forward = Forwards , Backwards , Backward = Backwards }
enum class	Position { Left , Right , Front , Back }
enum class	Allocation { Stack , Heap }

Functions
template<Operator::Hint H = Operator::Hint::None, class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsFloat< typename R::Value > > = 0, If< IsSatisfied<(typename R::Dimension()==2)> > = 0, If< IsSatisfied<(R::size(0)==R::size(1))> > = 0>
static constexpr auto	cholesky (X &&a)
template<class T , Size M, Size N>
	JacobiRotation (Tensor< T, M, N > const &a, Index const p, Index const q) -> JacobiRotation< T >
template<class V , class T , Size M, Size N>
	JacobiRotation (TensorViews::View< T, Sizes< M, N >, V > const &a, Index const p, Index const q) -> JacobiRotation< T >
template<class T , Size N>
	JacobiRotation (Tensor< T, N > const &a, Index const p, Index const q) -> JacobiRotation< T >
template<class V , class T , Size N>
	JacobiRotation (TensorViews::View< T, Sizes< N >, V > const &a, Index const p, Index const q) -> JacobiRotation< T >
template<class TA , class TB >
static constexpr auto	operator== (JacobiRotation< TA > const &a, JacobiRotation< TB > const &b)
template<class TA , class TB >
static constexpr auto	operator!= (JacobiRotation< TA > const &a, JacobiRotation< TB > const &b)
template<class TA , class TB >
static constexpr auto	operator* (JacobiRotation< TA > const &a, JacobiRotation< TB > const &b)
template<class T >
static constexpr auto	transpose (JacobiRotation< T > const &a)
template<class T >
static constexpr auto	adjoint (JacobiRotation< T > const &a)
template<class T , class X , class R = RemoveReference<X>, If< Any< All< IsTensor< R >, Not< IsReference< X > > >, All< IsTensorish< R >, IsAssignable< X > > > > = 0, If< IsSatisfied<(typename R::Dimension()==2)> > = 0>
static constexpr decltype(auto)	apply (JacobiRotation< T > const &r, X &&m, Index const p, Index const q)
template<class T , class X , class R = RemoveReference<X>, If< Any< All< IsTensor< R >, Not< IsReference< X > > >, All< IsTensorish< R >, IsAssignable< X > > > > = 0, If< IsSatisfied<(typename R::Dimension()==2)> > = 0>
static constexpr decltype(auto)	apply (X &&m, JacobiRotation< T > const &r, Index const p, Index const q)
template<Size B = 32, class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsFloat< typename R::Value > > = 0, If< IsSatisfied<(typename R::Dimension()==2)> > = 0>
static constexpr auto	lq (X &&input)
template<class Optimizer , class XX , class RX = RemoveReference<XX>, class TX = typename RX::Type, class VX = typename TX::Value, If< IsTensorish< RX > > = 0, class RXE = RemoveConstReference<ResultOf<Eval, XX>>, class FF , If< IsInvocable< FF, RXE const &, RXE & > > = 0, If< IsFloat< ResultOf< FF, RXE const &, RXE & > > > = 0, class FC , If< IsInvocable< FC, RXE & > > = 0, class VT = VX, If< All< IsFloat< VX >, IsFloat< VT > > > = 0, If< IsInvocable< Optimizer, XX, FF, FC, VT > > = 0>
static constexpr auto	optimize (Optimizer &&optimizer, XX &&x, FF &&function, FC &&callback, VT const &tolerance=NumericLimits< VT >::tolerance())
template<class Optimizer , class XX , class RX = RemoveReference<XX>, class TX = typename RX::Type, class VX = typename TX::Value, If< IsTensorish< RX > > = 0, class RXE = RemoveConstReference<ResultOf<Eval, XX>>, class FF , If< IsInvocable< FF, RXE const &, RXE & > > = 0, If< IsFloat< ResultOf< FF, RXE const &, RXE & > > > = 0, class VT = VX, If< All< IsFloat< VX >, IsFloat< VT > > > = 0, If< IsInvocable< Optimizer, XX, FF, void(RXE const), VT > > = 0>
static constexpr auto	optimize (Optimizer &&optimizer, XX &&x, FF &&function, VT const &tolerance=NumericLimits< VT >::tolerance())
template<class Optimizer , class XX , class RX = RemoveReference<XX>, class TX = typename RX::Type, class VX = typename TX::Value, If< IsTensorish< RX > > = 0, class RXE = RemoveConstReference<ResultOf<Eval, XX>>, class FF , If< IsInvocable< FF, RXE const &, RXE & > > = 0, If< IsFloat< ResultOf< FF, RXE const &, RXE & > > > = 0, class FC , If< IsInvocable< FC, RXE & > > = 0, class VT = VX, If< All< IsFloat< VX >, IsFloat< VT > > > = 0, If< IsInvocable< Optimizer, XX, FF, FC, VT > > = 0>
static constexpr auto	optimize (XX &&x, FF &&function, FC &&callback, VT const &tolerance=NumericLimits< VT >::tolerance())
template<class Optimizer , class XX , class RX = RemoveReference<XX>, class TX = typename RX::Type, class VX = typename TX::Value, If< IsTensorish< RX > > = 0, class RXE = RemoveConstReference<ResultOf<Eval, XX>>, class FF , If< IsInvocable< FF, RXE const &, RXE & > > = 0, If< IsFloat< ResultOf< FF, RXE const &, RXE & > > > = 0, class VT = VX, If< All< IsFloat< VX >, IsFloat< VT > > > = 0, If< IsInvocable< Optimizer, XX, FF, void(RXE const), VT > > = 0>
static constexpr auto	optimize (XX &&x, FF &&function, VT const &tolerance=NumericLimits< VT >::tolerance())
template<Size B = 32, class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsFloat< typename R::Value > > = 0, If< IsSatisfied<(typename R::Dimension()==2)> > = 0>
static constexpr auto	qr (X &&input)
template<Operator::Transform T = Operator::Transform::None, Operator::Restrict R = Operator::Restrict::None, Operator::Hint H = Operator::Hint::None, class Solver , class XA , class XB , If< IsInvocable< Solver, XA, XB > > = 0>
static constexpr decltype(auto)	solve (Solver &&solver, XA &&A, XB &&b)
template<Operator::Transform T = Operator::Transform::None, Operator::Restrict R = Operator::Restrict::None, Operator::Hint H = Operator::Hint::None, class Solver , class XA , class XB , class XX , If< IsInvocable< Solver, XA, XB, XX > > = 0>
static constexpr decltype(auto)	solve (Solver &&solver, XA &&A, XB &&b, XX &&x0)
template<Operator::Transform T = Operator::Transform::None, Operator::Restrict R = Operator::Restrict::None, Operator::Hint H = Operator::Hint::None, class Solver , class XA , class XB , class VT , If< IsInvocable< Solver, XA, XB, VT > > = 0>
static constexpr decltype(auto)	solve (Solver &&solver, XA &&A, XB &&b, VT const &tolerance)
template<Operator::Transform T = Operator::Transform::None, Operator::Restrict R = Operator::Restrict::None, Operator::Hint H = Operator::Hint::None, class Solver , class XA , class XB , class XX , class VT , If< IsInvocable< Solver, XA, XB, XX, VT > > = 0>
static constexpr decltype(auto)	solve (Solver &&solver, XA &&A, XB &&b, XX &&x0, VT const &tolerance)
template<class Solver , Operator::Transform T = Operator::Transform::None, Operator::Restrict R = Operator::Restrict::None, Operator::Hint H = Operator::Hint::None, class XA , class XB , If< IsInvocable< Solver, XA, XB > > = 0>
static constexpr decltype(auto)	solve (XA &&A, XB &&b)
template<class Solver , Operator::Transform T = Operator::Transform::None, Operator::Restrict R = Operator::Restrict::None, Operator::Hint H = Operator::Hint::None, class XA , class XB , class XX , If< IsInvocable< Solver, XA, XB, XX > > = 0>
static constexpr decltype(auto)	solve (XA &&A, XB &&b, XX &&x0)
template<class Solver , Operator::Transform T = Operator::Transform::None, Operator::Restrict R = Operator::Restrict::None, Operator::Hint H = Operator::Hint::None, class XA , class XB , class VT , If< IsInvocable< Solver, XA, XB, VT > > = 0>
static constexpr decltype(auto)	solve (XA &&A, XB &&b, VT const &tolerance)
template<class Solver , Operator::Transform T = Operator::Transform::None, Operator::Restrict R = Operator::Restrict::None, Operator::Hint H = Operator::Hint::None, class XA , class XB , class XX , class VT , If< IsInvocable< Solver, XA, XB, XX, VT > > = 0>
static constexpr decltype(auto)	solve (XA &&A, XB &&b, XX &&x0, VT const &tolerance)
template<class C , class T , If< IsSubscriptable< T > > = 0, class S = ResultOf<Subscript, T &, Index>, If< IsInvocable< C, S, S > > = 0, If< IsAssignable< S > > = 0>
static constexpr void	sort (C const &compare, T &a, Size const k=T::size(), Size const d=0)
template<class C = Less, class T , If< IsSubscriptable< T > > = 0, class S = ResultOf<Subscript, T &, Index>, If< IsInvocable< C, S, S > > = 0, If< IsAssignable< S > > = 0>
static constexpr void	sort (T &a, Size const k=T::size(), Size const d=0)
template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsFloat< typename R::Value > > = 0, If< IsSatisfied<(typename R::Dimension()==2)> > = 0>
static constexpr auto	svd (X &&input)
template<Size C, class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, class V = typename R::Value, class VT = V, If< All< IsFloat< V >, IsFloat< VT > > > = 0, If< IsSatisfied<(typename R::Dimension()==2)> > = 0, If< IsSatisfied<(C< min(R::size(0), R::size(1)))> > = 0>
static constexpr auto	svd (X &&input, VT const &tolerance=NumericLimits< VT >::tolerance())
static constexpr auto	reverse (Direction const D)
template<class TA , class TB , If< IsUnsignedIntegral< TA > > = 0, If< IsUnsignedIntegral< TB > > = 0>
static constexpr auto	bitRotateLeft (TA const value, TB count)
template<class TA , class TB , If< IsUnsignedIntegral< TA > > = 0, If< IsUnsignedIntegral< TB > > = 0>
static constexpr auto	bitRotateRight (TA const value, TB count)
template<class TA , class TB , If< IsUnsignedIntegral< TA > > = 0, If< IsUnsignedIntegral< TB > > = 0>
static constexpr auto	ceilDiv (TA const a, TB const b)
template<Bool C = true, class X >
static constexpr Conditional< IsSatisfied< C >, RemoveConstReference< X >, X >	copy (X &&a)
template<class X >
static constexpr auto	operator== (X &&a, Zero<> const)
template<class X >
static constexpr auto	operator== (Zero<> const, X &&b)
static constexpr auto	operator== (Zero<> const, Zero<> const)
template<class X >
static constexpr auto	operator> (X &&a, Zero<> const)
template<class X >
static constexpr auto	operator> (Zero<> const, X &&b)
static constexpr auto	operator> (Zero<> const, Zero<> const)
template<class X >
static constexpr auto	operator>= (X &&a, Zero<> const)
template<class X >
static constexpr auto	operator>= (Zero<> const, X &&b)
static constexpr auto	operator>= (Zero<> const, Zero<> const)
template<class T , If< IsDefined< Identity< T > > > = 0, If< IsConstructible< Identity< T > > > = 0>
static constexpr auto	identity ()
static constexpr auto	identity ()
template<class T , class X , If< IsDefined< Identity< T > > > = 0, If< IsConstructible< Identity< T > > > = 0, If< IsInvocable< Identity< T >, X > > = 0>
static constexpr auto	identity (X &&value)
template<Size B, class T , If< IsUnsignedIntegral< T > > = 0>
static constexpr T	iLog (T const a)
template<class B , class N , If< IsIntegral< B > > = 0, If< IsUnsignedIntegral< N > > = 0>
static constexpr B	iPow (B const base, N const exp)
template<class T , If< IsIntegral< T > > = 0>
static constexpr auto	isEven (T const a)
template<class T , T V, If< IsIntegral< T > > = 0>
static constexpr auto	isEven (Constant< T, V > const)
template<class T , If< IsIntegral< T > > = 0>
static constexpr auto	isIdentity (T const a)
template<class T , T V, If< IsIntegral< T > > = 0>
static constexpr auto	isIdentity (Constant< T, V > const)
template<class T , If< IsIntegral< T > > = 0>
static constexpr auto	isOdd (T const a)
template<class T , T V, If< IsIntegral< T > > = 0>
static constexpr auto	isOdd (Constant< T, V > const)
template<class T , If< IsIntegral< T > > = 0>
static constexpr auto	isPowerOfTwo (T const v)
template<class T , If< IsIntegral< T > > = 0>
static constexpr auto	isUnit (T const a)
template<class T , T V, If< IsIntegral< T > > = 0>
static constexpr auto	isUnit (Constant< T, V > const)
template<class T , If< IsIntegral< T > > = 0>
static constexpr auto	isZero (T const a)
template<class T , T V, If< IsIntegral< T > > = 0>
static constexpr auto	isZero (Constant< T, V > const)
template<class T , If< IsUnsignedIntegral< T > > = 0>
static constexpr T	iSqrt (T const a)
template<class X >
static constexpr auto	operator< (X &&a, Zero<> const)
template<class X >
static constexpr auto	operator< (Zero<> const, X &&b)
static constexpr auto	operator< (Zero<> const, Zero<> const)
template<class X >
static constexpr auto	operator<= (X &&a, Zero<> const)
template<class X >
static constexpr auto	operator<= (Zero<> const, X &&b)
static constexpr auto	operator<= (Zero<> const, Zero<> const)
template<class X >
static constexpr X	max (X &&a)
template<class XA , class XB , If< IsInvocable< Greater, XA, XB > > = 0>
static constexpr auto	max (XA &&a, XB &&b)
template<class XA , class XB , class... Xs, If< IsInvocable< Greater, XA, XB > > = 0, If< All< IsInvocable< Greater, ResultOf< Where, ResultOf< Greater, XA, XB >, XA, XB >, Xs >... > > = 0>
static constexpr auto	max (XA &&a, XB &&b, Xs &&...args)
template<class X >
static constexpr X	min (X &&a)
template<class XA , class XB , If< IsInvocable< Less, XA, XB > > = 0>
static constexpr auto	min (XA &&a, XB &&b)
template<class XA , class XB , class... Xs, If< IsInvocable< Less, XA, XB > > = 0, If< All< IsInvocable< Less, ResultOf< Where, ResultOf< Less, XA, XB >, XA, XB >, Xs >... > > = 0>
static constexpr auto	min (XA &&a, XB &&b, Xs &&...args)
template<class X >
static constexpr auto	operator!= (X &&a, Zero<> const)
template<class X >
static constexpr auto	operator!= (Zero<> const, X &&b)
static constexpr auto	operator!= (Zero<> const, Zero<> const)
template<Size N>
static auto	print (String< N > const &string, std::FILE *stream)
template<class T , T... Is, class S >
static auto	print (Sequence< T, Is... > const, S &&stream)
template<Size... Ns, class S >
static auto	print (Sizes< Ns... > const, S &&stream)
template<class S >
static auto	print (Direction const direction, S &&stream)
template<class S >
static auto	print (Context const context, S &&stream)
template<class T , class D , If< IsConstructible< Random< T, D >, RandomEngine &, D & > > = 0>
static constexpr auto	random (RandomEngine &rng, D &distribution)
template<class T , If< IsDefined< Unit< T > > > = 0, If< IsConstructible< Unit< T > > > = 0, If< IsInvocable< Unit< T > > > = 0>
static constexpr auto	unit ()
static constexpr auto	unit ()
template<class T , class X , If< IsDefined< Unit< T > > > = 0, If< IsConstructible< Unit< T > > > = 0, If< IsInvocable< Unit< T >, X > > = 0>
static constexpr auto	unit (X &&value)
template<class TE , class T , If< IsBool< TE > > = 0>
static constexpr T	where (TE const e, T &&a, T &&b)
template<class TE , class T , If< IsBool< TE > > = 0>
static constexpr T const &	where (TE const e, T const &a, T &b)
template<class TE , class T , If< IsBool< TE > > = 0>
static constexpr T const &	where (TE const e, T &a, T const &b)
template<class TE , class XA , class XB , If< IsBool< TE > > = 0>
static constexpr auto	where (TE const e, XA &&a, XB &&b)
template<class T , If< IsDefined< Zero< T > > > = 0, If< IsConstructible< Zero< T > > > = 0, If< IsInvocable< Zero< T > > > = 0>
static constexpr auto	zero ()
static constexpr auto	zero ()
static constexpr auto	operator! (Position const P)
template<Context C, Size I, Size L, Direction D = Direction::Forwards, Size S = 1, class F , class... Xs>
static constexpr auto	range (F &&f, Xs &&...args)
template<Size I, Size L, Direction D = Direction::Forwards, Size S = 1, class F , class... Xs>
static constexpr auto	range (F &&f, Xs &&...args)
template<Size L, Direction D = Direction::Forwards, Size S = 1, class F , class... Xs>
static constexpr auto	range (F &&f, Xs &&...args)
template<Context C, class I , class L , Direction O, class D , class S = decltype(makeConstantSequence<Size, typename I::Dimension{}, 1>()), class F , class... Xs, If< IsSizes< I > > = 0, If< IsSizes< L > > = 0, If< IsSequence< D > > = 0, If< IsSizes< S > > = 0, If< IsSame< Direction, typename D::Type > > = 0, If< IsSame< typename I::Dimension, typename L::Dimension, typename D::Dimension, typename S::Dimension > > = 0, If< IsSatisfied<((L() - I()) % S()==Constant< Size, 0 >())> , If< IsSatisfied<(O==Direction::LeftToRight||O==Direction::RightToLeft)> > = 0>
static constexpr auto	range (F &&f, Xs &&...args)
template<Context C, class L , Direction O, class D , class S = decltype(makeConstantSequence<Size, typename L::Dimension{}, 1>()), class F , class... Xs, If< IsSizes< L > > = 0, If< IsSequence< D > > = 0, If< IsSizes< S > > = 0, If< IsSame< Direction, typename D::Type > > = 0, If< IsSame< typename L::Dimension, typename D::Dimension, typename S::Dimension > > = 0, If< IsSatisfied<(L() % S()==Constant< Size, 0 >())> , If< IsSatisfied<(O==Direction::LeftToRight||O==Direction::RightToLeft)> > = 0>
static constexpr auto	range (F &&f, Xs &&...args)
template<class I , class L , Direction O, class D , class S = decltype(makeConstantSequence<Size, typename I::Dimension{}, 1>()), class F , class... Xs, If< IsSizes< I > > = 0, If< IsSizes< L > > = 0, If< IsSequence< D > > = 0, If< IsSizes< S > > = 0, If< IsSame< Direction, typename D::Type > > = 0, If< IsSame< typename I::Dimension, typename L::Dimension, typename D::Dimension, typename S::Dimension > > = 0, If< IsSatisfied<((L() - I()) % S()==Constant< Size, 0 >())> , If< IsSatisfied<(O==Direction::LeftToRight||O==Direction::RightToLeft)> > = 0>
static constexpr auto	range (F &&f, Xs &&...args)
template<class L , Direction O, class D , class S = decltype(makeConstantSequence<Size, typename L::Dimension{}, 1>()), class F , class... Xs, If< IsSizes< L > > = 0, If< IsSequence< D > > = 0, If< IsSizes< S > > = 0, If< IsSame< Direction, typename D::Type > > = 0, If< IsSame< typename L::Dimension, typename D::Dimension, typename S::Dimension > > = 0, If< IsSatisfied<(L() % S()==Constant< Size, 0 >())> , If< IsSatisfied<(O==Direction::LeftToRight||O==Direction::RightToLeft)> > = 0>
static constexpr auto	range (F &&f, Xs &&...args)
template<class X >
	RecursiveLambda (X &&) -> RecursiveLambda< RemoveReference< X > >
template<class T , T... Seq>
	Sequence (std::integer_sequence< T, Seq... > const) -> Sequence< T, Seq... >
template<Size... Ns>
	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	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	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	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	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	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	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	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	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	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	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	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	operator% (Sequence< T, As... > const, Constant< T, B > const)
template<class T , T... Is, If< IsInvocable< Minus, T > > = 0>
static constexpr auto	operator- (Sequence< T, Is... > const)
template<class T , T... As, T... Bs>
static constexpr auto	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	operator== (Sequence< T, As... > const, Sequence< T, Bs... > const)
template<class T , T... As, T B>
static constexpr auto	operator== (Sequence< T, As... > const, Constant< T, B > const)
template<class T , T A, T... Bs>
static constexpr auto	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	operator!= (Sequence< T, As... > const, Sequence< T, Bs... > const)
template<class T , T... As, T B>
static constexpr auto	operator!= (Sequence< T, As... > const, Constant< T, B > const)
template<class T , T A, T... Bs>
static constexpr auto	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	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	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	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	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	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	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	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	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	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	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	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	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)	expand (Sequence< T, Seq... > const, F &&f, Xs &&...args)
template<class T , T N>
static constexpr auto	makeSeries ()
template<class T >
static constexpr auto	makeSeriesFor ()
template<class T , class... Ts, If< IsSatisfied<(sizeof...(Ts) > 0)> >
static constexpr auto	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	makeRange ()
template<class T , Size N, T V>
static constexpr auto	makeConstantSequence ()
template<class F , class T , T I1, T I2, T... Is, If< IsInvocable< F, T, T > > = 0>
static constexpr auto	reduce (Sequence< T, I1, I2, Is... > const)
template<class F , class T , T I>
static constexpr auto	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	permute (Sequence< T, Is... > const)
template<class T , T... Is>
static constexpr auto	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	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	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	zip (Sequence< T, Is... > const, Seqs const ...)
template<class F , class T , T... Is>
static constexpr auto	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	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	chip (Sequence< T, Is... > const)
template<class T , T... Is>
static constexpr auto	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	select (Sequence< T, Is... > const)
template<class T , T... Is>
static constexpr auto	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	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	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	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	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	getPermutation (Sequence< T, Froms... > const, Sequence< T, Tos... > const)
template<class T , T... Froms>
static constexpr auto	getPermutation (Sequence< T, Froms... > const)
template<class T , T N, T... Ps>
static constexpr auto	integerFactorization (Constant< T, N > const, Sequence< T, Ps... > const =Sequence< T >())
	String (char const &) -> String< 1 >
template<Size N>
	String (char const (&)[N]) -> String< N - 1 >
template<Size M, Size N>
static constexpr auto	operator+ (String< M > const &lhs, String< N > const &rhs)
template<Size M, Size N>
static constexpr auto	operator+ (String< M > const &lhs, char const (&rhs)[N])
template<Size M, Size N>
static constexpr auto	operator+ (char const (&lhs)[M], String< N > const &rhs)
template<class T >
static constexpr auto	name ()
template<class T , auto = sizeof(T)>
True	isDefined (T *)
template<class T , auto = sizeof(T), If< Not< IsPointer< T > > > = 0>
True	isDefined (T &&)
template<class... Xs>
static constexpr auto	forwardAsTuple (Xs &&...args)
template<class T >
AddConst< T > &	asConst (T &a)
template<class T >
AddConst< T >	asConst (T &&a)
template<class T , If< IsFloat< T > > = 0>
	Complex (T const &) -> Complex< T >
template<class TA , class TB , If< All< IsFloat< TA >, IsFloat< TB > > > = 0>
	Complex (TA const &, TB const &) -> Complex< Common< TA, TB > >
template<class T , If< IsInvocable< Norm<>, Complex< T > > > = 0>
static constexpr auto	abs (Complex< T > const &a)
template<class T >
static constexpr auto	acos (Complex< T > const &a)
template<class T >
static constexpr auto	acosh (Complex< T > const &a)
template<class TA , class TB , If< IsInvocable< Add, TA, TB > > = 0>
static constexpr auto	operator+ (Complex< TA > const &a, Complex< TB > const &b)
template<class TA , class TB , If< IsValue< TB > > = 0, If< IsInvocable< Add, TA, TB > > = 0>
static constexpr auto	operator+ (Complex< TA > const &a, TB const &b)
template<class TA , class TB , If< IsValue< TA > > = 0, If< IsInvocable< Add, TA, TB > > = 0>
static constexpr auto	operator+ (TA const &a, Complex< TB > const &b)
template<class T , If< IsInvocable< Atan2, T, T > > = 0>
static constexpr auto	arg (Complex< T > const &a)
template<class T , If< IsInvocable< Asinh, Complex< T > > > = 0>
static constexpr auto	asin (Complex< T > const &a)
template<class T >
static constexpr auto	asinh (Complex< T > const &a)
template<class T >
static constexpr auto	atan (Complex< T > const &a)
template<class T >
static constexpr auto	atanh (Complex< T > const &a)
template<class C , If< IsValue< C > > = 0, class T , If< IsInvocable< Cast< C >, T > > = 0>
static constexpr auto	cast (Complex< T > const &a)
template<class X , If< IsComplex< RemoveReference< X > > > = 0>
static constexpr X	complexify (X &&a)
template<class T >
static constexpr auto	conj (Complex< T > const &a)
template<class T >
static constexpr auto	cos (Complex< T > const &a)
template<class T >
static constexpr auto	cosh (Complex< T > const &a)
template<class TA , class TB , If< IsInvocable< Sub, TA, TB > > = 0>
static constexpr auto	delta (Complex< TA > const &a, Complex< TB > const &b)
template<class TA , class TB , If< IsValue< TB > > = 0, If< IsInvocable< Sub, TA, TB > > = 0>
static constexpr auto	delta (Complex< TA > const &a, TB const &b)
template<class TA , class TB , If< IsValue< TA > > = 0, If< IsInvocable< Sub, TA, TB > > = 0>
static constexpr auto	delta (TA const &a, Complex< TB > const &b)
template<class TA , class TB >
static constexpr auto	operator/ (Complex< TA > const &a, Complex< TB > const &b)
template<class TA , class TB , If< IsValue< TB > > = 0, If< IsInvocable< Div, TA, TB > > = 0>
static constexpr auto	operator/ (Complex< TA > const &a, TB const &b)
template<class TA , class TB , If< IsValue< TA > > = 0>
static constexpr auto	operator/ (TA const &a, Complex< TB > const &b)
template<class TA , class TB , If< IsInvocable< Equal, TA, TB > > = 0>
static constexpr auto	operator== (Complex< TA > const &a, Complex< TB > const &b)
template<class TA , class TB , If< IsValue< TB > > = 0, If< IsInvocable< Equal, TA, TB > > = 0>
static constexpr auto	operator== (Complex< TA > const &a, TB const &b)
template<class TA , class TB , If< IsValue< TA > > = 0, If< IsInvocable< Equal, TA, TB > > = 0>
static constexpr auto	operator== (TA const &a, Complex< TB > const &b)
template<class X , If< IsComplex< RemoveReference< X > > > = 0>
static constexpr X	eval (X &&a)
template<class T >
static constexpr auto	exp (Complex< T > const &a)
template<class X , If< IsComplex< RemoveReference< X > > > = 0>
static constexpr decltype(auto)	imag (X &&a)
template<class TA , class TB , If< IsInvocable< Conj, Complex< TA > > > = 0, If< IsInvocable< ScalarProduct, Complex< TA >, Complex< TB > > > = 0>
static constexpr auto	innerProduct (Complex< TA > const &a, Complex< TB > const &b)
template<class TA , class TB , If< IsValue< TB > > = 0, If< IsInvocable< Conj, Complex< TA > > > = 0, If< IsInvocable< ScalarProduct, Complex< TA >, TB > > = 0>
static constexpr auto	innerProduct (Complex< TA > const &a, TB const &b)
template<class TA , class TB , If< IsValue< TA > > = 0, If< IsInvocable< ScalarProduct, TA, Complex< TB > > > = 0>
static constexpr auto	innerProduct (TA const &a, Complex< TB > const &b)
template<class T >
static constexpr auto	log (Complex< T > const &a)
template<class T , If< IsInvocable< Log, Complex< T > > > = 0>
static constexpr auto	log10 (Complex< T > const &a)
template<class T , If< IsInvocable< Log, Complex< T > > > = 0>
static constexpr auto	log2 (Complex< T > const &a)
template<class T >
static constexpr auto	operator- (Complex< T > const &a)
template<class TA , class TB , If< IsInvocable< Mul, TA, TB > > = 0, If< IsInvocable< Add, TA, TB > > = 0, If< IsInvocable< Sub, TA, TB > > = 0>
static constexpr auto	operator* (Complex< TA > const &a, Complex< TB > const &b)
template<class TA , class TB , If< IsValue< TB > > = 0, If< IsInvocable< Mul, TA, TB > > = 0>
static constexpr auto	operator* (Complex< TA > const &a, TB const &b)
template<class TA , class TB , If< IsValue< TA > > = 0, If< IsInvocable< Mul, TA, TB > > = 0>
static constexpr auto	operator* (TA const &a, Complex< TB > const &b)
template<Index P = 2, Index Q = P, class T >
static constexpr auto	norm (Complex< T > const &a)
template<class TA , class TB , If< IsInvocable< NotEqual, TA, TB > > = 0>
static constexpr auto	operator!= (Complex< TA > const &a, Complex< TB > const &b)
template<class TA , class TB , If< IsValue< TB > > = 0, If< IsInvocable< NotEqual, TA, TB > > = 0>
static constexpr auto	operator!= (Complex< TA > const &a, TB const &b)
template<class TA , class TB , If< IsValue< TA > > = 0, If< IsInvocable< NotEqual, TA, TB > > = 0>
static constexpr auto	operator!= (TA const &a, Complex< TB > const &b)
template<class T >
static constexpr auto	operator+ (Complex< T > const &a)
template<class TA , class TB , If< All< IsValue< TA >, IsValue< TB > > > = 0, If< IsInvocable< Cos, TB > > = 0, If< IsInvocable< Sin, TB > > = 0, If< IsInvocable< Mul, TA, TB > > = 0>
static constexpr auto	polar (TA const &rho, TB const &theta)
template<class X , class Y >
static constexpr auto	pow (Complex< X > const &x, Complex< Y > const &y)
template<class X , class Y , If< IsValue< Y > > = 0>
static constexpr auto	pow (Complex< X > const &x, Y const &y)
template<class X , class Y , If< IsValue< X > > = 0>
static constexpr auto	pow (X const &x, Complex< Y > const &y)
template<class T , class S , If< IsComplex< T > > = 0>
static auto	print (T const &value, S &&stream)
template<class T >
static constexpr auto	rcp (Complex< T > const &b)
template<class X , If< IsComplex< RemoveReference< X > > > = 0>
static constexpr decltype(auto)	real (X &&a)
template<std::int64_t D = 0, class T , If< IsInvocable< Round< D >, T > > = 0>
static constexpr auto	round (Complex< T > const &a)
template<class TA , class TB , If< IsInvocable< Mul, Complex< TA >, Complex< TB > > > = 0>
static constexpr auto	scalarProduct (Complex< TA > const &a, Complex< TB > const &b)
template<class TA , class TB , If< IsValue< TB > > = 0, If< IsInvocable< Mul, Complex< TA >, TB > > = 0>
static constexpr auto	scalarProduct (Complex< TA > const &a, TB const &b)
template<class TA , class TB , If< IsValue< TA > > = 0, If< IsInvocable< Mul, TA, Complex< TB > > > = 0>
static constexpr auto	scalarProduct (TA const &a, Complex< TB > const &b)
template<class T , If< IsInvocable< Sign, T > > = 0>
static constexpr auto	sign (Complex< T > const &a)
template<class T >
static constexpr auto	sin (Complex< T > const &a)
template<class T >
static constexpr auto	sinh (Complex< T > const &a)
template<class T >
static constexpr auto	sqrt (Complex< T > const &a)
template<class T , If< IsInvocable< Mul, T, T > > = 0, If< IsInvocable< Sub, T, T > > = 0>
static constexpr auto	square (Complex< T > const &a)
template<class TA , class TB , If< IsInvocable< Sub, TA, TB > > = 0>
static constexpr auto	operator- (Complex< TA > const &a, Complex< TB > const &b)
template<class TA , class TB , If< IsValue< TB > > = 0, If< IsInvocable< Sub, TA, TB > > = 0>
static constexpr auto	operator- (Complex< TA > const &a, TB const &b)
template<class TA , class TB , If< IsValue< TA > > = 0, If< IsInvocable< Sub, TA, TB > > = 0>
static constexpr auto	operator- (TA const &a, Complex< TB > const &b)
template<class T >
static constexpr auto	tan (Complex< T > const &a)
template<class T >
static constexpr auto	tanh (Complex< T > const &a)
template<class T , If< IsInvocable< Trunc, T > > = 0>
static constexpr auto	trunc (Complex< T > const &a)
static constexpr auto	isProperAlignment (Size const alignment)
template<Size S, Size P = alignof(std::max_align_t)>
static constexpr auto	alignment ()
static auto	alloc (Size size, Size const alignment=alignof(std::max_align_t))
static auto	dealloc (void *ptr)
template<class T , Size N>
	CommonArray (T const (&)[N]) -> CommonArray< Allocation::Stack, T, N >
template<Allocation A1, Allocation A2, class TA , class TB , Size... Ns, If< IsInvocable< Equal, TA, TB > > = 0>
static constexpr auto	operator== (CommonArray< A1, TA, Ns... > const &lhs, CommonArray< A2, TB, Ns... > const &rhs)
template<Allocation A1, Allocation A2, class TA , class TB , Size... Ns>
static constexpr auto	operator!= (CommonArray< A1, TA, Ns... > const &lhs, CommonArray< A2, TB, Ns... > const &rhs)
template<class S >
static auto	print (Allocation const alloc, S &&stream)
template<Size... Ns, class S >
static auto	print (Subscripts< Ns... > const &a, S &&stream)
template<Size N, class S >
static auto	print (Indices< N > const &a, S &&stream)
template<Allocation A, class T , Size... Ns, class S >
static auto	print (CommonArray< A, T, Ns... > const &arg, S &&stream)
template<class... Is, If< All< IsConvertible< Is, Index >... > > = 0>
	Indices (Is const ...) -> Indices< sizeof...(Is)>
template<Size... Ns>
static constexpr auto	operator+ (Subscripts< Ns... > const &lhs, Subscripts< Ns... > const &rhs)
template<Size... Ns>
static constexpr auto	operator- (Subscripts< Ns... > const &lhs, Subscripts< Ns... > const &rhs)
template<Size... Ns, Size... Ss, If< IsSatisfied<(sizeof...(Ns)==sizeof...(Ss))> > = 0>
static constexpr auto	operator* (Subscripts< Ns... > const &lhs, Sizes< Ss... > const)
template<Size... Ns, Size... Ss, If< IsSatisfied<(sizeof...(Ns)==sizeof...(Ss))> > = 0>
static constexpr auto	operator* (Sizes< Ss... > const, Subscripts< Ns... > const &rhs)
template<Size... Ns, Size... Ss, If< IsSatisfied<(sizeof...(Ns)==sizeof...(Ss))> > = 0>
static constexpr auto	operator/ (Subscripts< Ns... > const &lhs, Sizes< Ss... > const)
template<Size... Ns, Size... Ss, If< IsSatisfied<(sizeof...(Ns)==sizeof...(Ss))> > = 0>
static constexpr auto	operator% (Subscripts< Ns... > const &lhs, Sizes< Ss... > const)
template<Size... Ns>
static constexpr auto	operator== (Subscripts< Ns... > const &lhs, Subscripts< Ns... > const &rhs)
template<Size... Ns>
static constexpr auto	operator!= (Subscripts< Ns... > const &lhs, Subscripts< Ns... > const &rhs)
template<Index... Ps, Size... Ns, If< IsSatisfied<(sizeof...(Ps)==sizeof...(Ns))> > = 0, If< IsSatisfied<(max(Ps...)< sizeof...(Ns))> > = 0, If< IsUnique< Constant< Index, Ps >... > > = 0>
static constexpr auto	permute (Subscripts< Ns... > const &arg)
template<Size... Ns>
static constexpr auto	reverse (Subscripts< Ns... > const &arg)
template<Direction D, Size Step, Size... Ns, If< True< decltype(rotate< D, Step >(makeSeriesFor< Index, Ns... >()))> >
static constexpr auto	rotate (Subscripts< Ns... > const &arg)
template<Index... Ds, Size... Ns, If< True< decltype(chip< Ds... >(Sequence< Index, Ns... >()))> >
static constexpr auto	chip (Subscripts< Ns... > const &arg)
template<class T >
static constexpr auto	name ()
template<class T , T V, class S >
static auto	print (Constant< T, V > const, S &&stream)
template<class T , If< IsSame< T, Bool > > = 0>
static auto	print (T const value, std::FILE *stream)
static auto	print (char const *const string, std::FILE *stream)
static auto	print (std::string const &string, std::FILE *stream)
template<class... Ps>
static constexpr auto	help (Ps &&...parameters)
template<Context C, class T , class A , class N , class D , If< True< decltype(String(declval< A >()))> , If< True< decltype(String(declval< N >()))> , If< True< decltype(String(declval< D >()))> , If< IsSatisfied<(C==Context::CompileTime||C==Context::RunTime)> > = 0>
static constexpr auto	parameter (A &&argument, N &&name, D &&description, T const &defaultValue)
template<Context C, class T , class A , class N , class D , If< True< decltype(String(declval< A >()))> , If< True< decltype(String(declval< N >()))> , If< True< decltype(String(declval< D >()))> , If< IsSatisfied<(C==Context::RunTime)> > = 0>
static constexpr auto	parameter (A &&argument, N &&name, D &&description)
template<Context C, class T , class A , class N , class D , If< True< decltype(String(declval< A >()))> , If< True< decltype(String(declval< N >()))> , If< True< decltype(String(declval< D >()))> , If< IsSatisfied<(C==Context::RunTime)> > = 0>
static constexpr auto	parameter (A &&argument, N &&name, D &&description, T(*convert)(char const *const))
template<Context C, class T , class A , class N , class D , If< True< decltype(String(declval< A >()))> , If< True< decltype(String(declval< N >()))> , If< True< decltype(String(declval< D >()))> , If< IsSatisfied<(C==Context::RunTime)> > = 0>
static constexpr auto	parameter (A &&argument, N &&name, D &&description, T(*convert)(char const *const), T const &defaultValue)
template<class N , class D , class... Ps, If< True< decltype(String(declval< N >()))> , If< True< decltype(String(declval< D >()))> >
static constexpr auto	parse (int const argc, char const *const *const argv, N &&appName, D &&appDescription, Ps &...parameters)
template<class... Ps>
static constexpr auto	report (Ps &&...parameters)
template<class T , class... Ts>
static auto	optimizationBarrier (const T &basic, Ts &...basics)
static Float< 64 >	getTimeInSeconds ()
template<class T , class RNG , If< IsRandomEngine< RNG > > = 0, If< IsFloat< T > > = 0>
static constexpr T	generateCanonical (RNG &rng)
template<class T >
constexpr auto	operator== (GaussianDistribution< T > const &lhs, GaussianDistribution< T > const &rhs)
template<class T >
constexpr auto	operator!= (GaussianDistribution< T > const &lhs, GaussianDistribution< T > const &rhs)
template<class T >
constexpr auto	operator== (LaplaceDistribution< T > const &lhs, LaplaceDistribution< T > const &rhs)
template<class T >
constexpr auto	operator!= (LaplaceDistribution< T > const &lhs, LaplaceDistribution< T > const &rhs)
template<Size N, class S >
static auto	print (SeedSequence< N > const &seq, S &&stream)
template<class... Ts>
	SeedSequence (Ts &&...) -> SeedSequence< sizeof...(Ts)>
template<class T >
constexpr auto	operator== (UniformDistribution< T > const &lhs, UniformDistribution< T > const &rhs)
template<class T >
constexpr auto	operator!= (UniformDistribution< T > const &lhs, UniformDistribution< T > const &rhs)
template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Abs >, X > > = 0>
static constexpr auto	abs (X &&a)
template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Acos >, X > > = 0>
static constexpr auto	acos (X &&a)
template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Acosh >, X > > = 0>
static constexpr auto	acosh (X &&a)
template<class XA , class XB , If< IsTensorish< RemoveReference< XA > > > = 0, If< IsTensorish< RemoveReference< XB > > > = 0, If< IsInvocable< Loop< Add >, XA, XB > > = 0>
static constexpr auto	operator+ (XA &&a, XB &&b)
template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Arg >, X > > = 0>
static constexpr auto	arg (X &&a)
template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Asin >, X > > = 0>
static constexpr auto	asin (X &&a)
template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Asinh >, X > > = 0>
static constexpr auto	asinh (X &&a)
template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Atan >, X > > = 0>
static constexpr auto	atan (X &&a)
template<class XA , class XB , If< IsTensorish< RemoveReference< XA > > > = 0, If< IsTensorish< RemoveReference< XB > > > = 0, If< IsInvocable< Loop< Atan2 >, XA, XB > > = 0>
static constexpr auto	atan2 (XA &&a, XB &&b)
template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Atanh >, X > > = 0>
static constexpr auto	atanh (X &&a)
template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< View, X > > = 0>
static constexpr auto	backwards (X &&a)
template<Size... Bs, class X , class... Os, class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< View, X > > = 0, If< All< IsConvertible< Os, Index >... > > = 0, If< IsSatisfied<(sizeof...(Bs)==typename R::Dimension())> > = 0, If< IsSatisfied<(sizeof...(Os)==typename R::Dimension())> > = 0, If< IsSatisfied<(typename R::Sizes() % Sizes< Bs... >()==Constant< Size, 0 >())> >
static constexpr auto	block (X &&a, Os const ... offsets)
template<Size... Bs, class X , class... Os, class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< Not< IsInvocable< View, X > > > = 0, If< IsInvocable< Block< Bs... >, X &, Os... > > = 0>
static constexpr auto	block (X &&a, Os const ... offsets)
template<Size... Bs, class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< View, X > > = 0, If< IsSatisfied<(sizeof...(Bs)==typename R::Dimension())> > = 0>
static constexpr auto	broadcast (X &&a)
template<class C , class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Cast< C > >, X > > = 0>
static constexpr auto	cast (X &&a)
template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Ceil >, X > > = 0>
static constexpr auto	ceil (X &&a)
template<Index... Ds, class X , class... Is, class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< View, X > > = 0, If< All< IsConvertible< Is, Index >... > > = 0, If< IsSatisfied<(sizeof...(Is)==sizeof...(Ds))> > = 0, If< True< decltype(chip< Ds... >(makeSeries< Index, typename R::Dimension{}>()))> >
static constexpr auto	chip (X &&a, Is const ... indices)
template<Index... Ds, class X , class... Is, class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< Not< IsInvocable< View, X > > > = 0, If< IsInvocable< Chip< Ds... >, X &, Is... > > = 0>
static constexpr auto	chip (X &&a, Is const ... indices)
template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Complexify >, X > > = 0>
static constexpr auto	complexify (X &&a)
template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Conj >, X > > = 0>
static constexpr auto	conj (X &&a)
template<Index... Is, class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< View, X > > = 0, If< IsSatisfied<(isEven(sizeof...(Is)))> > = 0, If< IsSatisfied<(sizeof...(Is)<=typename R::Dimension())> > = 0>
static constexpr auto	contract (X &&a)
template<Index... Is, class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< IsTensorish< RA > > = 0, If< IsInvocable< View, XA > > = 0, If< IsTensorish< RB > > = 0, If< IsInvocable< View, XB > > = 0, If< IsSatisfied<(isEven(sizeof...(Is)))> > = 0, If< IsSatisfied<(sizeof...(Is)/2<=min(typename RA::Dimension(), typename RB::Dimension()))> > = 0>
static constexpr auto	contract (XA &&a, XB &&b)
template<Index... Is, class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< Not< IsInvocable< View, X > > > = 0, If< IsInvocable< Contract< Is... >, X & > > = 0>
static constexpr auto	contract (X &&a)
template<Index... Is, class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< IsTensorish< RA > > = 0, If< IsTensorish< RB > > = 0, If< Not< All< IsInvocable< View, XA >, IsInvocable< View, XB > > > > = 0, If< IsInvocable< Contract< Is... >, XA &, XB & > > = 0>
static constexpr auto	contract (XA &&a, XB &&b)
template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Cos >, X > > = 0>
static constexpr auto	cos (X &&a)
template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Cosh >, X > > = 0>
static constexpr auto	cosh (X &&a)
template<class XA , class XB , If< IsTensorish< RemoveReference< XA > > > = 0, If< IsTensorish< RemoveReference< XB > > > = 0, If< IsInvocable< Loop< Delta >, XA, XB > > = 0>
static constexpr auto	delta (XA &&a, XB &&b)
template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< IsTensorish< RA > > = 0, If< IsInvocable< View, XA > > = 0, If< IsTensorish< RB > > = 0, If< IsInvocable< View, XB > > = 0, If< IsSame< typename RA::Dimension, typename RB::Dimension > > = 0, If< HasCommon< typename RA::Type, typename RB::Type > > = 0>
static constexpr auto	directSum (XA &&a, XB &&b)
template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< IsTensorish< RA > > = 0, If< IsTensorish< RB > > = 0, If< Not< All< IsInvocable< View, XA >, IsInvocable< View, XB > > > > = 0, If< IsInvocable< DirectSum, XA &, XB & > > = 0>
static constexpr auto	directSum (XA &&a, XB &&b)
template<class XA , class XB , If< IsTensorish< RemoveReference< XA > > > = 0, If< IsTensorish< RemoveReference< XB > > > = 0, If< IsInvocable< Loop< Div >, XA, XB > > = 0>
static constexpr auto	operator/ (XA &&a, XB &&b)
template<class XA , class XB , If< IsTensorish< RemoveReference< XA > > > = 0, If< IsTensorish< RemoveReference< XB > > > = 0, If< IsInvocable< Loop< Equal >, XA, XB > > = 0>
static constexpr auto	operator== (XA &&a, XB &&b)
template<class X , If< IsTensor< RemoveReference< X > > > = 0>
static constexpr X	eval (X &&a)
template<class X , If< IsTensorView< RemoveReference< X > > > = 0>
static constexpr auto	eval (X &&a)
template<Index... Es, class F , class... Xs, If< All< IsTensorish< RemoveReference< Xs > >... > > = 0, If< All< IsInvocable< View, Xs >... > > = 0, If< IsSame< decltype(select< Es... >(typename RemoveReference< Xs >::Sizes()))... > , If< IsInvocable< F, ResultOf< pRC::Chip< Es... >, Xs, decltype(Es)... >... > > = 0, If< True< decltype(select< Es... >(makeSeries< Index, typename RemoveReference< Xs >::Dimension{}>()))... > >
static constexpr auto	exclude (F &&f, Xs &&...args)
template<class F , Index... Es, class... Xs, If< All< IsTensorish< RemoveReference< Xs > >... > > = 0, If< All< IsInvocable< View, Xs >... > > = 0, If< IsSame< decltype(select< Es... >(typename RemoveReference< Xs >::Sizes()))... > , If< IsInvocable< F, ResultOf< pRC::Chip< Es... >, Xs, decltype(Es)... >... > > = 0, If< True< decltype(select< Es... >(makeSeries< Index, typename RemoveReference< Xs >::Dimension{}>()))... > >
static constexpr auto	exclude (Xs &&...args)
template<Index... Es, class F , class... Xs, If< All< IsTensorish< RemoveReference< Xs > >... > > = 0, If< Not< All< IsInvocable< View, Xs >... > > > = 0, If< IsInvocable< Exclude< F, Es... >, Xs &... > > = 0>
static constexpr auto	exclude (F &&f, Xs &&...args)
template<class F , Index... Es, class... Xs, If< All< IsTensorish< RemoveReference< Xs > >... > > = 0, If< Not< All< IsInvocable< View, Xs >... > > > = 0, If< IsInvocable< Exclude< F, Es... >, Xs &... > > = 0>
static constexpr auto	exclude (Xs &&...args)
template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Exp >, X > > = 0>
static constexpr auto	exp (X &&a)
template<Index K, class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< View, X > > = 0, If< IsSatisfied<(typename R::Dimension{} > 1)> , If< IsSatisfied<(K< typename R::Dimension{})> > = 0>
static constexpr auto	flatten (X &&a)
template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Floor >, X > > = 0>
static constexpr auto	floor (X &&a)
template<class XA , class XB , If< IsTensorish< RemoveReference< XA > > > = 0, If< IsTensorish< RemoveReference< XB > > > = 0, If< IsInvocable< Loop< FMod >, XA, XB > > = 0>
static constexpr auto	fmod (XA &&a, XB &&b)
template<Position P, class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsSatisfied<(typename R::Dimension{} > 1)> , If< IsSatisfied<(P==Position::Left||P==Position::Right)> > = 0, If< All< IsInvocable< Unfolding< typename R::Dimension() - 2 >, X >, IsInvocable< Unfolding< 0 >, X > > > = 0>
static constexpr auto	folding (X &&a)
template<class XA , class XB , If< IsTensorish< RemoveReference< XA > > > = 0, If< IsTensorish< RemoveReference< XB > > > = 0, If< IsInvocable< Loop< Greater >, XA, XB > > = 0>
static constexpr auto	operator> (XA &&a, XB &&b)
template<class XA , class XB , If< IsTensorish< RemoveReference< XA > > > = 0, If< IsTensorish< RemoveReference< XB > > > = 0, If< IsInvocable< Loop< GreaterEqual >, XA, XB > > = 0>
static constexpr auto	operator>= (XA &&a, XB &&b)
template<class XA , class XB , If< IsTensorish< RemoveReference< XA > > > = 0, If< IsTensorish< RemoveReference< XB > > > = 0, If< IsInvocable< Loop< Mul >, XA, XB > > = 0>
static constexpr auto	hadamardProduct (XA &&a, XB &&b)
template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Imag >, X > > = 0>
static constexpr auto	imag (X &&a)
template<Size... Is, class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< View, X > > = 0, If< IsSatisfied<(sizeof...(Is)==typename R::Dimension())> > = 0>
static constexpr auto	inflate (X &&a)
template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< IsTensorish< RA > > = 0, If< IsInvocable< View, XA > > = 0, If< IsTensorish< RB > > = 0, If< IsInvocable< Conj, XA > > = 0, If< IsInvocable< ScalarProduct, ResultOf< Conj, XA >, XB > > = 0>
static constexpr auto	innerProduct (XA &&a, XB &&b)
template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< IsTensorish< RA > > = 0, If< IsTensorish< RB > > = 0, If< Not< All< IsInvocable< View, XA >, IsInvocable< View, XB > > > > = 0, If< IsInvocable< InnerProduct, XA &, XB & > > = 0>
static constexpr auto	innerProduct (XA &&a, XB &&b)
template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< IsTensorish< RA > > = 0, If< IsInvocable< View, XA > > = 0, If< IsTensorish< RB > > = 0, If< IsInvocable< View, XB > > = 0, If< IsSame< typename RA::Dimension, typename RB::Dimension > > = 0, class EA = ResultOf<XA, typename RA::Subscripts>, class EB = ResultOf<XB, typename RB::Subscripts>, If< IsInvocable< Mul, EA, EB > > = 0>
static constexpr auto	kroneckerProduct (XA &&a, XB &&b)
template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< IsTensorish< RA > > = 0, If< IsTensorish< RB > > = 0, If< Not< All< IsInvocable< View, XA >, IsInvocable< View, XB > > > > = 0, If< IsInvocable< KroneckerProduct, XA &, XB & > > = 0>
static constexpr auto	kroneckerProduct (XA &&a, XB &&b)
template<class XA , class XB , If< IsTensorish< RemoveReference< XA > > > = 0, If< IsTensorish< RemoveReference< XB > > > = 0, If< IsInvocable< Loop< Less >, XA, XB > > = 0>
static constexpr auto	operator< (XA &&a, XB &&b)
template<class XA , class XB , If< IsTensorish< RemoveReference< XA > > > = 0, If< IsTensorish< RemoveReference< XB > > > = 0, If< IsInvocable< Loop< LessEqual >, XA, XB > > = 0>
static constexpr auto	operator<= (XA &&a, XB &&b)
template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsSatisfied<(typename R::Dimension{} > 0)> , If< IsInvocable< Reshape< R::Sizes::size()>, X > > = 0>
static constexpr auto	linearize (X &&a)
template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Log >, X > > = 0>
static constexpr auto	log (X &&a)
template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Log10 >, X > > = 0>
static constexpr auto	log10 (X &&a)
template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Log2 >, X > > = 0>
static constexpr auto	log2 (X &&a)
template<class XA , class XB , If< IsTensorish< RemoveReference< XA > > > = 0, If< IsTensorish< RemoveReference< XB > > > = 0, If< IsInvocable< Loop< LogicalAnd >, XA, XB > > = 0>
static constexpr auto	operator&& (XA &&a, XB &&b)
template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< LogicalNot >, X > > = 0>
static constexpr auto	operator! (X &&a)
template<class XA , class XB , If< IsTensorish< RemoveReference< XA > > > = 0, If< IsTensorish< RemoveReference< XB > > > = 0, If< IsInvocable< Loop< LogicalOr >, XA, XB > > = 0>
static constexpr auto	operator|| (XA &&a, XB &&b)
template<class F , class... Xs, If< All< IsTensorish< RemoveReference< Xs > >... > > = 0, If< All< IsInvocable< View, Xs >... > > = 0, If< IsSame< typename RemoveReference< Xs >::Sizes... > > = 0, If< IsInvocable< F, ResultOf< Xs, typename RemoveReference< Xs >::Subscripts >... > > = 0>
static constexpr auto	loop (F &&f, Xs &&...args)
template<class F , class... Xs, If< All< IsTensorish< RemoveReference< Xs > >... > > = 0, If< All< IsInvocable< View, Xs >... > > = 0, If< IsSame< typename RemoveReference< Xs >::Sizes... > > = 0, If< IsInvocable< F, ResultOf< Xs, typename RemoveReference< Xs >::Subscripts >... > > = 0>
static constexpr auto	loop (Xs &&...args)
template<class F , class... Xs, If< All< IsTensorish< RemoveReference< Xs > >... > > = 0, If< Not< All< IsInvocable< View, Xs >... > > > = 0, If< IsInvocable< Loop< F >, F, Xs &... > > = 0>
static constexpr auto	loop (F &&f, Xs &&...args)
template<class F , class... Xs, If< All< IsTensorish< RemoveReference< Xs > >... > > = 0, If< Not< All< IsInvocable< View, Xs >... > > > = 0, If< IsInvocable< Loop< F >, Xs &... > > = 0>
static constexpr auto	loop (Xs &&...args)
template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Minus >, X > > = 0>
static constexpr auto	operator- (X &&a)
template<class XA , class XB , If< IsTensorish< RemoveReference< XA > > > = 0, If< IsTensorish< RemoveReference< XB > > > = 0, If< IsInvocable< Loop< Mod >, XA, XB > > = 0>
static constexpr auto	operator% (XA &&a, XB &&b)
template<Index... Ns, class F , class... Xs, If< All< IsTensorish< RemoveReference< Xs > >... > > = 0, If< IsSame< decltype(chip< Ns... >(typename RemoveReference< Xs >::Sizes()))... > , If< True< decltype(chip< Ns... >(makeSeries< Index, Common< typename RemoveReference< Xs >::Dimension... >{}>()))> >
static constexpr auto	narrow (F &&f, Xs &&...args)
template<class F , Index... Ns, class... Xs, If< All< IsTensorish< RemoveReference< Xs > >... > > = 0, If< IsSame< decltype(chip< Ns... >(typename RemoveReference< Xs >::Sizes()))... > , If< True< decltype(chip< Ns... >(makeSeries< Index, Common< typename RemoveReference< Xs >::Dimension... >{}>()))> >
static constexpr auto	narrow (Xs &&...args)
template<Index P = 2, Index Q = P, class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< View, X > > = 0, If< Any< All< IsSatisfied<(P==1 &&Q==1)>, IsInvocable< Loop< Norm< 1, 1 > >, X >, IsInvocable< Reduce< Add >, ResultOf< Loop< Norm< 1, 1 > >, X > > >, All< IsSatisfied<(P==2 &&Q==1)>, IsInvocable< Loop< Norm< 2, 1 > >, X >, IsInvocable< Reduce< Add >, ResultOf< Loop< Norm< 2, 1 > >, X > > >, All< IsSatisfied<(P==2 &&Q==2)>, IsInvocable< Loop< Norm< 2, 1 > >, X >, IsInvocable< Reduce< Add >, ResultOf< Loop< Norm< 2, 1 > >, X > >, IsInvocable< Sqrt, ResultOf< Reduce< Add >, ResultOf< Loop< Norm< 2, 1 > >, X > > > >, All< IsSatisfied<(P !=Q &&Q==0)>, IsInvocable< Loop< Norm< P, P > >, X >, IsInvocable< Reduce< Max >, ResultOf< Loop< Norm< P, P > >, X > > > > > = 0>
static constexpr auto	norm (X &&a)
template<class XA , class XB , If< IsTensorish< RemoveReference< XA > > > = 0, If< IsTensorish< RemoveReference< XB > > > = 0, If< IsInvocable< Loop< NotEqual >, XA, XB > > = 0>
static constexpr auto	operator!= (XA &&a, XB &&b)
template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< IsTensorish< RA > > = 0, If< IsInvocable< View, XA > > = 0, If< IsTensorish< RB > > = 0, If< IsInvocable< View, XB > > = 0, If< IsInvocable< Conj, XA > > = 0, If< IsInvocable< TensorProduct, XA, ResultOf< Conj, XB > > > = 0>
static constexpr auto	outerProduct (XA &&a, XB &&b)
template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< IsTensorish< RA > > = 0, If< IsTensorish< RB > > = 0, If< Not< All< IsInvocable< View, XA >, IsInvocable< View, XB > > > > = 0, If< IsInvocable< OuterProduct, XA &, XB & > > = 0>
static constexpr auto	outerProduct (XA &&a, XB &&b)
template<Index... Ps, class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< View, X > > = 0, If< IsSatisfied<(sizeof...(Ps)==typename R::Dimension())> > = 0, If< IsSatisfied<(max(Ps...)< typename R::Dimension())> > = 0, If< IsUnique< Constant< Index, Ps >... > > = 0>
static constexpr auto	permute (X &&a)
template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< View, X > > = 0, If< IsSatisfied<(0==typename R::Dimension())> > = 0>
static constexpr auto	permute (X &&a)
template<Index... Ps, class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< Not< IsInvocable< View, X > > > = 0, If< IsInvocable< Permute< Ps... >, X & > > = 0>
static constexpr auto	permute (X &&a)
template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Plus >, X > > = 0>
static constexpr auto	operator+ (X &&a)
template<class XA , class XB , If< IsTensorish< RemoveReference< XA > > > = 0, If< IsTensorish< RemoveReference< XB > > > = 0, If< IsInvocable< Loop< Pow >, XA, XB > > = 0>
static constexpr auto	pow (XA &&a, XB &&b)
template<class X , class S , class R = RemoveReference<X>, If< IsTensorish< R > > = 0>
static void	print (X &&arg, S &&stream)
template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Rcp >, X > > = 0>
static constexpr auto	rcp (X &&a)
template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Real >, X > > = 0>
static constexpr auto	real (X &&a)
template<class F , Index... Is, class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< View, X > > = 0, If< IsSatisfied<(sizeof...(Is)<=typename R::Dimension())> > = 0, If< IsUnique< Constant< Index, Is >... > > = 0, If< IsSatisfied<(max(Is...)< typename R::Dimension())> > = 0, class E = ResultOf<X, typename R::Subscripts>, If< IsInvocable< F, E, E > > = 0, If< IsInvocable< F, decltype(F::template Identity< typename R::Type >()), E > >
static constexpr auto	reduce (X &&a)
template<class F , class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< View, X > > = 0, class E = ResultOf<X, typename R::Subscripts>, If< IsInvocable< F, E, E > > = 0, If< IsInvocable< F, decltype(F::template Identity< typename R::Type >()), E > >
static constexpr auto	reduce (X &&a)
template<class F , Index... Is, class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< Not< IsInvocable< View, X > > > = 0, If< IsInvocable< Reduce< F, Is... >, X & > > = 0>
static constexpr auto	reduce (X &&a)
template<Size... Ns, class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< View, X > > = 0, If< IsSatisfied<(Sizes< Ns... >::size()==R::size())> >
static constexpr auto	reshape (X &&a)
template<Bool... Rs, class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< View, X > > = 0, If< IsSatisfied<(sizeof...(Rs)==typename R::Dimension())> > = 0>
static constexpr auto	reverse (X &&a)
template<Direction D, Size S = 1, class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsSatisfied<(D==Direction::Leftwards||D==Direction::Rightwards)> > = 0>
static constexpr auto	rotate (X &&a)
template<std::int64_t D = 0, class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Round< D > >, X > > = 0>
static constexpr auto	round (X &&a)
template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsSatisfied<(R::Sizes::size()==1)> > = 0, If< IsInvocable< Reshape<>, X > > = 0>
static constexpr auto	scalar (X &&a)
template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< IsTensorish< RA > > = 0, If< IsInvocable< View, XA > > = 0, If< IsTensorish< RB > > = 0, If< IsInvocable< View, XB > > = 0, If< IsSame< typename RA::Sizes, typename RB::Sizes > > = 0, If< IsInvocable< HadamardProduct, XA, XB > > = 0, If< IsInvocable< Reduce< Add >, ResultOf< HadamardProduct, XA, XB > > > = 0>
static constexpr auto	scalarProduct (XA &&a, XB &&b)
template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< IsTensorish< RA > > = 0, If< IsTensorish< RB > > = 0, If< Not< All< IsInvocable< View, XA >, IsInvocable< View, XB > > > > = 0, If< IsInvocable< ScalarProduct, XA &, XB & > > = 0>
static constexpr auto	scalarProduct (XA &&a, XB &&b)
template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< IsTensorish< RA > > = 0, If< IsTensorish< RB > > = 0, class DA = typename RA::Dimension, class DB = typename RB::Dimension, If< IsSatisfied<(DA()==0||DB()==0)> > = 0, If< IsInvocable< TensorProduct, XA, XB > > = 0>
static constexpr auto	operator* (XA &&a, XB &&b)
template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< IsTensorish< RA > > = 0, If< IsTensorish< RB > > = 0, class DA = typename RA::Dimension, class DB = typename RB::Dimension, If< IsSatisfied<(DA()==0 &&DB() !=0)> > = 0, If< IsInvocable< Div, decltype(unit< typename RB::template ChangeType< typename RA::Type > >(declval< XA >()())), XB > >
static constexpr auto	operator/ (XA &&a, XB &&b)
template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< IsTensorish< RA > > = 0, If< Any< IsValue< RB >, IsComplex< RB > > > = 0, If< IsInvocable< Mul, XA, decltype(unit< Tensor< RB > >(declval< XB >()))> >
static constexpr auto	operator* (XA &&a, XB &&b)
template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< IsTensorish< RA > > = 0, If< Any< IsValue< RB >, IsComplex< RB > > > = 0, If< IsInvocable< Div, XA, decltype(unit< Tensor< RB > >(declval< XB >()))> >
static constexpr auto	operator/ (XA &&a, XB &&b)
template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Sign >, X > > = 0>
static constexpr auto	sign (X &&a)
template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Sin >, X > > = 0>
static constexpr auto	sin (X &&a)
template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Sinh >, X > > = 0>
static constexpr auto	sinh (X &&a)
template<Size... Es, class X , class... Os, class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< View, X > > = 0, If< All< IsConvertible< Os, Index >... > > = 0, If< IsSatisfied<(sizeof...(Es)==typename R::Dimension())> > = 0, If< IsSatisfied<(sizeof...(Os)==typename R::Dimension())> > = 0, If< IsSatisfied<(Sizes< Es... >()<=typename R::Sizes())> >
static constexpr auto	slice (X &&a, Os const ... offsets)
template<Size... Es, class X , class... Os, class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< Not< IsInvocable< View, X > > > = 0, If< IsInvocable< Slice< Es... >, X &, Os... > > = 0>
static constexpr auto	slice (X &&a, Os const ... offsets)
template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Sqrt >, X > > = 0>
static constexpr auto	sqrt (X &&a)
template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Square >, X > > = 0>
static constexpr auto	square (X &&a)
template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0>
static constexpr auto	squeeze (X &&a)
template<Size... Ss, class X , class... Os, class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< View, X > > = 0, If< All< IsConvertible< Os, Index >... > > = 0, If< IsSatisfied<(sizeof...(Ss)==typename R::Dimension())> > = 0, If< IsSatisfied<(sizeof...(Os)==typename R::Dimension())> > = 0, If< IsSatisfied<(typename R::Sizes() % Sizes< Ss... >()==Constant< Size, 0 >())> >
static constexpr auto	stride (X &&a, Os const ... offsets)
template<Size... Ss, class X , class... Os, class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< Not< IsInvocable< View, X > > > = 0, If< IsInvocable< Stride< Ss... >, X &, Os... > > = 0>
static constexpr auto	stride (X &&a, Os const ... offsets)
template<class XA , class XB , If< IsTensorish< RemoveReference< XA > > > = 0, If< IsTensorish< RemoveReference< XB > > > = 0, If< IsInvocable< Loop< Sub >, XA, XB > > = 0>
static constexpr auto	operator- (XA &&a, XB &&b)
template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< IsTensorish< RA > > = 0, If< IsInvocable< View, XA > > = 0, If< IsTensorish< RB > > = 0, If< IsInvocable< View, XB > > = 0, If< IsSame< typename RA::Sizes, typename RB::Sizes > > = 0, class EA = ResultOf<XA, typename RA::Subscripts>, class EB = ResultOf<XB, typename RB::Subscripts>, If< IsInvocable< Swap, EA, EB > > = 0>
static constexpr auto	swap (XA &&a, XB &&b)
template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Tan >, X > > = 0>
static constexpr auto	tan (X &&a)
template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Tanh >, X > > = 0>
static constexpr auto	tanh (X &&a)
template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< IsTensorish< RA > > = 0, If< IsInvocable< View, XA > > = 0, If< IsTensorish< RB > > = 0, If< IsInvocable< View, XB > > = 0, class EA = ResultOf<XA, typename RA::Subscripts>, class EB = ResultOf<XB, typename RB::Subscripts>, If< IsInvocable< Mul, EA, EB > > = 0>
static constexpr auto	tensorProduct (XA &&a, XB &&b)
template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< IsTensorish< RA > > = 0, If< IsTensorish< RB > > = 0, If< Not< All< IsInvocable< View, XA >, IsInvocable< View, XB > > > > = 0, If< IsInvocable< TensorProduct, XA &, XB & > > = 0>
static constexpr auto	tensorProduct (XA &&a, XB &&b)
template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Trunc >, X > > = 0>
static constexpr auto	trunc (X &&a)
template<Index K, class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsSatisfied<(typename R::Dimension{} > 1)> , If< IsSatisfied<(K+1< typename R::Dimension{})> > = 0, If< IsInvocable< Reshape< R::size(K), R::Sizes::size()/R::size(K)>, X > > = 0>
static constexpr auto	unfolding (X &&a)
template<class X , If< IsTensorView< RemoveReference< X > > > = 0>
static constexpr X	view (X &&a)
template<class T , Size... Ns>
static constexpr auto	view (Tensor< T, Ns... > const &a)
template<class T , Size... Ns>
static constexpr auto	view (Tensor< T, Ns... > &a)
template<class T , Size... Ns>
static constexpr auto	view (Tensor< T, Ns... > const &&)=delete
template<class XE , class XA , class XB , If< IsTensorish< RemoveReference< XE > > > = 0, If< IsTensorish< RemoveReference< XA > > > = 0, If< IsTensorish< RemoveReference< XB > > > = 0, If< IsInvocable< Loop< Where >, XE, XA, XB > > = 0>
static constexpr auto	where (XE &&e, XA &&a, XB &&b)
template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< View, X > > = 0, If< IsInvocable< Transpose, X > > = 0, If< IsInvocable< Conj, ResultOf< Transpose, X > > > = 0>
static constexpr auto	adjoint (X &&a)
template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< Not< IsInvocable< View, X > > > = 0, If< IsInvocable< Adjoint, X & > > = 0>
static constexpr auto	adjoint (X &&a)
template<Operator::Transform OT = Operator::Transform::None, Operator::Restrict OR = Operator::Restrict::None, Operator::Hint OH = Operator::Hint::None, class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< IsTensorish< RA > > = 0, If< IsInvocable< View, XA > > = 0, If< IsTensorish< RB > > = 0, If< IsInvocable< View, XB > > = 0, class DA = typename RA::Dimension, class DB = typename RB::Dimension, If< IsSatisfied<(isEven(DA()) &&(DA()/2==DB()||DA()==DB()))> > = 0, If< IsInvocable< Transform< OT >, XA > > = 0, If< IsInvocable< Mul, ResultOf< Restrict< OR >, ResultOf< Transform< OT >, XA > >, XB > > = 0>
static constexpr auto	apply (XA &&a, XB &&b)
template<Operator::Transform OT = Operator::Transform::None, Operator::Restrict OR = Operator::Restrict::None, Operator::Hint OH = Operator::Hint::None, class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< IsTensorish< RA > > = 0, If< IsTensorish< RB > > = 0, If< Not< All< IsInvocable< View, XA >, IsInvocable< View, XB > > > > = 0, If< IsInvocable< Apply< OT, OR, OH >, XA &, XB & > > = 0>
static constexpr auto	apply (XA &&a, XB &&b)
template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< View, X > > = 0, If< IsSatisfied<(isEven(typename R::Dimension()))> > = 0>
static constexpr auto	diagonal (X &&a)
template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< View, X > > = 0, If< IsSatisfied<(isEven(typename R::Dimension()))> > = 0>
static constexpr auto	extractDiagonal (X &&a)
template<Size... Ds, class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< View, X > > = 0, If< IsSatisfied<(isEven(sizeof...(Ds)))> > = 0, If< IsSatisfied<(sizeof...(Ds)/2==typename R::Dimension())> > = 0, If< IsSatisfied<(cut< 2, 0 >(Sizes< Ds... >()) >=typename R::Sizes())> , If< IsSatisfied<(cut< 2, 1 >(Sizes< Ds... >()) >=typename R::Sizes())> >
static constexpr auto	fromDiagonal (X &&a)
template<Size... Ds, class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< Not< IsInvocable< View, X > > > = 0, If< IsInvocable< FromDiagonal< Ds... >, X & > > = 0>
static constexpr auto	fromDiagonal (X &&a)
template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0>
static constexpr auto	fromDiagonal (X &&a)
template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< Diagonal, X > > = 0, If< IsInvocable< IsApprox, ResultOf< Diagonal, X >, X > > = 0, class TT = typename R::Value>
static constexpr auto	isDiagonal (X &&a, TT const &tolerance=NumericLimits< TT >::tolerance())
template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< LowerTriangular, X > > = 0, If< IsInvocable< IsApprox, ResultOf< LowerTriangular, X >, X > > = 0, class TT = typename R::Value>
static constexpr auto	isLowerTriangular (X &&a, TT const &tolerance=NumericLimits< TT >::tolerance())
template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< OffDiagonal, X > > = 0, If< IsInvocable< IsApprox, ResultOf< OffDiagonal, X >, X > > = 0, class TT = typename R::Value>
static constexpr auto	isOffDiagonal (X &&a, TT const &tolerance=NumericLimits< TT >::tolerance())
template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< Adjoint, X > > = 0, If< IsInvocable< IsApprox, ResultOf< Adjoint, X >, X > > = 0, class TT = typename R::Value>
static constexpr auto	isSelfAdjoint (X &&a, TT const &tolerance=NumericLimits< TT >::tolerance())
template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< StrictlyLowerTriangular, X > > = 0, If< IsInvocable< IsApprox, ResultOf< StrictlyLowerTriangular, X >, X > > = 0, class TT = typename R::Value>
static constexpr auto	isStrictlyLowerTriangular (X &&a, TT const &tolerance=NumericLimits< TT >::tolerance())
template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< StrictlyUpperTriangular, X > > = 0, If< IsInvocable< IsApprox, ResultOf< StrictlyUpperTriangular, X >, X > > = 0, class TT = typename R::Value>
static constexpr auto	isStrictlyUpperTriangular (X &&a, TT const &tolerance=NumericLimits< TT >::tolerance())
template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< Transpose, X > > = 0, If< IsInvocable< IsApprox, ResultOf< Transpose, X >, X > > = 0, class TT = typename R::Value>
static constexpr auto	isSymmetric (X &&a, TT const &tolerance=NumericLimits< TT >::tolerance())
template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< UnitLowerTriangular, X > > = 0, If< IsInvocable< IsApprox, ResultOf< UnitLowerTriangular, X >, X > > = 0, class TT = typename R::Value>
static constexpr auto	isUnitLowerTriangular (X &&a, TT const &tolerance=NumericLimits< TT >::tolerance())
template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< UnitUpperTriangular, X > > = 0, If< IsInvocable< IsApprox, ResultOf< UnitUpperTriangular, X >, X > > = 0, class TT = typename R::Value>
static constexpr auto	isUnitUpperTriangular (X &&a, TT const &tolerance=NumericLimits< TT >::tolerance())
template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< Adjoint, X > > = 0, If< IsInvocable< IsApprox, ResultOf< Mul, ResultOf< Adjoint, X >, X >, ResultOf< Mul, ResultOf< Adjoint, X >, X > > > = 0, class TT = typename R::Value>
static constexpr auto	isUnitary (X &&a, TT const &tolerance=NumericLimits< TT >::tolerance())
template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< UpperTriangular, X > > = 0, If< IsInvocable< IsApprox, ResultOf< UpperTriangular, X >, X > > = 0, class TT = typename R::Value>
static constexpr auto	isUpperTriangular (X &&a, TT const &tolerance=NumericLimits< TT >::tolerance())
template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< View, X > > = 0, If< IsSatisfied<(typename R::Dimension()==2)> > = 0>
static constexpr auto	lowerTriangular (X &&a)
template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsSatisfied<(typename R::Dimension{} > 0)> , If< IsSatisfied<(isEven(typename R::Dimension()))> > = 0>
static constexpr auto	matricize (X &&a)
template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< IsTensorish< RA > > = 0, If< IsTensorish< RB > > = 0, class DA = typename RA::Dimension, class DB = typename RB::Dimension, class SA = typename RA::Sizes, class SB = typename RB::Sizes, If< IsSatisfied<(isEven(DA()) &&DA()/2==DB())> > = 0, If< IsSame< decltype(cut< 2, 1 >(SA())), SB > , If< IsInvocable< Contract< DB{}, 0 >, XA, XB > > = 0>
static constexpr auto	operator* (XA &&a, XB &&b)
template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< View, X > > = 0, If< IsSatisfied<(typename R::Dimension()==2)> > = 0>
static constexpr auto	offDiagonal (X &&a)
template<Operator::Restrict OR = Operator::Restrict::None, class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0>
static constexpr decltype(auto)	restrict (X &&a)
template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< View, X > > = 0, If< IsSatisfied<(typename R::Dimension()==2)> > = 0>
static constexpr auto	strictlyLowerTriangular (X &&a)
template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< View, X > > = 0, If< IsSatisfied<(typename R::Dimension()==2)> > = 0>
static constexpr auto	strictlyUpperTriangular (X &&a)
template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< View, X > > = 0, If< IsInvocable< ExtractDiagonal, X > > = 0, If< IsInvocable< Reduce< Add >, ResultOf< ExtractDiagonal, X > > > = 0>
static constexpr auto	trace (X &&a)
template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< Not< IsInvocable< View, X > > > = 0, If< IsInvocable< Trace, X & > > = 0>
static constexpr auto	trace (X &&a)
template<Operator::Transform OT = Operator::Transform::None, class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0>
static constexpr decltype(auto)	transform (X &&a)
template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsSatisfied<(isEven(typename R::Dimension()))> > = 0>
static constexpr auto	transpose (X &&a)
template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< View, X > > = 0, If< IsSatisfied<(typename R::Dimension()==2)> > = 0>
static constexpr auto	unitLowerTriangular (X &&a)
template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< View, X > > = 0, If< IsSatisfied<(typename R::Dimension()==2)> > = 0>
static constexpr auto	unitUpperTriangular (X &&a)
template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< View, X > > = 0, If< IsSatisfied<(typename R::Dimension()==2)> > = 0>
static constexpr auto	upperTriangular (X &&a)
template<class F , class T , Size... Ns>
	Tensor (TensorViews::View< T, Sizes< Ns... >, F > const &) -> Tensor< T, Ns... >
template<class X , class T , class N , class F >
static constexpr auto	isTensorView (TensorViews::View< T, N, F > const &&)
template<class >
static constexpr auto	isTensorView (...)
static constexpr auto	isnan (BFloat16 const a)
	Float (Float< 16 >::Fundamental const) -> Float< 16 >
	Float (Float< 32 >::Fundamental const) -> Float< 32 >
	Float (Float< 64 >::Fundamental const) -> Float< 64 >
template<class T , If< IsValue< T > > = 0, If< IsSatisfied<(typename T::Signed()==true)> > = 0>
static constexpr auto	abs (T const &a)
template<class XA , class XB , If< IsInvocable< Sub, XA, XB > > = 0, If< IsInvocable< Norm<>, ResultOf< Sub, XA, XB > > > = 0, If< IsInvocable< Eval, ResultOf< Norm<>, ResultOf< Sub, XA, XB > > > > = 0>
static constexpr auto	absoluteError (XA &&a, XB &&b)
template<class T , If< IsFloat< T > > = 0>
static constexpr auto	acos (T const &a)
template<class T , If< IsFloat< T > > = 0>
static constexpr auto	acosh (T const a)
template<class TA , class TB , If< IsFloat< TA > > = 0, If< IsFloat< TB > > = 0>
static constexpr auto	operator+ (TA const &a, TB const &b)
template<class T , If< IsFloat< T > > = 0>
static constexpr auto	arg (T const &a)
template<class T , If< IsFloat< T > > = 0>
static constexpr auto	asin (T const &a)
template<class T , If< IsFloat< T > > = 0>
static constexpr auto	asinh (T const &a)
template<class T , If< IsFloat< T > > = 0>
static constexpr auto	atan (T const &a)
template<class Y , class X , If< IsFloat< Y > > = 0, If< IsFloat< X > > = 0>
static constexpr auto	atan2 (Y const &y, X const &x)
template<class T , If< IsFloat< T > > = 0>
static constexpr auto	atanh (T const &a)
template<class C , If< IsValue< C > > = 0, class T , If< IsValue< T > > = 0, If< IsConstructible< C, typename T::Fundamental > > = 0>
static constexpr auto	cast (T const &a)
template<class T , If< IsFloat< T > > = 0>
static constexpr auto	ceil (T const a)
template<class T , If< IsValue< T > > = 0, If< IsConstructible< Complex< T >, T > > = 0>
static constexpr auto	complexify (T const &a)
template<class T , If< IsValue< T > > = 0>
static constexpr auto	conj (T const &a)
template<class T , If< IsFloat< T > > = 0>
static constexpr auto	cos (T const a)
template<class T , If< IsFloat< T > > = 0>
static constexpr auto	cosh (T const &a)
template<class TA , class TB , If< IsValue< TA > > = 0, If< IsValue< TB > > = 0, If< None< IsUnsignedInteger< TA >, IsUnsignedInteger< TB > > > = 0>
static constexpr auto	delta (TA const &a, TB const &b)
template<class TA , class TB , If< IsFloat< TA > > = 0, If< IsFloat< TB > > = 0>
static constexpr auto	operator/ (TA const &a, TB const &b)
template<class TA , class TB , If< IsValue< TA > > = 0, If< IsValue< TB > > = 0, If< Any< IsFloat< TA >, IsFloat< TB > > > = 0>
static constexpr auto	operator== (TA const &a, TB const &b)
template<class TA , class TB , If< IsInteger< TA > > = 0, If< IsInteger< TB > > = 0>
static constexpr auto	operator== (TA const &a, TB const &b)
template<class X , If< IsBool< RemoveReference< X > > > = 0>
static constexpr X	eval (X &&a)
template<class T , If< IsFloat< T > > = 0>
static constexpr auto	exp (T const &a)
template<class T , If< IsFloat< T > > = 0>
static constexpr auto	floor (T const &a)
template<class TA , class TB , If< IsFloat< TA > > = 0, If< IsFloat< TB > > = 0>
static constexpr auto	fmod (TA const &a, TB const &b)
template<class F , Bool E = false, Direction D = Direction::Forwards, If< IsSatisfied<(D==Direction::Forwards||D==Direction::Backwards)> > = 0, class XA , If< IsInvocable< F, XA, XA > > = 0>
static constexpr Conditional< IsSatisfied< E >, decltype(eval(declval< XA >())), XA >	fold (XA &&a)
template<class F , Bool E = false, Direction D = Direction::Forwards, If< IsSatisfied<(D==Direction::Forwards||D==Direction::Backwards)> > = 0, class XA , class XB , If< IsInvocable< F, XA, XB > > = 0>
static constexpr auto	fold (XA &&a, XB &&b)
template<class F , Bool E = false, Direction D = Direction::Forwards, class XA , class XB , class... Xs, If< IsSatisfied<(sizeof...(Xs) > 0)> , If< IsSatisfied<(D==Direction::Forwards||D==Direction::Backwards)> > = 0, If< IsInvocable< F, XA, XB > > = 0, If< IsInvocable< Fold< F, E, D >, ResultOf< Fold< F, E, D >, XA, XB > const &, Xs... > > = 0>
static constexpr auto	fold (XA &&a, XB &&b, Xs &&...args)
template<class TA , class TB , If< IsValue< TA > > = 0, If< IsValue< TB > > = 0>
static constexpr auto	operator> (TA const &a, TB const &b)
template<class TA , class TB , If< IsValue< TA > > = 0, If< IsValue< TB > > = 0>
static constexpr auto	operator>= (TA const &a, TB const &b)
template<class T , If< IsValue< T > > = 0>
static constexpr auto	imag (T const)
template<class TA , class TB , If< IsValue< TA > > = 0, If< IsValue< TB > > = 0>
static constexpr auto	innerProduct (TA const &a, TB const &b)
template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, class TT = Common<typename RA::Value, typename RB::Value>, class T = Common<typename RA::Value, typename RB::Value, TT>, If< IsValue< TT > > = 0, If< IsInvocable< AbsoluteError, XA, XB > > = 0, If< IsInvocable< Norm<>, XA > > = 0, If< IsInvocable< Norm<>, XB > > = 0, If< IsConstructible< T, ResultOf< AbsoluteError, XA, XB > > > = 0, If< IsConstructible< T, ResultOf< Norm<>, XA > > > = 0, If< IsConstructible< T, ResultOf< Norm<>, XB > > > = 0>
static constexpr auto	isApprox (XA &&a, XB &&b, TT const &tolerance=NumericLimits< TT >::tolerance())
template<class T , If< IsFloat< T > > = 0>
static constexpr auto	isFinite (T const &a)
template<class X , class R = RemoveReference<X>, class TT = typename R::Value, If< IsValue< TT > > = 0, If< IsDefined< Identity< R > > > = 0, If< IsInvocable< Identity< R > > > = 0, If< IsInvocable< AbsoluteError, X, R > > = 0>
static constexpr auto	isIdentity (X &&a, TT const &tolerance=NumericLimits< TT >::tolerance())
template<class T , If< IsFloat< T > > = 0>
static constexpr auto	isNaN (T const &a)
template<class X , class R = RemoveReference<X>, class TT = typename R::Value, If< IsValue< TT > > = 0, If< IsDefined< Unit< R > > > = 0, If< IsInvocable< Unit< R > > > = 0, If< IsInvocable< AbsoluteError, X, R > > = 0>
static constexpr auto	isUnit (X &&a, TT const &tolerance=NumericLimits< TT >::tolerance())
template<class X , class R = RemoveReference<X>, class TT = typename R::Value, If< IsValue< TT > > = 0, If< IsDefined< Zero< R > > > = 0, If< IsInvocable< Zero< R > > > = 0, If< IsInvocable< AbsoluteError, X, R > > = 0>
static constexpr auto	isZero (X &&a, TT const &tolerance=NumericLimits< TT >::tolerance())
template<class TA , class TB , If< IsValue< TA > > = 0, If< IsValue< TB > > = 0, If< Any< IsFloat< TA >, IsFloat< TB > > > = 0>
static constexpr auto	operator< (TA const &a, TB const &b)
template<class TA , class TB , If< IsInteger< TA > > = 0, If< IsInteger< TB > > = 0>
static constexpr auto	operator< (TA const &a, TB const &b)
template<class TA , class TB , If< IsValue< TA > > = 0, If< IsValue< TB > > = 0>
static constexpr auto	operator<= (TA const &a, TB const &b)
template<class T , If< IsFloat< T > > = 0>
static constexpr auto	log (T const &a)
template<class T , If< IsFloat< T > > = 0>
static constexpr auto	log10 (T const &a)
template<class T , If< IsFloat< T > > = 0>
static constexpr auto	log2 (T const &a)
template<class... Xs, If< IsInvocable< Fold< Add >, Xs... > > = 0>
static constexpr auto	mean (Xs &&...args)
template<class T , If< IsValue< T > > = 0>
static constexpr auto	operator- (T const &a)
template<class TA , class TB , If< IsInteger< TA > > = 0, If< IsInteger< TB > > = 0>
static constexpr auto	operator% (TA const &a, TB const &b)
template<class TA , class TB , If< IsFloat< TA > > = 0, If< IsFloat< TB > > = 0>
static constexpr auto	operator* (TA const &a, TB const &b)
template<Index P = 2, Index Q = P, class T , If< IsValue< T > > = 0>
static constexpr auto	norm (T const &a)
template<class TA , class TB , If< IsValue< TA > > = 0, If< IsValue< TB > > = 0>
static constexpr auto	operator!= (TA const &a, TB const &b)
template<class T , If< IsFloat< T > > = 0>
static constexpr T	pi ()
template<class T , If< IsInteger< T > > = 0>
static constexpr auto	pi ()
template<class T , If< IsValue< T > > = 0>
static constexpr auto	operator+ (T const &a)
template<class B , class N , If< IsFloat< B > > = 0, If< IsFloat< N > > = 0>
static constexpr auto	pow (B const &base, N const &exp)
template<class T , If< IsFloat< T > > = 0>
static auto	print (T const &value, std::FILE *stream)
template<class T , If< IsValue< T > > = 0>
static constexpr auto	rcp (T const &a)
template<class X , If< IsValue< RemoveReference< X > > > = 0>
static constexpr X	real (X &&a)
template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< IsFloat< typename RA::Value > > = 0, If< IsFloat< typename RB::Value > > = 0, If< IsInvocable< AbsoluteError, XA, XB > > = 0, If< IsInvocable< Norm<>, XA > > = 0, If< IsInvocable< Div, ResultOf< AbsoluteError, XA, XB >, ResultOf< Norm<>, XA > > > = 0>
static constexpr auto	relativeError (XA &&a, XB &&b)
template<std::int64_t D = 0, class T , If< IsFloat< T > > = 0>
static constexpr auto	round (T const &a)
template<class TA , class TB , If< IsValue< TA > > = 0, If< IsValue< TB > > = 0>
static constexpr auto	scalarProduct (TA const &a, TB const &b)
template<class T , If< IsValue< T > > = 0, If< IsSatisfied<(typename T::Signed()==true)> > = 0>
static constexpr auto	sign (T const &a)
template<class T , If< IsFloat< T > > = 0>
static constexpr auto	sin (T const a)
template<class T , If< IsFloat< T > > = 0>
static constexpr auto	sinh (T const a)
template<class T , If< IsFloat< T > > = 0>
static constexpr auto	sqrt (T const &a)
template<class T , If< IsValue< T > > = 0>
static constexpr auto	square (T const &a)
template<class TA , class TB , If< IsFloat< TA > > = 0, If< IsFloat< TB > > = 0>
static constexpr auto	operator- (TA const &a, TB const &b)
template<class T , If< IsFloat< T > > = 0>
static constexpr auto	tan (T const a)
template<class T , If< IsFloat< T > > = 0>
static constexpr auto	tanh (T const a)
template<class T , If< IsFloat< T > > = 0>
static constexpr auto	trunc (T const &a)
	Integer (Integer< true, 8 >::Fundamental const) -> Integer< true, 8 >
	Integer (Integer< true, 16 >::Fundamental const) -> Integer< true, 16 >
	Integer (Integer< true, 32 >::Fundamental const) -> Integer< true, 32 >
	Integer (Integer< true, 64 >::Fundamental const) -> Integer< true, 64 >
	Integer (Integer< false, 8 >::Fundamental const) -> Integer< false, 8 >
	Integer (Integer< false, 16 >::Fundamental const) -> Integer< false, 16 >
	Integer (Integer< false, 32 >::Fundamental const) -> Integer< false, 32 >
	Integer (Integer< false, 64 >::Fundamental const) -> Integer< false, 64 >
template<Position P, class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsFloat< typename R::Value > > = 0, If< IsSatisfied<(P==Position::Left||P==Position::Right)> > = 0>
static constexpr auto	orthogonalize (X &&a)
template<Size C, Position P, class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, class V = typename R::Value, class VT = V, If< All< IsFloat< V >, IsFloat< VT > > > = 0, If< IsSatisfied<(P==Position::Left||P==Position::Right)> > = 0>
static constexpr auto	truncate (X &&a, VT const &tolerance=NumericLimits< VT >::epsilon())
template<class X , class R = RemoveReference<X>, If< Any< TensorTrain::IsTensorish< R >, TensorTrain::IsOperatorish< R > > > = 0, If< IsInvocable< Loop< Conj >, X > > = 0>
static constexpr auto	conj (X &&a)
template<class F , class... Xs, If< All< Any< TensorTrain::IsTensorish< RemoveReference< Xs > >, TensorTrain::IsOperatorish< RemoveReference< Xs > > >... > > = 0, If< All< IsInvocable< View, Xs >... > > = 0, If< IsSame< typename RemoveReference< Xs >::Dimension... > > = 0, If< True< decltype(declval< F >().template operator()<0 >(declval< Xs >().template core< 0 >()...))> >
static constexpr auto	enumerate (F &&f, Xs &&...args)
template<class F , class... Xs, If< All< Any< TensorTrain::IsTensorish< RemoveReference< Xs > >, TensorTrain::IsOperatorish< RemoveReference< Xs > > >... > > = 0, If< All< IsInvocable< View, Xs >... > > = 0, If< IsSame< typename RemoveReference< Xs >::Dimension... > > = 0, If< True< decltype(declval< F >().template operator()<0 >(declval< Xs >().template core< 0 >()...))> >
static constexpr auto	enumerate (Xs &&...args)
template<class F , class... Xs, If< All< Any< TensorTrain::IsTensorish< RemoveReference< Xs > >, TensorTrain::IsOperatorish< RemoveReference< Xs > > >... > > = 0, If< Not< All< IsInvocable< View, Xs >... > > > = 0, If< IsInvocable< Enumerate< F >, F, Xs &... > > = 0>
static constexpr auto	enumerate (F &&f, Xs &&...args)
template<class F , class... Xs, If< All< Any< TensorTrain::IsTensorish< RemoveReference< Xs > >, TensorTrain::IsOperatorish< RemoveReference< Xs > > >... > > = 0, If< Not< All< IsInvocable< View, Xs >... > > > = 0, If< IsInvocable< Enumerate< F >, Xs &... > > = 0>
static constexpr auto	enumerate (Xs &&...args)
template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< Any< All< TensorTrain::IsTensorish< RA >, TensorTrain::IsTensorish< RB > >, All< TensorTrain::IsOperatorish< RA >, TensorTrain::IsOperatorish< RB > > > > = 0, If< IsInvocable< Conj, XA > > = 0, If< IsInvocable< ScalarProduct, ResultOf< Conj, XA >, XB > > = 0>
static constexpr auto	innerProduct (XA &&a, XB &&b)
template<class F , class... Xs, If< All< Any< TensorTrain::IsTensorish< RemoveReference< Xs > >, TensorTrain::IsOperatorish< RemoveReference< Xs > > >... > > = 0, If< All< IsInvocable< View, Xs >... > > = 0, If< IsSame< typename RemoveReference< Xs >::Dimension... > > = 0, If< IsInvocable< F, decltype(declval< Xs >().template core< 0 >())... > >
static constexpr auto	loop (F &&f, Xs &&...args)
template<class F , class... Xs, If< All< Any< TensorTrain::IsTensorish< RemoveReference< Xs > >, TensorTrain::IsOperatorish< RemoveReference< Xs > > >... > > = 0, If< All< IsInvocable< View, Xs >... > > = 0, If< IsSame< typename RemoveReference< Xs >::Dimension... > > = 0, If< IsInvocable< F, decltype(declval< Xs >().template core< 0 >())... > >
static constexpr auto	loop (Xs &&...args)
template<class F , class... Xs, If< All< Any< TensorTrain::IsTensorish< RemoveReference< Xs > >, TensorTrain::IsOperatorish< RemoveReference< Xs > > >... > > = 0, If< Not< All< IsInvocable< View, Xs >... > > > = 0, If< IsInvocable< Loop< F >, F, Xs &... > > = 0>
static constexpr auto	loop (F &&f, Xs &&...args)
template<class F , class... Xs, If< All< Any< TensorTrain::IsTensorish< RemoveReference< Xs > >, TensorTrain::IsOperatorish< RemoveReference< Xs > > >... > > = 0, If< Not< All< IsInvocable< View, Xs >... > > > = 0, If< IsInvocable< Loop< F >, Xs &... > > = 0>
static constexpr auto	loop (Xs &&...args)
template<class X , class R = RemoveReference<X>, If< Any< TensorTrain::IsTensorish< R >, TensorTrain::IsOperatorish< R > > > = 0>
static constexpr auto	operator- (X &&a)
template<Index P = 2, Index Q = P, class X , class R = RemoveReference<X>, If< Any< TensorTrain::IsTensorish< R >, TensorTrain::IsOperatorish< R > > > = 0, If< IsSatisfied<(P==2 &&Q==2)> > = 0>
static constexpr auto	norm (X &&a)
template<class X , class R = RemoveReference<X>, If< Any< TensorTrain::IsTensorish< R >, TensorTrain::IsOperatorish< R > > > = 0, If< IsInvocable< Loop< Plus >, X > > = 0>
static constexpr auto	operator+ (X &&a)
template<class X , class S , class R = RemoveReference<X>, If< Any< TensorTrain::IsTensorish< R >, TensorTrain::IsOperatorish< R > > > = 0>
static void	print (X &&arg, S &&stream)
template<class Ranks , class X , class R = RemoveReference<X>, class V = typename R::Value, class VT = V, If< All< IsFloat< V >, IsFloat< VT > > > = 0, If< Any< TensorTrain::IsTensorish< R >, TensorTrain::IsOperatorish< R > > > = 0, If< IsSizes< Ranks > > = 0, If< IsSatisfied<(typename Ranks::Dimension()==typename R::Dimension() - 1)> > = 0>
static constexpr auto	round (X &&a, VT const &tolerance=NumericLimits< VT >::epsilon())
template<class X , class R = RemoveReference<X>, class V = typename R::Value, class VT = V, If< All< IsFloat< V >, IsFloat< VT > > > = 0, If< Any< TensorTrain::IsTensorish< R >, TensorTrain::IsOperatorish< R > > > = 0>
static constexpr auto	round (X &&a, VT const &tolerance=NumericLimits< VT >::epsilon())
template<Size C, class X , class R = RemoveReference<X>, class V = typename R::Value, class VT = V, If< All< IsFloat< V >, IsFloat< VT > > > = 0, If< Any< TensorTrain::IsTensorish< R >, TensorTrain::IsOperatorish< R > > > = 0>
static constexpr auto	round (X &&a, VT const &tolerance=NumericLimits< VT >::epsilon())
template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< Any< TensorTrain::IsTensorish< RA >, TensorTrain::IsOperatorish< RA > > > = 0, If< IsInvocable< View, XA > > = 0, If< Any< IsValue< RB >, IsComplex< RB > > > = 0, If< IsInvocable< Mul, typename RA::Type, RB const & > > = 0>
static constexpr auto	operator* (XA &&a, XB &&b)
template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< Any< TensorTrain::IsTensorish< RA >, TensorTrain::IsOperatorish< RA > > > = 0, If< IsInvocable< View, XA > > = 0, If< Any< IsValue< RB >, IsComplex< RB > > > = 0, If< IsInvocable< Div, typename RA::Type, RB const & > > = 0>
static constexpr auto	operator/ (XA &&a, XB &&b)
template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< Any< TensorTrain::IsTensorish< RA >, TensorTrain::IsOperatorish< RA > > > = 0, If< IsTensorish< RB > > = 0, If< IsInvocable< Mul, XA, typename RB::Type > > = 0>
static constexpr auto	operator* (XA &&a, XB &&b)
template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< Any< TensorTrain::IsTensorish< RA >, TensorTrain::IsOperatorish< RA > > > = 0, If< IsTensorish< RB > > = 0, If< IsInvocable< Div, XA, typename RB::Type > > = 0>
static constexpr auto	operator/ (XA &&a, XB &&b)
template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< Any< All< TensorTrain::IsTensorish< RA >, TensorTrain::IsTensorish< RB > >, All< TensorTrain::IsOperatorish< RA >, TensorTrain::IsOperatorish< RB > > > > = 0, If< IsInvocable< Minus, XB > > = 0, If< IsInvocable< Add, XA, ResultOf< Minus, XB > > > = 0>
static constexpr auto	operator- (XA &&a, XB &&b)
template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< TensorTrain::IsOperatorish< RA > > = 0, If< TensorTrain::IsOperatorish< RB > > = 0, If< IsSame< typename RA::Sizes, typename RB::Sizes > > = 0, If< HasCommon< typename RA::Type, typename RB::Type > > = 0>
static constexpr auto	operator+ (XA &&a, XB &&b)
template<class X , If< TensorTrain::IsOperatorish< RemoveReference< X > > > = 0, If< IsInvocable< View, X > > = 0, If< IsInvocable< Transpose, X > > = 0, If< IsInvocable< Conj, ResultOf< Transpose, X > > > = 0>
static constexpr auto	adjoint (X &&a)
template<class X , If< TensorTrain::IsOperatorish< RemoveReference< X > > > = 0, If< Not< IsInvocable< View, X > > > = 0, If< IsInvocable< Adjoint, X & > > = 0>
static constexpr auto	adjoint (X &&a)
template<Operator::Transform OT = Operator::Transform::None, Operator::Restrict OR = Operator::Restrict::None, Operator::Hint OH = Operator::Hint::None, class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< TensorTrain::IsOperatorish< RA > > = 0, If< IsInvocable< View, XA > > = 0, If< Any< TensorTrain::IsOperatorish< RB >, TensorTrain::IsTensorish< RB > > > = 0, If< IsInvocable< View, XB > > = 0, If< IsInvocable< Transform< OT >, XA > > = 0, If< IsInvocable< Mul, ResultOf< Restrict< OR >, ResultOf< Transform< OT >, XA > >, XB > > = 0>
static constexpr auto	apply (XA &&a, XB &&b)
template<Operator::Transform OT = Operator::Transform::None, Operator::Restrict OR = Operator::Restrict::None, Operator::Hint OH = Operator::Hint::None, class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< TensorTrain::IsOperatorish< RA > > = 0, If< Any< TensorTrain::IsOperatorish< RB >, TensorTrain::IsTensorish< RB > > > = 0, If< Not< All< IsInvocable< View, XA >, IsInvocable< View, XB > > > > = 0, If< IsInvocable< Apply< OT, OR, OH >, XA &, XB & > > = 0>
static constexpr auto	apply (XA &&a, XB &&b)
template<class X , class R = RemoveReference<X>, If< TensorTrain::IsOperatorish< R > > = 0, If< IsInvocable< View, X > > = 0>
static constexpr auto	backwards (X &&a)
template<class X , If< TensorTrain::IsOperator< RemoveReference< X > > > = 0>
static constexpr X	eval (X &&a)
template<class X , If< TensorTrain::IsOperatorView< RemoveReference< X > > > = 0>
static constexpr auto	eval (X &&a)
template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< TensorTrain::IsOperatorish< RA > > = 0, If< TensorTrain::IsOperatorish< RB > > = 0, If< IsSame< typename RA::Sizes, typename RB::Sizes > > = 0, If< IsInvocable< Mul, typename RA::Type, typename RB::Type > > = 0>
static constexpr auto	hadamardProduct (XA &&a, XB &&b)
template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< TensorTrain::IsOperatorish< RA > > = 0, If< IsInvocable< View, XA > > = 0, If< TensorTrain::IsTensorish< RB > > = 0, If< IsInvocable< View, XB > > = 0, If< IsSame< typename RA::N, typename RB::N > > = 0>
static constexpr auto	operator* (XA &&a, XB &&b)
template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< Any< TensorTrain::IsOperatorish< RA >, TensorTrain::IsTensorish< RA > > > = 0, If< Any< TensorTrain::IsOperatorish< RB >, TensorTrain::IsTensorish< RB > > > = 0, If< Not< All< IsInvocable< View, XA >, IsInvocable< View, XB > > > > = 0, If< IsInvocable< Mul, XA &, XB & > > = 0>
static constexpr auto	operator* (XA &&a, XB &&b)
template<Operator::Restrict OR = Operator::Restrict::None, class X , class R = RemoveReference<X>, If< TensorTrain::IsOperatorish< R > > = 0>
static constexpr decltype(auto)	restrict (X &&a)
template<class XA , class XB , If< TensorTrain::IsOperatorish< RemoveReference< XA > > > = 0, If< TensorTrain::IsOperatorish< RemoveReference< XB > > > = 0, If< IsInvocable< HadamardProduct, XA, XB > > = 0>
static constexpr auto	scalarProduct (XA &&a, XB &&b)
template<Operator::Transform OT = Operator::Transform::None, class X , class R = RemoveReference<X>, If< TensorTrain::IsOperatorish< R > > = 0>
static constexpr decltype(auto)	transform (X &&a)
template<class X , class R = RemoveReference<X>, If< TensorTrain::IsOperatorish< R > > = 0, If< IsInvocable< Loop< Permute< 0, 2, 1, 3 > >, X > > = 0>
static constexpr auto	transpose (X &&a)
template<class X , If< TensorTrain::IsOperatorView< RemoveReference< X > > > = 0>
static constexpr X	view (X &&a)
template<class T , class M , class N , class R >
static constexpr auto	view (TensorTrain::Operator< T, M, N, R > const &a)
template<class T , class M , class N , class R >
static constexpr auto	view (TensorTrain::Operator< T, M, N, R > &a)
template<class T , class M , class N , class R >
static constexpr auto	view (TensorTrain::Operator< T, M, N, R > const &&)=delete
template<class T , Size... Ms, Size... Ns, class R >
	Tensor (TensorTrain::Operator< T, Sizes< Ms... >, Sizes< Ns... >, R > const &) -> Tensor< T, Ms..., Ns... >
template<class T , Size... Ms, Size... Ns, class R , class F >
	Tensor (TensorTrain::OperatorViews::View< T, Sizes< Ms... >, Sizes< Ns... >, R, F > const &) -> Tensor< T, Ms..., Ns... >
template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< TensorTrain::IsTensorish< RA > > = 0, If< TensorTrain::IsTensorish< RB > > = 0, If< IsSame< typename RA::Sizes, typename RB::Sizes > > = 0, If< HasCommon< typename RA::Type, typename RB::Type > > = 0>
static constexpr auto	operator+ (XA &&a, XB &&b)
template<class X , class R = RemoveReference<X>, If< TensorTrain::IsTensorish< R > > = 0, If< IsInvocable< View, X > > = 0>
static constexpr auto	backwards (X &&a)
template<class X , If< TensorTrain::IsTensor< RemoveReference< X > > > = 0>
static constexpr X	eval (X &&a)
template<class X , If< TensorTrain::IsTensorView< RemoveReference< X > > > = 0>
static constexpr auto	eval (X &&a)
template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< TensorTrain::IsTensorish< RA > > = 0, If< TensorTrain::IsTensorish< RB > > = 0, If< IsSame< typename RA::Sizes, typename RB::Sizes > > = 0, If< IsInvocable< Mul, typename RA::Type, typename RB::Type > > = 0>
static constexpr auto	hadamardProduct (XA &&a, XB &&b)
template<class XA , class XB , If< TensorTrain::IsTensorish< RemoveReference< XA > > > = 0, If< TensorTrain::IsTensorish< RemoveReference< XB > > > = 0, If< IsInvocable< HadamardProduct, XA, XB > > = 0>
static constexpr auto	scalarProduct (XA &&a, XB &&b)
template<class X , If< TensorTrain::IsTensorView< RemoveReference< X > > > = 0>
static constexpr X	view (X &&a)
template<class T , class N , class R >
static constexpr auto	view (TensorTrain::Tensor< T, N, R > const &a)
template<class T , class N , class R >
static constexpr auto	view (TensorTrain::Tensor< T, N, R > &a)
template<class T , class N , class R >
static constexpr auto	view (TensorTrain::Tensor< T, N, R > const &&)=delete
template<class T , Size... Ns, class R >
	Tensor (TensorTrain::Tensor< T, Sizes< Ns... >, R > const &) -> Tensor< T, Ns... >
template<class T , Size... Ns, class R , class F >
	Tensor (TensorTrain::TensorViews::View< T, Sizes< Ns... >, R, F > const &) -> Tensor< T, Ns... >

Variables
constexpr auto	cLogLevel = LogLevel::Info
constexpr auto	cDebugLevel = DebugLevel::Low
constexpr Size	cHugepageSizeByte = 2 * 1024 * 1024
constexpr Size	cPageSizeByte = 4 * 1024
constexpr Size	cCacheLineSizeByte = 64
constexpr Size	cSimdSizeByte
False	isDefined (...)

Typedef Documentation

AddConst

template<class T >

using pRC::AddConst = std::add_const_t<T>

All

template<class... Bs>

using pRC::All = std::conjunction<Bs...>

Any

template<class... Bs>

using pRC::Any = std::disjunction<Bs...>

Array

template<class T , Size... Ns>

using pRC::Array

Initial value:

 Conditional<
        IsSatisfied<((Ns * ... * 1) * sizeof(T) > cHugepageSizeByte)>,
        HeapArray<T, Ns...>, StackArray<T, Ns...>>

Bool

using pRC::Bool = bool

Common

template<class... Ts>

using pRC::Common = typename CommonTypes<Ts...>::Type

Conditional

template<class B , class T , class F >

using pRC::Conditional = std::conditional_t<B{}, T, F>

Constant

template<class T , T V>

using pRC::Constant = std::integral_constant<T, V>

HasCommon

template<class... Ts>

using pRC::HasCommon = IsDetected<Common, Ts...>

HeapArray

template<class T , Size... Ns>

using pRC::HeapArray = CommonArray<Allocation::Heap, T, Ns...>

If

template<class B = True<>>

using pRC::If = std::enable_if_t<B{}, int>

Index

using pRC::Index = Size

IsAssignable

template<class T , class U = T>

using pRC::IsAssignable = std::is_assignable<T, U>

IsBaseOf

template<class B , class D >

using pRC::IsBaseOf = std::is_base_of<B, D>

IsBool

template<class T >

using pRC::IsBool = IsSame<RemoveConst<T>, Bool>

IsConst

template<class T >

using pRC::IsConst = std::is_const<T>

IsConstructible

template<class T , class... Args>

using pRC::IsConstructible = std::is_constructible<T, Args...>

IsConvertible

template<class F , class T >

using pRC::IsConvertible = std::is_convertible<F, T>

IsDefined

template<class T >

using pRC::IsDefined = decltype(isDefined(declval<T *>()))

IsDetected

template<template< class... > class Op, class... Args>

using pRC::IsDetected = Detector<void, Op, Args...>

IsEnum

template<class T >

using pRC::IsEnum = std::is_enum<T>

IsIndex

template<class T >

using pRC::IsIndex = IsSame<RemoveConst<T>, Index>

IsInteger

template<class T >

using pRC::IsInteger = Any<IsSignedInteger<T>, IsUnsignedInteger<T>>

IsIntegral

template<class T >

using pRC::IsIntegral = All<std::is_integral<T>, Not<IsBool<T>>>

IsInvocable

template<class F , class... Args>

using pRC::IsInvocable = std::is_invocable<F, Args...>

IsInvocableResult

template<class R , class F , class... Args>

using pRC::IsInvocableResult = std::is_invocable_r<R, F, Args...>

IsPointer

template<class T >

using pRC::IsPointer = std::is_pointer<T>

IsReference

template<class T >

using pRC::IsReference = std::is_reference<T>

IsSatisfied

template<Bool B>

using pRC::IsSatisfied = Constant<Bool, B>

IsSeed

template<class T >

using pRC::IsSeed = IsSame<RemoveConst<T>, Seed>

IsSignedIntegral

template<class T >

using pRC::IsSignedIntegral = All<IsIntegral<T>, std::is_signed<T>>

IsSize

template<class T >

using pRC::IsSize = IsSame<RemoveConst<T>, Size>

IsSizes

template<class T >

using pRC::IsSizes = All<IsSequence<T>, IsSame<Size, typename T::Type>>

IsStandardLayout

template<class T >

using pRC::IsStandardLayout = std::is_standard_layout<T>

IsSubscriptable

template<class T >

using pRC::IsSubscriptable = IsInvocable<Subscript, T, Index>

IsTensorish

template<class T >

using pRC::IsTensorish = Any<IsTensor<T>, IsTensorView<T>>

IsUnsignedIntegral

template<class T >

using pRC::IsUnsignedIntegral = All<IsIntegral<T>, std::is_unsigned<T>>

IsValue

template<class T >

using pRC::IsValue = Any<IsFloat<T>, IsInteger<T>>

Mutex

using pRC::Mutex = std::mutex

None

template<class... Bs>

using pRC::None = All<Not<Bs>...>

Not

template<class B >

using pRC::Not = std::negation<B>

RandomEngine

using pRC::RandomEngine = Threefry<20>

RemoveConst

template<class T >

using pRC::RemoveConst = std::remove_const_t<T>

RemoveConstReference

template<class T >

using pRC::RemoveConstReference = RemoveConst<RemoveReference<T>>

RemoveReference

template<class T >

using pRC::RemoveReference = std::remove_reference_t<T>

ResultOf

template<class F , class... Args>

using pRC::ResultOf = std::invoke_result_t<F, Args...>

Seed

using pRC::Seed = std::uint32_t

SignedInteger

template<Size W = sizeof(int) * 8>

using pRC::SignedInteger = Integer<true, W>

Size

using pRC::Size = std::size_t

Sizes

template<Size... Ns>

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

StackArray

template<class T , Size... Ns>

using pRC::StackArray = CommonArray<Allocation::Stack, T, Ns...>

UnderlyingType

template<class T >

using pRC::UnderlyingType = std::underlying_type_t<T>

UnsignedInteger

template<Size W = sizeof(int) * 8>

using pRC::UnsignedInteger = Integer<false, W>

Void

template<class... Ts>

using pRC::Void = void

Enumeration Type Documentation

Allocation

enum class pRC::Allocation

strong

Enumerator
Stack
Heap

Context

enum class pRC::Context

strong

Enumerator
CompileTime
RunTime

DebugLevel

enum class pRC::DebugLevel

strong

Enumerator
None
Low
Mid
High

Direction

enum class pRC::Direction

strong

Enumerator
Leftwards
RightToLeft
Rightwards
LeftToRight
Upwards
Up
Downwards
Down
Forwards
Forward
Backwards
Backward

LogLevel

enum class pRC::LogLevel

strong

Enumerator
Error
Warning
Info
Debug
Trace

Position

enum class pRC::Position

strong

Enumerator
Left
Right
Front
Back

Function Documentation

abs() [1/3]

template<class T , If< IsInvocable< Norm<>, Complex< T > > > = 0>

static constexpr auto pRC::abs ( Complex< T > const & a )

inlinestaticconstexpr

abs() [2/3]

template<class T , If< IsValue< T > > = 0, If< IsSatisfied<(typename T::Signed()==true)> > = 0>

static constexpr auto pRC::abs ( T const & a )

inlinestaticconstexpr

abs() [3/3]

template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Abs >, X > > = 0>

static constexpr auto pRC::abs ( X && a )

inlinestaticconstexpr

absoluteError()

template<class XA , class XB , If< IsInvocable< Sub, XA, XB > > = 0, If< IsInvocable< Norm<>, ResultOf< Sub, XA, XB > > > = 0, If< IsInvocable< Eval, ResultOf< Norm<>, ResultOf< Sub, XA, XB > > > > = 0>

static constexpr auto pRC::absoluteError ( XA && a, XB && b )

inlinestaticconstexpr

acos() [1/3]

template<class T >

static constexpr auto pRC::acos ( Complex< T > const & a )

inlinestaticconstexpr

acos() [2/3]

template<class T , If< IsFloat< T > > = 0>

static constexpr auto pRC::acos ( T const & a )

inlinestaticconstexpr

acos() [3/3]

template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Acos >, X > > = 0>

static constexpr auto pRC::acos ( X && a )

inlinestaticconstexpr

acosh() [1/3]

template<class T >

static constexpr auto pRC::acosh ( Complex< T > const & a )

inlinestaticconstexpr

acosh() [2/3]

template<class T , If< IsFloat< T > > = 0>

static constexpr auto pRC::acosh ( T const a )

inlinestaticconstexpr

acosh() [3/3]

template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Acosh >, X > > = 0>

static constexpr auto pRC::acosh ( X && a )

inlinestaticconstexpr

adjoint() [1/5]

template<class T >

static constexpr auto pRC::adjoint ( JacobiRotation< T > const & a )

inlinestaticconstexpr

adjoint() [2/5]

template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< View, X > > = 0, If< IsInvocable< Transpose, X > > = 0, If< IsInvocable< Conj, ResultOf< Transpose, X > > > = 0>

static constexpr auto pRC::adjoint ( X && a )

inlinestaticconstexpr

adjoint() [3/5]

template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< Not< IsInvocable< View, X > > > = 0, If< IsInvocable< Adjoint, X & > > = 0>

static constexpr auto pRC::adjoint ( X && a )

inlinestaticconstexpr

adjoint() [4/5]

template<class X , If< TensorTrain::IsOperatorish< RemoveReference< X > > > = 0, If< IsInvocable< View, X > > = 0, If< IsInvocable< Transpose, X > > = 0, If< IsInvocable< Conj, ResultOf< Transpose, X > > > = 0>

static constexpr auto pRC::adjoint ( X && a )

inlinestaticconstexpr

adjoint() [5/5]

template<class X , If< TensorTrain::IsOperatorish< RemoveReference< X > > > = 0, If< Not< IsInvocable< View, X > > > = 0, If< IsInvocable< Adjoint, X & > > = 0>

static constexpr auto pRC::adjoint ( X && a )

inlinestaticconstexpr

alignment()

template<Size S, Size P = alignof(std::max_align_t)>

static constexpr auto pRC::alignment ( )

inlinestaticconstexpr

alloc()

static auto pRC::alloc ( Size size, Size const alignment = alignof(std::max_align_t) )

inlinestatic

apply() [1/6]

template<class T , class X , class R = RemoveReference<X>, If< Any< All< IsTensor< R >, Not< IsReference< X > > >, All< IsTensorish< R >, IsAssignable< X > > > > = 0, If< IsSatisfied<(typename R::Dimension()==2)> > = 0>

static constexpr decltype(auto) pRC::apply ( JacobiRotation< T > const & r, X && m, Index const p, Index const q )

inlinestaticconstexpr

apply() [2/6]

template<class T , class X , class R = RemoveReference<X>, If< Any< All< IsTensor< R >, Not< IsReference< X > > >, All< IsTensorish< R >, IsAssignable< X > > > > = 0, If< IsSatisfied<(typename R::Dimension()==2)> > = 0>

static constexpr decltype(auto) pRC::apply ( X && m, JacobiRotation< T > const & r, Index const p, Index const q )

inlinestaticconstexpr

apply() [3/6]

template<Operator::Transform OT = Operator::Transform::None, Operator::Restrict OR = Operator::Restrict::None, Operator::Hint OH = Operator::Hint::None, class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< IsTensorish< RA > > = 0, If< IsInvocable< View, XA > > = 0, If< IsTensorish< RB > > = 0, If< IsInvocable< View, XB > > = 0, class DA = typename RA::Dimension, class DB = typename RB::Dimension, If< IsSatisfied<(isEven(DA()) &&(DA()/2==DB()||DA()==DB()))> > = 0, If< IsInvocable< Transform< OT >, XA > > = 0, If< IsInvocable< Mul, ResultOf< Restrict< OR >, ResultOf< Transform< OT >, XA > >, XB > > = 0>

static constexpr auto pRC::apply ( XA && a, XB && b )

inlinestaticconstexpr

apply() [4/6]

template<Operator::Transform OT = Operator::Transform::None, Operator::Restrict OR = Operator::Restrict::None, Operator::Hint OH = Operator::Hint::None, class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< IsTensorish< RA > > = 0, If< IsTensorish< RB > > = 0, If< Not< All< IsInvocable< View, XA >, IsInvocable< View, XB > > > > = 0, If< IsInvocable< Apply< OT, OR, OH >, XA &, XB & > > = 0>

static constexpr auto pRC::apply ( XA && a, XB && b )

inlinestaticconstexpr

apply() [5/6]

template<Operator::Transform OT = Operator::Transform::None, Operator::Restrict OR = Operator::Restrict::None, Operator::Hint OH = Operator::Hint::None, class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< TensorTrain::IsOperatorish< RA > > = 0, If< IsInvocable< View, XA > > = 0, If< Any< TensorTrain::IsOperatorish< RB >, TensorTrain::IsTensorish< RB > > > = 0, If< IsInvocable< View, XB > > = 0, If< IsInvocable< Transform< OT >, XA > > = 0, If< IsInvocable< Mul, ResultOf< Restrict< OR >, ResultOf< Transform< OT >, XA > >, XB > > = 0>

static constexpr auto pRC::apply ( XA && a, XB && b )

inlinestaticconstexpr

apply() [6/6]

template<Operator::Transform OT = Operator::Transform::None, Operator::Restrict OR = Operator::Restrict::None, Operator::Hint OH = Operator::Hint::None, class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< TensorTrain::IsOperatorish< RA > > = 0, If< Any< TensorTrain::IsOperatorish< RB >, TensorTrain::IsTensorish< RB > > > = 0, If< Not< All< IsInvocable< View, XA >, IsInvocable< View, XB > > > > = 0, If< IsInvocable< Apply< OT, OR, OH >, XA &, XB & > > = 0>

static constexpr auto pRC::apply ( XA && a, XB && b )

inlinestaticconstexpr

arg() [1/3]

template<class T , If< IsInvocable< Atan2, T, T > > = 0>

static constexpr auto pRC::arg ( Complex< T > const & a )

inlinestaticconstexpr

arg() [2/3]

template<class T , If< IsFloat< T > > = 0>

static constexpr auto pRC::arg ( T const & a )

inlinestaticconstexpr

arg() [3/3]

template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Arg >, X > > = 0>

static constexpr auto pRC::arg ( X && a )

inlinestaticconstexpr

asConst() [1/2]

template<class T >

AddConst< T > pRC::asConst

(

T &&

a

)

asConst() [2/2]

template<class T >

AddConst< T > & pRC::asConst

(

T &

a

)

asin() [1/3]

template<class T , If< IsInvocable< Asinh, Complex< T > > > = 0>

static constexpr auto pRC::asin ( Complex< T > const & a )

inlinestaticconstexpr

asin() [2/3]

template<class T , If< IsFloat< T > > = 0>

static constexpr auto pRC::asin ( T const & a )

inlinestaticconstexpr

asin() [3/3]

template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Asin >, X > > = 0>

static constexpr auto pRC::asin ( X && a )

inlinestaticconstexpr

asinh() [1/3]

template<class T >

static constexpr auto pRC::asinh ( Complex< T > const & a )

inlinestaticconstexpr

asinh() [2/3]

template<class T , If< IsFloat< T > > = 0>

static constexpr auto pRC::asinh ( T const & a )

inlinestaticconstexpr

asinh() [3/3]

template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Asinh >, X > > = 0>

static constexpr auto pRC::asinh ( X && a )

inlinestaticconstexpr

atan() [1/3]

template<class T >

static constexpr auto pRC::atan ( Complex< T > const & a )

inlinestaticconstexpr

atan() [2/3]

template<class T , If< IsFloat< T > > = 0>

static constexpr auto pRC::atan ( T const & a )

inlinestaticconstexpr

atan() [3/3]

template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Atan >, X > > = 0>

static constexpr auto pRC::atan ( X && a )

inlinestaticconstexpr

atan2() [1/2]

template<class XA , class XB , If< IsTensorish< RemoveReference< XA > > > = 0, If< IsTensorish< RemoveReference< XB > > > = 0, If< IsInvocable< Loop< Atan2 >, XA, XB > > = 0>

static constexpr auto pRC::atan2 ( XA && a, XB && b )

inlinestaticconstexpr

atan2() [2/2]

template<class Y , class X , If< IsFloat< Y > > = 0, If< IsFloat< X > > = 0>

static constexpr auto pRC::atan2 ( Y const & y, X const & x )

inlinestaticconstexpr

atanh() [1/3]

template<class T >

static constexpr auto pRC::atanh ( Complex< T > const & a )

inlinestaticconstexpr

atanh() [2/3]

template<class T , If< IsFloat< T > > = 0>

static constexpr auto pRC::atanh ( T const & a )

inlinestaticconstexpr

atanh() [3/3]

template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Atanh >, X > > = 0>

static constexpr auto pRC::atanh ( X && a )

inlinestaticconstexpr

backwards() [1/3]

template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< View, X > > = 0>

static constexpr auto pRC::backwards ( X && a )

inlinestaticconstexpr

backwards() [2/3]

template<class X , class R = RemoveReference<X>, If< TensorTrain::IsOperatorish< R > > = 0, If< IsInvocable< View, X > > = 0>

static constexpr auto pRC::backwards ( X && a )

inlinestaticconstexpr

backwards() [3/3]

template<class X , class R = RemoveReference<X>, If< TensorTrain::IsTensorish< R > > = 0, If< IsInvocable< View, X > > = 0>

static constexpr auto pRC::backwards ( X && a )

inlinestaticconstexpr

bitRotateLeft()

template<class TA , class TB , If< IsUnsignedIntegral< TA > > = 0, If< IsUnsignedIntegral< TB > > = 0>

static constexpr auto pRC::bitRotateLeft ( TA const value, TB count )

inlinestaticconstexpr

bitRotateRight()

template<class TA , class TB , If< IsUnsignedIntegral< TA > > = 0, If< IsUnsignedIntegral< TB > > = 0>

static constexpr auto pRC::bitRotateRight ( TA const value, TB count )

inlinestaticconstexpr

block() [1/2]

template<Size... Bs, class X , class... Os, class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< View, X > > = 0, If< All< IsConvertible< Os, Index >... > > = 0, If< IsSatisfied<(sizeof...(Bs)==typename R::Dimension())> > = 0, If< IsSatisfied<(sizeof...(Os)==typename R::Dimension())> > = 0, If< IsSatisfied<(typename R::Sizes() % Sizes< Bs... >()==Constant< Size, 0 >())> >

static constexpr auto pRC::block ( X && a, Os const ... offsets )

inlinestaticconstexpr

block() [2/2]

template<Size... Bs, class X , class... Os, class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< Not< IsInvocable< View, X > > > = 0, If< IsInvocable< Block< Bs... >, X &, Os... > > = 0>

static constexpr auto pRC::block ( X && a, Os const ... offsets )

inlinestaticconstexpr

broadcast()

template<Size... Bs, class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< View, X > > = 0, If< IsSatisfied<(sizeof...(Bs)==typename R::Dimension())> > = 0>

static constexpr auto pRC::broadcast ( X && a )

inlinestaticconstexpr

cast() [1/3]

template<class C , If< IsValue< C > > = 0, class T , If< IsInvocable< Cast< C >, T > > = 0>

static constexpr auto pRC::cast ( Complex< T > const & a )

inlinestaticconstexpr

cast() [2/3]

template<class C , If< IsValue< C > > = 0, class T , If< IsValue< T > > = 0, If< IsConstructible< C, typename T::Fundamental > > = 0>

static constexpr auto pRC::cast ( T const & a )

inlinestaticconstexpr

cast() [3/3]

template<class C , class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Cast< C > >, X > > = 0>

static constexpr auto pRC::cast ( X && a )

inlinestaticconstexpr

ceil() [1/2]

template<class T , If< IsFloat< T > > = 0>

static constexpr auto pRC::ceil ( T const a )

inlinestaticconstexpr

ceil() [2/2]

template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Ceil >, X > > = 0>

static constexpr auto pRC::ceil ( X && a )

inlinestaticconstexpr

ceilDiv()

template<class TA , class TB , If< IsUnsignedIntegral< TA > > = 0, If< IsUnsignedIntegral< TB > > = 0>

static constexpr auto pRC::ceilDiv ( TA const a, TB const b )

inlinestaticconstexpr

chip() [1/5]

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 )

inlinestaticconstexpr

chip() [2/5]

template<class T , T... Is>

static constexpr auto pRC::chip ( Sequence< T, Is... > const )

inlinestaticconstexpr

chip() [3/5]

template<Index... Ds, Size... Ns, If< True< decltype(chip< Ds... >(Sequence< Index, Ns... >()))> >

static constexpr auto pRC::chip ( Subscripts< Ns... > const & arg )

inlinestaticconstexpr

chip() [4/5]

template<Index... Ds, class X , class... Is, class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< View, X > > = 0, If< All< IsConvertible< Is, Index >... > > = 0, If< IsSatisfied<(sizeof...(Is)==sizeof...(Ds))> > = 0, If< True< decltype(chip< Ds... >(makeSeries< Index, typename R::Dimension{}>()))> >

static constexpr auto pRC::chip ( X && a, Is const ... indices )

inlinestaticconstexpr

chip() [5/5]

template<Index... Ds, class X , class... Is, class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< Not< IsInvocable< View, X > > > = 0, If< IsInvocable< Chip< Ds... >, X &, Is... > > = 0>

static constexpr auto pRC::chip ( X && a, Is const ... indices )

inlinestaticconstexpr

cholesky()

template<Operator::Hint H = Operator::Hint::None, class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsFloat< typename R::Value > > = 0, If< IsSatisfied<(typename R::Dimension()==2)> > = 0, If< IsSatisfied<(R::size(0)==R::size(1))> > = 0>

static constexpr auto pRC::cholesky ( X && a )

inlinestaticconstexpr

CommonArray()

template<class T , Size N>

pRC::CommonArray

(

T

const(&)[N]

)

-> CommonArray< Allocation::Stack, T, N >

Complex() [1/2]

template<class T , If< IsFloat< T > > = 0>

pRC::Complex

(

T const &

)

-> Complex< T >

Complex() [2/2]

template<class TA , class TB , If< All< IsFloat< TA >, IsFloat< TB > > > = 0>

pRC::Complex	(	TA const &	,
		TB const &	) -> Complex< Common< TA, TB > >

complexify() [1/3]

template<class T , If< IsValue< T > > = 0, If< IsConstructible< Complex< T >, T > > = 0>

static constexpr auto pRC::complexify ( T const & a )

inlinestaticconstexpr

complexify() [2/3]

template<class X , If< IsComplex< RemoveReference< X > > > = 0>

static constexpr X pRC::complexify ( X && a )

inlinestaticconstexpr

complexify() [3/3]

template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Complexify >, X > > = 0>

static constexpr auto pRC::complexify ( X && a )

inlinestaticconstexpr

conj() [1/4]

template<class T >

static constexpr auto pRC::conj ( Complex< T > const & a )

inlinestaticconstexpr

conj() [2/4]

template<class T , If< IsValue< T > > = 0>

static constexpr auto pRC::conj ( T const & a )

inlinestaticconstexpr

conj() [3/4]

template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Conj >, X > > = 0>

static constexpr auto pRC::conj ( X && a )

inlinestaticconstexpr

conj() [4/4]

template<class X , class R = RemoveReference<X>, If< Any< TensorTrain::IsTensorish< R >, TensorTrain::IsOperatorish< R > > > = 0, If< IsInvocable< Loop< Conj >, X > > = 0>

static constexpr auto pRC::conj ( X && a )

inlinestaticconstexpr

contract() [1/4]

template<Index... Is, class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< View, X > > = 0, If< IsSatisfied<(isEven(sizeof...(Is)))> > = 0, If< IsSatisfied<(sizeof...(Is)<=typename R::Dimension())> > = 0>

static constexpr auto pRC::contract ( X && a )

inlinestaticconstexpr

contract() [2/4]

template<Index... Is, class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< Not< IsInvocable< View, X > > > = 0, If< IsInvocable< Contract< Is... >, X & > > = 0>

static constexpr auto pRC::contract ( X && a )

inlinestaticconstexpr

contract() [3/4]

template<Index... Is, class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< IsTensorish< RA > > = 0, If< IsInvocable< View, XA > > = 0, If< IsTensorish< RB > > = 0, If< IsInvocable< View, XB > > = 0, If< IsSatisfied<(isEven(sizeof...(Is)))> > = 0, If< IsSatisfied<(sizeof...(Is)/2<=min(typename RA::Dimension(), typename RB::Dimension()))> > = 0>

static constexpr auto pRC::contract ( XA && a, XB && b )

inlinestaticconstexpr

contract() [4/4]

template<Index... Is, class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< IsTensorish< RA > > = 0, If< IsTensorish< RB > > = 0, If< Not< All< IsInvocable< View, XA >, IsInvocable< View, XB > > > > = 0, If< IsInvocable< Contract< Is... >, XA &, XB & > > = 0>

static constexpr auto pRC::contract ( XA && a, XB && b )

inlinestaticconstexpr

copy()

template<Bool C = true, class X >

static constexpr Conditional< IsSatisfied< C >, RemoveConstReference< X >, X > pRC::copy ( X && a )

inlinestaticconstexpr

cos() [1/3]

template<class T >

static constexpr auto pRC::cos ( Complex< T > const & a )

inlinestaticconstexpr

cos() [2/3]

template<class T , If< IsFloat< T > > = 0>

static constexpr auto pRC::cos ( T const a )

inlinestaticconstexpr

cos() [3/3]

template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Cos >, X > > = 0>

static constexpr auto pRC::cos ( X && a )

inlinestaticconstexpr

cosh() [1/3]

template<class T >

static constexpr auto pRC::cosh ( Complex< T > const & a )

inlinestaticconstexpr

cosh() [2/3]

template<class T , If< IsFloat< T > > = 0>

static constexpr auto pRC::cosh ( T const & a )

inlinestaticconstexpr

cosh() [3/3]

template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Cosh >, X > > = 0>

static constexpr auto pRC::cosh ( X && a )

inlinestaticconstexpr

cut()

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 )

inlinestaticconstexpr

dealloc()

static auto pRC::dealloc ( void * ptr )

inlinestatic

delta() [1/5]

template<class TA , class TB , If< IsInvocable< Sub, TA, TB > > = 0>

static constexpr auto pRC::delta ( Complex< TA > const & a, Complex< TB > const & b )

inlinestaticconstexpr

delta() [2/5]

template<class TA , class TB , If< IsValue< TB > > = 0, If< IsInvocable< Sub, TA, TB > > = 0>

static constexpr auto pRC::delta ( Complex< TA > const & a, TB const & b )

inlinestaticconstexpr

delta() [3/5]

template<class TA , class TB , If< IsValue< TA > > = 0, If< IsInvocable< Sub, TA, TB > > = 0>

static constexpr auto pRC::delta ( TA const & a, Complex< TB > const & b )

inlinestaticconstexpr

delta() [4/5]

template<class TA , class TB , If< IsValue< TA > > = 0, If< IsValue< TB > > = 0, If< None< IsUnsignedInteger< TA >, IsUnsignedInteger< TB > > > = 0>

static constexpr auto pRC::delta ( TA const & a, TB const & b )

inlinestaticconstexpr

delta() [5/5]

template<class XA , class XB , If< IsTensorish< RemoveReference< XA > > > = 0, If< IsTensorish< RemoveReference< XB > > > = 0, If< IsInvocable< Loop< Delta >, XA, XB > > = 0>

static constexpr auto pRC::delta ( XA && a, XB && b )

inlinestaticconstexpr

diagonal()

template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< View, X > > = 0, If< IsSatisfied<(isEven(typename R::Dimension()))> > = 0>

static constexpr auto pRC::diagonal ( X && a )

inlinestaticconstexpr

directSum() [1/2]

template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< IsTensorish< RA > > = 0, If< IsInvocable< View, XA > > = 0, If< IsTensorish< RB > > = 0, If< IsInvocable< View, XB > > = 0, If< IsSame< typename RA::Dimension, typename RB::Dimension > > = 0, If< HasCommon< typename RA::Type, typename RB::Type > > = 0>

static constexpr auto pRC::directSum ( XA && a, XB && b )

inlinestaticconstexpr

directSum() [2/2]

template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< IsTensorish< RA > > = 0, If< IsTensorish< RB > > = 0, If< Not< All< IsInvocable< View, XA >, IsInvocable< View, XB > > > > = 0, If< IsInvocable< DirectSum, XA &, XB & > > = 0>

static constexpr auto pRC::directSum ( XA && a, XB && b )

inlinestaticconstexpr

enumerate() [1/4]

template<class F , class... Xs, If< All< Any< TensorTrain::IsTensorish< RemoveReference< Xs > >, TensorTrain::IsOperatorish< RemoveReference< Xs > > >... > > = 0, If< All< IsInvocable< View, Xs >... > > = 0, If< IsSame< typename RemoveReference< Xs >::Dimension... > > = 0, If< True< decltype(declval< F >().template operator()<0 >(declval< Xs >().template core< 0 >()...))> >

static constexpr auto pRC::enumerate ( F && f, Xs &&... args )

inlinestaticconstexpr

enumerate() [2/4]

template<class F , class... Xs, If< All< Any< TensorTrain::IsTensorish< RemoveReference< Xs > >, TensorTrain::IsOperatorish< RemoveReference< Xs > > >... > > = 0, If< Not< All< IsInvocable< View, Xs >... > > > = 0, If< IsInvocable< Enumerate< F >, F, Xs &... > > = 0>

static constexpr auto pRC::enumerate ( F && f, Xs &&... args )

inlinestaticconstexpr

enumerate() [3/4]

template<class F , class... Xs, If< All< Any< TensorTrain::IsTensorish< RemoveReference< Xs > >, TensorTrain::IsOperatorish< RemoveReference< Xs > > >... > > = 0, If< All< IsInvocable< View, Xs >... > > = 0, If< IsSame< typename RemoveReference< Xs >::Dimension... > > = 0, If< True< decltype(declval< F >().template operator()<0 >(declval< Xs >().template core< 0 >()...))> >

static constexpr auto pRC::enumerate ( Xs &&... args )

inlinestaticconstexpr

enumerate() [4/4]

template<class F , class... Xs, If< All< Any< TensorTrain::IsTensorish< RemoveReference< Xs > >, TensorTrain::IsOperatorish< RemoveReference< Xs > > >... > > = 0, If< Not< All< IsInvocable< View, Xs >... > > > = 0, If< IsInvocable< Enumerate< F >, Xs &... > > = 0>

static constexpr auto pRC::enumerate ( Xs &&... args )

inlinestaticconstexpr

eval() [1/8]

template<class X , If< IsComplex< RemoveReference< X > > > = 0>

static constexpr X pRC::eval ( X && a )

inlinestaticconstexpr

eval() [2/8]

template<class X , If< IsTensor< RemoveReference< X > > > = 0>

static constexpr X pRC::eval ( X && a )

inlinestaticconstexpr

eval() [3/8]

template<class X , If< IsTensorView< RemoveReference< X > > > = 0>

static constexpr auto pRC::eval ( X && a )

inlinestaticconstexpr

eval() [4/8]

template<class X , If< IsBool< RemoveReference< X > > > = 0>

static constexpr X pRC::eval ( X && a )

inlinestaticconstexpr

eval() [5/8]

template<class X , If< TensorTrain::IsOperator< RemoveReference< X > > > = 0>

static constexpr X pRC::eval ( X && a )

inlinestaticconstexpr

eval() [6/8]

template<class X , If< TensorTrain::IsOperatorView< RemoveReference< X > > > = 0>

static constexpr auto pRC::eval ( X && a )

inlinestaticconstexpr

eval() [7/8]

template<class X , If< TensorTrain::IsTensor< RemoveReference< X > > > = 0>

static constexpr X pRC::eval ( X && a )

inlinestaticconstexpr

eval() [8/8]

template<class X , If< TensorTrain::IsTensorView< RemoveReference< X > > > = 0>

static constexpr auto pRC::eval ( X && a )

inlinestaticconstexpr

exclude() [1/4]

template<Index... Es, class F , class... Xs, If< All< IsTensorish< RemoveReference< Xs > >... > > = 0, If< All< IsInvocable< View, Xs >... > > = 0, If< IsSame< decltype(select< Es... >(typename RemoveReference< Xs >::Sizes()))... > , If< IsInvocable< F, ResultOf< pRC::Chip< Es... >, Xs, decltype(Es)... >... > > = 0, If< True< decltype(select< Es... >(makeSeries< Index, typename RemoveReference< Xs >::Dimension{}>()))... > >

static constexpr auto pRC::exclude ( F && f, Xs &&... args )

inlinestaticconstexpr

exclude() [2/4]

template<Index... Es, class F , class... Xs, If< All< IsTensorish< RemoveReference< Xs > >... > > = 0, If< Not< All< IsInvocable< View, Xs >... > > > = 0, If< IsInvocable< Exclude< F, Es... >, Xs &... > > = 0>

static constexpr auto pRC::exclude ( F && f, Xs &&... args )

inlinestaticconstexpr

exclude() [3/4]

template<class F , Index... Es, class... Xs, If< All< IsTensorish< RemoveReference< Xs > >... > > = 0, If< All< IsInvocable< View, Xs >... > > = 0, If< IsSame< decltype(select< Es... >(typename RemoveReference< Xs >::Sizes()))... > , If< IsInvocable< F, ResultOf< pRC::Chip< Es... >, Xs, decltype(Es)... >... > > = 0, If< True< decltype(select< Es... >(makeSeries< Index, typename RemoveReference< Xs >::Dimension{}>()))... > >

static constexpr auto pRC::exclude ( Xs &&... args )

inlinestaticconstexpr

exclude() [4/4]

template<class F , Index... Es, class... Xs, If< All< IsTensorish< RemoveReference< Xs > >... > > = 0, If< Not< All< IsInvocable< View, Xs >... > > > = 0, If< IsInvocable< Exclude< F, Es... >, Xs &... > > = 0>

static constexpr auto pRC::exclude ( Xs &&... args )

inlinestaticconstexpr

exp() [1/3]

template<class T >

static constexpr auto pRC::exp ( Complex< T > const & a )

inlinestaticconstexpr

exp() [2/3]

template<class T , If< IsFloat< T > > = 0>

static constexpr auto pRC::exp ( T const & a )

inlinestaticconstexpr

exp() [3/3]

template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Exp >, X > > = 0>

static constexpr auto pRC::exp ( X && a )

inlinestaticconstexpr

expand()

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 )

inlinestaticconstexpr

extractDiagonal()

template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< View, X > > = 0, If< IsSatisfied<(isEven(typename R::Dimension()))> > = 0>

static constexpr auto pRC::extractDiagonal ( X && a )

inlinestaticconstexpr

filter()

template<class F , class T , T... Is>

static constexpr auto pRC::filter ( Sequence< T, Is... > const )

inlinestaticconstexpr

flatten()

template<Index K, class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< View, X > > = 0, If< IsSatisfied<(typename R::Dimension{} > 1)> , If< IsSatisfied<(K< typename R::Dimension{})> > = 0>

static constexpr auto pRC::flatten ( X && a )

inlinestaticconstexpr

Float() [1/3]

pRC::Float

(

Float< 16 >::Fundamental const

)

-> Float< 16 >

Float() [2/3]

pRC::Float

(

Float< 32 >::Fundamental const

)

-> Float< 32 >

Float() [3/3]

pRC::Float

(

Float< 64 >::Fundamental const

)

-> Float< 64 >

floor() [1/2]

template<class T , If< IsFloat< T > > = 0>

static constexpr auto pRC::floor ( T const & a )

inlinestaticconstexpr

floor() [2/2]

template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Floor >, X > > = 0>

static constexpr auto pRC::floor ( X && a )

inlinestaticconstexpr

fmod() [1/2]

template<class TA , class TB , If< IsFloat< TA > > = 0, If< IsFloat< TB > > = 0>

static constexpr auto pRC::fmod ( TA const & a, TB const & b )

inlinestaticconstexpr

fmod() [2/2]

template<class XA , class XB , If< IsTensorish< RemoveReference< XA > > > = 0, If< IsTensorish< RemoveReference< XB > > > = 0, If< IsInvocable< Loop< FMod >, XA, XB > > = 0>

static constexpr auto pRC::fmod ( XA && a, XB && b )

inlinestaticconstexpr

fold() [1/3]

template<class F , Bool E = false, Direction D = Direction::Forwards, If< IsSatisfied<(D==Direction::Forwards||D==Direction::Backwards)> > = 0, class XA , If< IsInvocable< F, XA, XA > > = 0>

static constexpr Conditional< IsSatisfied< E >, decltype(eval(declval< XA >())), XA > pRC::fold ( XA && a )

inlinestaticconstexpr

fold() [2/3]

template<class F , Bool E = false, Direction D = Direction::Forwards, If< IsSatisfied<(D==Direction::Forwards||D==Direction::Backwards)> > = 0, class XA , class XB , If< IsInvocable< F, XA, XB > > = 0>

static constexpr auto pRC::fold ( XA && a, XB && b )

inlinestaticconstexpr

fold() [3/3]

template<class F , Bool E = false, Direction D = Direction::Forwards, class XA , class XB , class... Xs, If< IsSatisfied<(sizeof...(Xs) > 0)> , If< IsSatisfied<(D==Direction::Forwards||D==Direction::Backwards)> > = 0, If< IsInvocable< F, XA, XB > > = 0, If< IsInvocable< Fold< F, E, D >, ResultOf< Fold< F, E, D >, XA, XB > const &, Xs... > > = 0>

static constexpr auto pRC::fold ( XA && a, XB && b, Xs &&... args )

inlinestaticconstexpr

folding()

template<Position P, class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsSatisfied<(typename R::Dimension{} > 1)> , If< IsSatisfied<(P==Position::Left||P==Position::Right)> > = 0, If< All< IsInvocable< Unfolding< typename R::Dimension() - 2 >, X >, IsInvocable< Unfolding< 0 >, X > > > = 0>

static constexpr auto pRC::folding ( X && a )

inlinestaticconstexpr

forwardAsTuple()

template<class... Xs>

static constexpr auto pRC::forwardAsTuple ( Xs &&... args )

inlinestaticconstexpr

fromDiagonal() [1/3]

template<Size... Ds, class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< View, X > > = 0, If< IsSatisfied<(isEven(sizeof...(Ds)))> > = 0, If< IsSatisfied<(sizeof...(Ds)/2==typename R::Dimension())> > = 0, If< IsSatisfied<(cut< 2, 0 >(Sizes< Ds... >()) >=typename R::Sizes())> , If< IsSatisfied<(cut< 2, 1 >(Sizes< Ds... >()) >=typename R::Sizes())> >

static constexpr auto pRC::fromDiagonal ( X && a )

inlinestaticconstexpr

fromDiagonal() [2/3]

template<Size... Ds, class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< Not< IsInvocable< View, X > > > = 0, If< IsInvocable< FromDiagonal< Ds... >, X & > > = 0>

static constexpr auto pRC::fromDiagonal ( X && a )

inlinestaticconstexpr

fromDiagonal() [3/3]

template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0>

static constexpr auto pRC::fromDiagonal ( X && a )

inlinestaticconstexpr

generateCanonical()

template<class T , class RNG , If< IsRandomEngine< RNG > > = 0, If< IsFloat< T > > = 0>

static constexpr T pRC::generateCanonical ( RNG & rng )

inlinestaticconstexpr

getPermutation() [1/3]

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  )

inlinestaticconstexpr

getPermutation() [2/3]

template<class T , T... Froms>

static constexpr auto pRC::getPermutation ( Sequence< T, Froms... > const )

inlinestaticconstexpr

getPermutation() [3/3]

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  )

inlinestaticconstexpr

getTimeInSeconds()

static Float< 64 > pRC::getTimeInSeconds ( )

inlinestatic

hadamardProduct() [1/3]

template<class XA , class XB , If< IsTensorish< RemoveReference< XA > > > = 0, If< IsTensorish< RemoveReference< XB > > > = 0, If< IsInvocable< Loop< Mul >, XA, XB > > = 0>

static constexpr auto pRC::hadamardProduct ( XA && a, XB && b )

inlinestaticconstexpr

hadamardProduct() [2/3]

template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< TensorTrain::IsOperatorish< RA > > = 0, If< TensorTrain::IsOperatorish< RB > > = 0, If< IsSame< typename RA::Sizes, typename RB::Sizes > > = 0, If< IsInvocable< Mul, typename RA::Type, typename RB::Type > > = 0>

static constexpr auto pRC::hadamardProduct ( XA && a, XB && b )

inlinestaticconstexpr

hadamardProduct() [3/3]

template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< TensorTrain::IsTensorish< RA > > = 0, If< TensorTrain::IsTensorish< RB > > = 0, If< IsSame< typename RA::Sizes, typename RB::Sizes > > = 0, If< IsInvocable< Mul, typename RA::Type, typename RB::Type > > = 0>

static constexpr auto pRC::hadamardProduct ( XA && a, XB && b )

inlinestaticconstexpr

help()

template<class... Ps>

static constexpr auto pRC::help ( Ps &&... parameters )

inlinestaticconstexpr

identity() [1/3]

template<class T , If< IsDefined< Identity< T > > > = 0, If< IsConstructible< Identity< T > > > = 0>

static constexpr auto pRC::identity ( )

inlinestaticconstexpr

identity() [2/3]

static constexpr auto pRC::identity ( )

inlinestaticconstexpr

identity() [3/3]

template<class T , class X , If< IsDefined< Identity< T > > > = 0, If< IsConstructible< Identity< T > > > = 0, If< IsInvocable< Identity< T >, X > > = 0>

static constexpr auto pRC::identity ( X && value )

inlinestaticconstexpr

iLog()

template<Size B, class T , If< IsUnsignedIntegral< T > > = 0>

static constexpr T pRC::iLog ( T const a )

inlinestaticconstexpr

imag() [1/3]

template<class T , If< IsValue< T > > = 0>

static constexpr auto pRC::imag ( T const )

inlinestaticconstexpr

imag() [2/3]

template<class X , If< IsComplex< RemoveReference< X > > > = 0>

static constexpr decltype(auto) pRC::imag ( X && a )

inlinestaticconstexpr

imag() [3/3]

template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Imag >, X > > = 0>

static constexpr auto pRC::imag ( X && a )

inlinestaticconstexpr

Indices()

template<class... Is, If< All< IsConvertible< Is, Index >... > > = 0>

pRC::Indices

(

Is

const ...

)

-> Indices< sizeof...(Is)>

inflate()

template<Size... Is, class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< View, X > > = 0, If< IsSatisfied<(sizeof...(Is)==typename R::Dimension())> > = 0>

static constexpr auto pRC::inflate ( X && a )

inlinestaticconstexpr

innerProduct() [1/7]

template<class TA , class TB , If< IsInvocable< Conj, Complex< TA > > > = 0, If< IsInvocable< ScalarProduct, Complex< TA >, Complex< TB > > > = 0>

static constexpr auto pRC::innerProduct ( Complex< TA > const & a, Complex< TB > const & b )

inlinestaticconstexpr

innerProduct() [2/7]

template<class TA , class TB , If< IsValue< TB > > = 0, If< IsInvocable< Conj, Complex< TA > > > = 0, If< IsInvocable< ScalarProduct, Complex< TA >, TB > > = 0>

static constexpr auto pRC::innerProduct ( Complex< TA > const & a, TB const & b )

inlinestaticconstexpr

innerProduct() [3/7]

template<class TA , class TB , If< IsValue< TA > > = 0, If< IsInvocable< ScalarProduct, TA, Complex< TB > > > = 0>

static constexpr auto pRC::innerProduct ( TA const & a, Complex< TB > const & b )

inlinestaticconstexpr

innerProduct() [4/7]

template<class TA , class TB , If< IsValue< TA > > = 0, If< IsValue< TB > > = 0>

static constexpr auto pRC::innerProduct ( TA const & a, TB const & b )

inlinestaticconstexpr

innerProduct() [5/7]

template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< IsTensorish< RA > > = 0, If< IsInvocable< View, XA > > = 0, If< IsTensorish< RB > > = 0, If< IsInvocable< Conj, XA > > = 0, If< IsInvocable< ScalarProduct, ResultOf< Conj, XA >, XB > > = 0>

static constexpr auto pRC::innerProduct ( XA && a, XB && b )

inlinestaticconstexpr

innerProduct() [6/7]

template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< IsTensorish< RA > > = 0, If< IsTensorish< RB > > = 0, If< Not< All< IsInvocable< View, XA >, IsInvocable< View, XB > > > > = 0, If< IsInvocable< InnerProduct, XA &, XB & > > = 0>

static constexpr auto pRC::innerProduct ( XA && a, XB && b )

inlinestaticconstexpr

innerProduct() [7/7]

template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< Any< All< TensorTrain::IsTensorish< RA >, TensorTrain::IsTensorish< RB > >, All< TensorTrain::IsOperatorish< RA >, TensorTrain::IsOperatorish< RB > > > > = 0, If< IsInvocable< Conj, XA > > = 0, If< IsInvocable< ScalarProduct, ResultOf< Conj, XA >, XB > > = 0>

static constexpr auto pRC::innerProduct ( XA && a, XB && b )

inlinestaticconstexpr

Integer() [1/8]

pRC::Integer

(

Integer< false, 16 >::Fundamental const

)

-> Integer< false, 16 >

Integer() [2/8]

pRC::Integer

(

Integer< false, 32 >::Fundamental const

)

-> Integer< false, 32 >

Integer() [3/8]

pRC::Integer

(

Integer< false, 64 >::Fundamental const

)

-> Integer< false, 64 >

Integer() [4/8]

pRC::Integer

(

Integer< false, 8 >::Fundamental const

)

-> Integer< false, 8 >

Integer() [5/8]

pRC::Integer

(

Integer< true, 16 >::Fundamental const

)

-> Integer< true, 16 >

Integer() [6/8]

pRC::Integer

(

Integer< true, 32 >::Fundamental const

)

-> Integer< true, 32 >

Integer() [7/8]

pRC::Integer

(

Integer< true, 64 >::Fundamental const

)

-> Integer< true, 64 >

Integer() [8/8]

pRC::Integer

(

Integer< true, 8 >::Fundamental const

)

-> Integer< true, 8 >

integerFactorization()

template<class T , T N, T... Ps>

static constexpr auto pRC::integerFactorization ( Constant< T, N > const , Sequence< T, Ps... > const = Sequence<T>() )

inlinestaticconstexpr

iPow()

template<class B , class N , If< IsIntegral< B > > = 0, If< IsUnsignedIntegral< N > > = 0>

static constexpr B pRC::iPow ( B const base, N const exp )

inlinestaticconstexpr

isApprox()

template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, class TT = Common<typename RA::Value, typename RB::Value>, class T = Common<typename RA::Value, typename RB::Value, TT>, If< IsValue< TT > > = 0, If< IsInvocable< AbsoluteError, XA, XB > > = 0, If< IsInvocable< Norm<>, XA > > = 0, If< IsInvocable< Norm<>, XB > > = 0, If< IsConstructible< T, ResultOf< AbsoluteError, XA, XB > > > = 0, If< IsConstructible< T, ResultOf< Norm<>, XA > > > = 0, If< IsConstructible< T, ResultOf< Norm<>, XB > > > = 0>

static constexpr auto pRC::isApprox ( XA && a, XB && b, TT const & tolerance = NumericLimits<TT>::tolerance() )

inlinestaticconstexpr

isDefined() [1/2]

template<class T , auto = sizeof(T), If< Not< IsPointer< T > > > = 0>

True pRC::isDefined

(

T &&

)

isDefined() [2/2]

template<class T , auto = sizeof(T)>

True pRC::isDefined

(

T *

)

isDiagonal()

template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< Diagonal, X > > = 0, If< IsInvocable< IsApprox, ResultOf< Diagonal, X >, X > > = 0, class TT = typename R::Value>

static constexpr auto pRC::isDiagonal ( X && a, TT const & tolerance = NumericLimits<TT>::tolerance() )

inlinestaticconstexpr

isEven() [1/2]

template<class T , T V, If< IsIntegral< T > > = 0>

static constexpr auto pRC::isEven ( Constant< T, V > const )

inlinestaticconstexpr

isEven() [2/2]

template<class T , If< IsIntegral< T > > = 0>

static constexpr auto pRC::isEven ( T const a )

inlinestaticconstexpr

isFinite()

template<class T , If< IsFloat< T > > = 0>

static constexpr auto pRC::isFinite ( T const & a )

inlinestaticconstexpr

isIdentity() [1/3]

template<class T , T V, If< IsIntegral< T > > = 0>

static constexpr auto pRC::isIdentity ( Constant< T, V > const )

inlinestaticconstexpr

isIdentity() [2/3]

template<class T , If< IsIntegral< T > > = 0>

static constexpr auto pRC::isIdentity ( T const a )

inlinestaticconstexpr

isIdentity() [3/3]

template<class X , class R = RemoveReference<X>, class TT = typename R::Value, If< IsValue< TT > > = 0, If< IsDefined< Identity< R > > > = 0, If< IsInvocable< Identity< R > > > = 0, If< IsInvocable< AbsoluteError, X, R > > = 0>

static constexpr auto pRC::isIdentity ( X && a, TT const & tolerance = NumericLimits<TT>::tolerance() )

inlinestaticconstexpr

isLowerTriangular()

template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< LowerTriangular, X > > = 0, If< IsInvocable< IsApprox, ResultOf< LowerTriangular, X >, X > > = 0, class TT = typename R::Value>

static constexpr auto pRC::isLowerTriangular ( X && a, TT const & tolerance = NumericLimits<TT>::tolerance() )

inlinestaticconstexpr

isnan()

static constexpr auto pRC::isnan ( BFloat16 const a )

inlinestaticconstexpr

isNaN()

template<class T , If< IsFloat< T > > = 0>

static constexpr auto pRC::isNaN ( T const & a )

inlinestaticconstexpr

isOdd() [1/2]

template<class T , T V, If< IsIntegral< T > > = 0>

static constexpr auto pRC::isOdd ( Constant< T, V > const )

inlinestaticconstexpr

isOdd() [2/2]

template<class T , If< IsIntegral< T > > = 0>

static constexpr auto pRC::isOdd ( T const a )

inlinestaticconstexpr

isOffDiagonal()

template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< OffDiagonal, X > > = 0, If< IsInvocable< IsApprox, ResultOf< OffDiagonal, X >, X > > = 0, class TT = typename R::Value>

static constexpr auto pRC::isOffDiagonal ( X && a, TT const & tolerance = NumericLimits<TT>::tolerance() )

inlinestaticconstexpr

isPowerOfTwo()

template<class T , If< IsIntegral< T > > = 0>

static constexpr auto pRC::isPowerOfTwo ( T const v )

inlinestaticconstexpr

isProperAlignment()

static constexpr auto pRC::isProperAlignment ( Size const alignment )

inlinestaticconstexpr

iSqrt()

template<class T , If< IsUnsignedIntegral< T > > = 0>

static constexpr T pRC::iSqrt ( T const a )

inlinestaticconstexpr

isSelfAdjoint()

template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< Adjoint, X > > = 0, If< IsInvocable< IsApprox, ResultOf< Adjoint, X >, X > > = 0, class TT = typename R::Value>

static constexpr auto pRC::isSelfAdjoint ( X && a, TT const & tolerance = NumericLimits<TT>::tolerance() )

inlinestaticconstexpr

isStrictlyLowerTriangular()

template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< StrictlyLowerTriangular, X > > = 0, If< IsInvocable< IsApprox, ResultOf< StrictlyLowerTriangular, X >, X > > = 0, class TT = typename R::Value>

static constexpr auto pRC::isStrictlyLowerTriangular ( X && a, TT const & tolerance = NumericLimits<TT>::tolerance() )

inlinestaticconstexpr

isStrictlyUpperTriangular()

template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< StrictlyUpperTriangular, X > > = 0, If< IsInvocable< IsApprox, ResultOf< StrictlyUpperTriangular, X >, X > > = 0, class TT = typename R::Value>

static constexpr auto pRC::isStrictlyUpperTriangular ( X && a, TT const & tolerance = NumericLimits<TT>::tolerance() )

inlinestaticconstexpr

isSymmetric()

template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< Transpose, X > > = 0, If< IsInvocable< IsApprox, ResultOf< Transpose, X >, X > > = 0, class TT = typename R::Value>

static constexpr auto pRC::isSymmetric ( X && a, TT const & tolerance = NumericLimits<TT>::tolerance() )

inlinestaticconstexpr

isTensorView() [1/2]

template<class >

static constexpr auto pRC::isTensorView ( ... )

inlinestaticconstexpr

isTensorView() [2/2]

template<class X , class T , class N , class F >

static constexpr auto pRC::isTensorView ( TensorViews::View< T, N, F > const && )

inlinestaticconstexpr

isUnit() [1/3]

template<class T , T V, If< IsIntegral< T > > = 0>

static constexpr auto pRC::isUnit ( Constant< T, V > const )

inlinestaticconstexpr

isUnit() [2/3]

template<class T , If< IsIntegral< T > > = 0>

static constexpr auto pRC::isUnit ( T const a )

inlinestaticconstexpr

isUnit() [3/3]

template<class X , class R = RemoveReference<X>, class TT = typename R::Value, If< IsValue< TT > > = 0, If< IsDefined< Unit< R > > > = 0, If< IsInvocable< Unit< R > > > = 0, If< IsInvocable< AbsoluteError, X, R > > = 0>

static constexpr auto pRC::isUnit ( X && a, TT const & tolerance = NumericLimits<TT>::tolerance() )

inlinestaticconstexpr

isUnitary()

template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< Adjoint, X > > = 0, If< IsInvocable< IsApprox, ResultOf< Mul, ResultOf< Adjoint, X >, X >, ResultOf< Mul, ResultOf< Adjoint, X >, X > > > = 0, class TT = typename R::Value>

static constexpr auto pRC::isUnitary ( X && a, TT const & tolerance = NumericLimits<TT>::tolerance() )

inlinestaticconstexpr

isUnitLowerTriangular()

template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< UnitLowerTriangular, X > > = 0, If< IsInvocable< IsApprox, ResultOf< UnitLowerTriangular, X >, X > > = 0, class TT = typename R::Value>

static constexpr auto pRC::isUnitLowerTriangular ( X && a, TT const & tolerance = NumericLimits<TT>::tolerance() )

inlinestaticconstexpr

isUnitUpperTriangular()

template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< UnitUpperTriangular, X > > = 0, If< IsInvocable< IsApprox, ResultOf< UnitUpperTriangular, X >, X > > = 0, class TT = typename R::Value>

static constexpr auto pRC::isUnitUpperTriangular ( X && a, TT const & tolerance = NumericLimits<TT>::tolerance() )

inlinestaticconstexpr

isUpperTriangular()

template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< UpperTriangular, X > > = 0, If< IsInvocable< IsApprox, ResultOf< UpperTriangular, X >, X > > = 0, class TT = typename R::Value>

static constexpr auto pRC::isUpperTriangular ( X && a, TT const & tolerance = NumericLimits<TT>::tolerance() )

inlinestaticconstexpr

isZero() [1/3]

template<class T , T V, If< IsIntegral< T > > = 0>

static constexpr auto pRC::isZero ( Constant< T, V > const )

inlinestaticconstexpr

isZero() [2/3]

template<class T , If< IsIntegral< T > > = 0>

static constexpr auto pRC::isZero ( T const a )

inlinestaticconstexpr

isZero() [3/3]

template<class X , class R = RemoveReference<X>, class TT = typename R::Value, If< IsValue< TT > > = 0, If< IsDefined< Zero< R > > > = 0, If< IsInvocable< Zero< R > > > = 0, If< IsInvocable< AbsoluteError, X, R > > = 0>

static constexpr auto pRC::isZero ( X && a, TT const & tolerance = NumericLimits<TT>::tolerance() )

inlinestaticconstexpr

JacobiRotation() [1/4]

template<class T , Size M, Size N>

pRC::JacobiRotation	(	Tensor< T, M, N > const &	a,
		Index const	p,
		Index const	q ) -> JacobiRotation< T >

JacobiRotation() [2/4]

template<class T , Size N>

pRC::JacobiRotation	(	Tensor< T, N > const &	a,
		Index const	p,
		Index const	q ) -> JacobiRotation< T >

JacobiRotation() [3/4]

template<class V , class T , Size M, Size N>

pRC::JacobiRotation	(	TensorViews::View< T, Sizes< M, N >, V > const &	a,
		Index const	p,
		Index const	q ) -> JacobiRotation< T >

JacobiRotation() [4/4]

template<class V , class T , Size N>

pRC::JacobiRotation	(	TensorViews::View< T, Sizes< N >, V > const &	a,
		Index const	p,
		Index const	q ) -> JacobiRotation< T >

kroneckerProduct() [1/2]

template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< IsTensorish< RA > > = 0, If< IsInvocable< View, XA > > = 0, If< IsTensorish< RB > > = 0, If< IsInvocable< View, XB > > = 0, If< IsSame< typename RA::Dimension, typename RB::Dimension > > = 0, class EA = ResultOf<XA, typename RA::Subscripts>, class EB = ResultOf<XB, typename RB::Subscripts>, If< IsInvocable< Mul, EA, EB > > = 0>

static constexpr auto pRC::kroneckerProduct ( XA && a, XB && b )

inlinestaticconstexpr

kroneckerProduct() [2/2]

template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< IsTensorish< RA > > = 0, If< IsTensorish< RB > > = 0, If< Not< All< IsInvocable< View, XA >, IsInvocable< View, XB > > > > = 0, If< IsInvocable< KroneckerProduct, XA &, XB & > > = 0>

static constexpr auto pRC::kroneckerProduct ( XA && a, XB && b )

inlinestaticconstexpr

linearize()

template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsSatisfied<(typename R::Dimension{} > 0)> , If< IsInvocable< Reshape< R::Sizes::size()>, X > > = 0>

static constexpr auto pRC::linearize ( X && a )

inlinestaticconstexpr

log() [1/3]

template<class T >

static constexpr auto pRC::log ( Complex< T > const & a )

inlinestaticconstexpr

log() [2/3]

template<class T , If< IsFloat< T > > = 0>

static constexpr auto pRC::log ( T const & a )

inlinestaticconstexpr

log() [3/3]

template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Log >, X > > = 0>

static constexpr auto pRC::log ( X && a )

inlinestaticconstexpr

log10() [1/3]

template<class T , If< IsInvocable< Log, Complex< T > > > = 0>

static constexpr auto pRC::log10 ( Complex< T > const & a )

inlinestaticconstexpr

log10() [2/3]

template<class T , If< IsFloat< T > > = 0>

static constexpr auto pRC::log10 ( T const & a )

inlinestaticconstexpr

log10() [3/3]

template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Log10 >, X > > = 0>

static constexpr auto pRC::log10 ( X && a )

inlinestaticconstexpr

log2() [1/3]

template<class T , If< IsInvocable< Log, Complex< T > > > = 0>

static constexpr auto pRC::log2 ( Complex< T > const & a )

inlinestaticconstexpr

log2() [2/3]

template<class T , If< IsFloat< T > > = 0>

static constexpr auto pRC::log2 ( T const & a )

inlinestaticconstexpr

log2() [3/3]

template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Log2 >, X > > = 0>

static constexpr auto pRC::log2 ( X && a )

inlinestaticconstexpr

loop() [1/8]

template<class F , class... Xs, If< All< IsTensorish< RemoveReference< Xs > >... > > = 0, If< All< IsInvocable< View, Xs >... > > = 0, If< IsSame< typename RemoveReference< Xs >::Sizes... > > = 0, If< IsInvocable< F, ResultOf< Xs, typename RemoveReference< Xs >::Subscripts >... > > = 0>

static constexpr auto pRC::loop ( F && f, Xs &&... args )

inlinestaticconstexpr

loop() [2/8]

template<class F , class... Xs, If< All< IsTensorish< RemoveReference< Xs > >... > > = 0, If< Not< All< IsInvocable< View, Xs >... > > > = 0, If< IsInvocable< Loop< F >, F, Xs &... > > = 0>

static constexpr auto pRC::loop ( F && f, Xs &&... args )

inlinestaticconstexpr

loop() [3/8]

template<class F , class... Xs, If< All< Any< TensorTrain::IsTensorish< RemoveReference< Xs > >, TensorTrain::IsOperatorish< RemoveReference< Xs > > >... > > = 0, If< All< IsInvocable< View, Xs >... > > = 0, If< IsSame< typename RemoveReference< Xs >::Dimension... > > = 0, If< IsInvocable< F, decltype(declval< Xs >().template core< 0 >())... > >

static constexpr auto pRC::loop ( F && f, Xs &&... args )

inlinestaticconstexpr

loop() [4/8]

template<class F , class... Xs, If< All< Any< TensorTrain::IsTensorish< RemoveReference< Xs > >, TensorTrain::IsOperatorish< RemoveReference< Xs > > >... > > = 0, If< Not< All< IsInvocable< View, Xs >... > > > = 0, If< IsInvocable< Loop< F >, F, Xs &... > > = 0>

static constexpr auto pRC::loop ( F && f, Xs &&... args )

inlinestaticconstexpr

loop() [5/8]

template<class F , class... Xs, If< All< IsTensorish< RemoveReference< Xs > >... > > = 0, If< All< IsInvocable< View, Xs >... > > = 0, If< IsSame< typename RemoveReference< Xs >::Sizes... > > = 0, If< IsInvocable< F, ResultOf< Xs, typename RemoveReference< Xs >::Subscripts >... > > = 0>

static constexpr auto pRC::loop ( Xs &&... args )

inlinestaticconstexpr

loop() [6/8]

template<class F , class... Xs, If< All< IsTensorish< RemoveReference< Xs > >... > > = 0, If< Not< All< IsInvocable< View, Xs >... > > > = 0, If< IsInvocable< Loop< F >, Xs &... > > = 0>

static constexpr auto pRC::loop ( Xs &&... args )

inlinestaticconstexpr

loop() [7/8]

template<class F , class... Xs, If< All< Any< TensorTrain::IsTensorish< RemoveReference< Xs > >, TensorTrain::IsOperatorish< RemoveReference< Xs > > >... > > = 0, If< All< IsInvocable< View, Xs >... > > = 0, If< IsSame< typename RemoveReference< Xs >::Dimension... > > = 0, If< IsInvocable< F, decltype(declval< Xs >().template core< 0 >())... > >

static constexpr auto pRC::loop ( Xs &&... args )

inlinestaticconstexpr

loop() [8/8]

template<class F , class... Xs, If< All< Any< TensorTrain::IsTensorish< RemoveReference< Xs > >, TensorTrain::IsOperatorish< RemoveReference< Xs > > >... > > = 0, If< Not< All< IsInvocable< View, Xs >... > > > = 0, If< IsInvocable< Loop< F >, Xs &... > > = 0>

static constexpr auto pRC::loop ( Xs &&... args )

inlinestaticconstexpr

lowerTriangular()

template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< View, X > > = 0, If< IsSatisfied<(typename R::Dimension()==2)> > = 0>

static constexpr auto pRC::lowerTriangular ( X && a )

inlinestaticconstexpr

lq()

template<Size B = 32, class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsFloat< typename R::Value > > = 0, If< IsSatisfied<(typename R::Dimension()==2)> > = 0>

static constexpr auto pRC::lq ( X && input )

inlinestaticconstexpr

makeConstantSequence()

template<class T , Size N, T V>

static constexpr auto pRC::makeConstantSequence ( )

inlinestaticconstexpr

makeRange()

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 ( )

inlinestaticconstexpr

makeSeries()

template<class T , T N>

static constexpr auto pRC::makeSeries ( )

inlinestaticconstexpr

makeSeriesFor() [1/2]

template<class T >

static constexpr auto pRC::makeSeriesFor ( )

inlinestaticconstexpr

makeSeriesFor() [2/2]

template<class T , class... Ts, If< IsSatisfied<(sizeof...(Ts) > 0)> >

static constexpr auto pRC::makeSeriesFor ( )

inlinestaticconstexpr

matricize()

template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsSatisfied<(typename R::Dimension{} > 0)> , If< IsSatisfied<(isEven(typename R::Dimension()))> > = 0>

static constexpr auto pRC::matricize ( X && a )

inlinestaticconstexpr

max() [1/3]

template<class X >

static constexpr X pRC::max ( X && a )

inlinestaticconstexpr

max() [2/3]

template<class XA , class XB , If< IsInvocable< Greater, XA, XB > > = 0>

static constexpr auto pRC::max ( XA && a, XB && b )

inlinestaticconstexpr

max() [3/3]

template<class XA , class XB , class... Xs, If< IsInvocable< Greater, XA, XB > > = 0, If< All< IsInvocable< Greater, ResultOf< Where, ResultOf< Greater, XA, XB >, XA, XB >, Xs >... > > = 0>

static constexpr auto pRC::max ( XA && a, XB && b, Xs &&... args )

inlinestaticconstexpr

mean()

template<class... Xs, If< IsInvocable< Fold< Add >, Xs... > > = 0>

static constexpr auto pRC::mean ( Xs &&... args )

inlinestaticconstexpr

min() [1/3]

template<class X >

static constexpr X pRC::min ( X && a )

inlinestaticconstexpr

min() [2/3]

template<class XA , class XB , If< IsInvocable< Less, XA, XB > > = 0>

static constexpr auto pRC::min ( XA && a, XB && b )

inlinestaticconstexpr

min() [3/3]

template<class XA , class XB , class... Xs, If< IsInvocable< Less, XA, XB > > = 0, If< All< IsInvocable< Less, ResultOf< Where, ResultOf< Less, XA, XB >, XA, XB >, Xs >... > > = 0>

static constexpr auto pRC::min ( XA && a, XB && b, Xs &&... args )

inlinestaticconstexpr

name() [1/2]

template<class T >

static constexpr auto pRC::name ( )

inlinestaticconstexpr

name() [2/2]

template<class T >

static constexpr auto pRC::name ( )

inlinestaticconstexpr

narrow() [1/2]

template<Index... Ns, class F , class... Xs, If< All< IsTensorish< RemoveReference< Xs > >... > > = 0, If< IsSame< decltype(chip< Ns... >(typename RemoveReference< Xs >::Sizes()))... > , If< True< decltype(chip< Ns... >(makeSeries< Index, Common< typename RemoveReference< Xs >::Dimension... >{}>()))> >

static constexpr auto pRC::narrow ( F && f, Xs &&... args )

inlinestaticconstexpr

narrow() [2/2]

template<class F , Index... Ns, class... Xs, If< All< IsTensorish< RemoveReference< Xs > >... > > = 0, If< IsSame< decltype(chip< Ns... >(typename RemoveReference< Xs >::Sizes()))... > , If< True< decltype(chip< Ns... >(makeSeries< Index, Common< typename RemoveReference< Xs >::Dimension... >{}>()))> >

static constexpr auto pRC::narrow ( Xs &&... args )

inlinestaticconstexpr

norm() [1/4]

template<Index P = 2, Index Q = P, class T >

static constexpr auto pRC::norm ( Complex< T > const & a )

inlinestaticconstexpr

norm() [2/4]

template<Index P = 2, Index Q = P, class T , If< IsValue< T > > = 0>

static constexpr auto pRC::norm ( T const & a )

inlinestaticconstexpr

norm() [3/4]

template<Index P = 2, Index Q = P, class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< View, X > > = 0, If< Any< All< IsSatisfied<(P==1 &&Q==1)>, IsInvocable< Loop< Norm< 1, 1 > >, X >, IsInvocable< Reduce< Add >, ResultOf< Loop< Norm< 1, 1 > >, X > > >, All< IsSatisfied<(P==2 &&Q==1)>, IsInvocable< Loop< Norm< 2, 1 > >, X >, IsInvocable< Reduce< Add >, ResultOf< Loop< Norm< 2, 1 > >, X > > >, All< IsSatisfied<(P==2 &&Q==2)>, IsInvocable< Loop< Norm< 2, 1 > >, X >, IsInvocable< Reduce< Add >, ResultOf< Loop< Norm< 2, 1 > >, X > >, IsInvocable< Sqrt, ResultOf< Reduce< Add >, ResultOf< Loop< Norm< 2, 1 > >, X > > > >, All< IsSatisfied<(P !=Q &&Q==0)>, IsInvocable< Loop< Norm< P, P > >, X >, IsInvocable< Reduce< Max >, ResultOf< Loop< Norm< P, P > >, X > > > > > = 0>

static constexpr auto pRC::norm ( X && a )

inlinestaticconstexpr

norm() [4/4]

template<Index P = 2, Index Q = P, class X , class R = RemoveReference<X>, If< Any< TensorTrain::IsTensorish< R >, TensorTrain::IsOperatorish< R > > > = 0, If< IsSatisfied<(P==2 &&Q==2)> > = 0>

static constexpr auto pRC::norm ( X && a )

inlinestaticconstexpr

offDiagonal()

template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< View, X > > = 0, If< IsSatisfied<(typename R::Dimension()==2)> > = 0>

static constexpr auto pRC::offDiagonal ( X && a )

inlinestaticconstexpr

operator!() [1/2]

static constexpr auto pRC::operator! ( Position const P )

inlinestaticconstexpr

operator!() [2/2]

template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< LogicalNot >, X > > = 0>

static constexpr auto pRC::operator! ( X && a )

inlinestaticconstexpr

operator!=() [1/17]

template<Allocation A1, Allocation A2, class TA , class TB , Size... Ns>

static constexpr auto pRC::operator!= ( CommonArray< A1, TA, Ns... > const & lhs, CommonArray< A2, TB, Ns... > const & rhs )

inlinestaticconstexpr

operator!=() [2/17]

template<class TA , class TB , If< IsInvocable< NotEqual, TA, TB > > = 0>

static constexpr auto pRC::operator!= ( Complex< TA > const & a, Complex< TB > const & b )

inlinestaticconstexpr

operator!=() [3/17]

template<class TA , class TB , If< IsValue< TB > > = 0, If< IsInvocable< NotEqual, TA, TB > > = 0>

static constexpr auto pRC::operator!= ( Complex< TA > const & a, TB const & b )

inlinestaticconstexpr

operator!=() [4/17]

template<class T , T A, T... Bs>

static constexpr auto pRC::operator!= ( Constant< T, A > const , Sequence< T, Bs... > const  )

inlinestaticconstexpr

operator!=() [5/17]

template<class T >

constexpr auto pRC::operator!= ( GaussianDistribution< T > const & lhs, GaussianDistribution< T > const & rhs )

constexpr

operator!=() [6/17]

template<class TA , class TB >

static constexpr auto pRC::operator!= ( JacobiRotation< TA > const & a, JacobiRotation< TB > const & b )

inlinestaticconstexpr

operator!=() [7/17]

template<class T >

constexpr auto pRC::operator!= ( LaplaceDistribution< T > const & lhs, LaplaceDistribution< T > const & rhs )

constexpr

operator!=() [8/17]

template<class T , T... As, T B>

static constexpr auto pRC::operator!= ( Sequence< T, As... > const , Constant< T, B > const  )

inlinestaticconstexpr

operator!=() [9/17]

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  )

inlinestaticconstexpr

operator!=() [10/17]

template<Size... Ns>

static constexpr auto pRC::operator!= ( Subscripts< Ns... > const & lhs, Subscripts< Ns... > const & rhs )

inlinestaticconstexpr

operator!=() [11/17]

template<class TA , class TB , If< IsValue< TA > > = 0, If< IsInvocable< NotEqual, TA, TB > > = 0>

static constexpr auto pRC::operator!= ( TA const & a, Complex< TB > const & b )

inlinestaticconstexpr

operator!=() [12/17]

template<class TA , class TB , If< IsValue< TA > > = 0, If< IsValue< TB > > = 0>

static constexpr auto pRC::operator!= ( TA const & a, TB const & b )

inlinestaticconstexpr

operator!=() [13/17]

template<class T >

constexpr auto pRC::operator!= ( UniformDistribution< T > const & lhs, UniformDistribution< T > const & rhs )

constexpr

operator!=() [14/17]

template<class X >

static constexpr auto pRC::operator!= ( X && a, Zero<> const  )

inlinestaticconstexpr

operator!=() [15/17]

template<class XA , class XB , If< IsTensorish< RemoveReference< XA > > > = 0, If< IsTensorish< RemoveReference< XB > > > = 0, If< IsInvocable< Loop< NotEqual >, XA, XB > > = 0>

static constexpr auto pRC::operator!= ( XA && a, XB && b )

inlinestaticconstexpr

operator!=() [16/17]

template<class X >

static constexpr auto pRC::operator!= ( Zero<> const , X && b )

inlinestaticconstexpr

operator!=() [17/17]

static constexpr auto pRC::operator!= ( Zero<> const , Zero<> const  )

inlinestaticconstexpr

operator%() [1/5]

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  )

inlinestaticconstexpr

operator%() [2/5]

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  )

inlinestaticconstexpr

operator%() [3/5]

template<Size... Ns, Size... Ss, If< IsSatisfied<(sizeof...(Ns)==sizeof...(Ss))> > = 0>

static constexpr auto pRC::operator% ( Subscripts< Ns... > const & lhs, Sizes< Ss... > const  )

inlinestaticconstexpr

operator%() [4/5]

template<class TA , class TB , If< IsInteger< TA > > = 0, If< IsInteger< TB > > = 0>

static constexpr auto pRC::operator% ( TA const & a, TB const & b )

inlinestaticconstexpr

operator%() [5/5]

template<class XA , class XB , If< IsTensorish< RemoveReference< XA > > > = 0, If< IsTensorish< RemoveReference< XB > > > = 0, If< IsInvocable< Loop< Mod >, XA, XB > > = 0>

static constexpr auto pRC::operator% ( XA && a, XB && b )

inlinestaticconstexpr

operator&&()

template<class XA , class XB , If< IsTensorish< RemoveReference< XA > > > = 0, If< IsTensorish< RemoveReference< XB > > > = 0, If< IsInvocable< Loop< LogicalAnd >, XA, XB > > = 0>

static constexpr auto pRC::operator&& ( XA && a, XB && b )

inlinestaticconstexpr

operator*() [1/17]

template<class TA , class TB , If< IsInvocable< Mul, TA, TB > > = 0, If< IsInvocable< Add, TA, TB > > = 0, If< IsInvocable< Sub, TA, TB > > = 0>

static constexpr auto pRC::operator* ( Complex< TA > const & a, Complex< TB > const & b )

inlinestaticconstexpr

operator*() [2/17]

template<class TA , class TB , If< IsValue< TB > > = 0, If< IsInvocable< Mul, TA, TB > > = 0>

static constexpr auto pRC::operator* ( Complex< TA > const & a, TB const & b )

inlinestaticconstexpr

operator*() [3/17]

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  )

inlinestaticconstexpr

operator*() [4/17]

template<class TA , class TB >

static constexpr auto pRC::operator* ( JacobiRotation< TA > const & a, JacobiRotation< TB > const & b )

inlinestaticconstexpr

operator*() [5/17]

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  )

inlinestaticconstexpr

operator*() [6/17]

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  )

inlinestaticconstexpr

operator*() [7/17]

template<Size... Ns, Size... Ss, If< IsSatisfied<(sizeof...(Ns)==sizeof...(Ss))> > = 0>

static constexpr auto pRC::operator* ( Sizes< Ss... > const , Subscripts< Ns... > const & rhs )

inlinestaticconstexpr

operator*() [8/17]

template<Size... Ns, Size... Ss, If< IsSatisfied<(sizeof...(Ns)==sizeof...(Ss))> > = 0>

static constexpr auto pRC::operator* ( Subscripts< Ns... > const & lhs, Sizes< Ss... > const  )

inlinestaticconstexpr

operator*() [9/17]

template<class TA , class TB , If< IsValue< TA > > = 0, If< IsInvocable< Mul, TA, TB > > = 0>

static constexpr auto pRC::operator* ( TA const & a, Complex< TB > const & b )

inlinestaticconstexpr

operator*() [10/17]

template<class TA , class TB , If< IsFloat< TA > > = 0, If< IsFloat< TB > > = 0>

static constexpr auto pRC::operator* ( TA const & a, TB const & b )

inlinestaticconstexpr

operator*() [11/17]

template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< IsTensorish< RA > > = 0, If< IsTensorish< RB > > = 0, class DA = typename RA::Dimension, class DB = typename RB::Dimension, If< IsSatisfied<(DA()==0||DB()==0)> > = 0, If< IsInvocable< TensorProduct, XA, XB > > = 0>

static constexpr auto pRC::operator* ( XA && a, XB && b )

inlinestaticconstexpr

operator*() [12/17]

template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< IsTensorish< RA > > = 0, If< Any< IsValue< RB >, IsComplex< RB > > > = 0, If< IsInvocable< Mul, XA, decltype(unit< Tensor< RB > >(declval< XB >()))> >

static constexpr auto pRC::operator* ( XA && a, XB && b )

inlinestaticconstexpr

operator*() [13/17]

template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< IsTensorish< RA > > = 0, If< IsTensorish< RB > > = 0, class DA = typename RA::Dimension, class DB = typename RB::Dimension, class SA = typename RA::Sizes, class SB = typename RB::Sizes, If< IsSatisfied<(isEven(DA()) &&DA()/2==DB())> > = 0, If< IsSame< decltype(cut< 2, 1 >(SA())), SB > , If< IsInvocable< Contract< DB{}, 0 >, XA, XB > > = 0>

static constexpr auto pRC::operator* ( XA && a, XB && b )

inlinestaticconstexpr

operator*() [14/17]

template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< Any< TensorTrain::IsTensorish< RA >, TensorTrain::IsOperatorish< RA > > > = 0, If< IsInvocable< View, XA > > = 0, If< Any< IsValue< RB >, IsComplex< RB > > > = 0, If< IsInvocable< Mul, typename RA::Type, RB const & > > = 0>

static constexpr auto pRC::operator* ( XA && a, XB && b )

inlinestaticconstexpr

operator*() [15/17]

template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< Any< TensorTrain::IsTensorish< RA >, TensorTrain::IsOperatorish< RA > > > = 0, If< IsTensorish< RB > > = 0, If< IsInvocable< Mul, XA, typename RB::Type > > = 0>

static constexpr auto pRC::operator* ( XA && a, XB && b )

inlinestaticconstexpr

operator*() [16/17]

template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< TensorTrain::IsOperatorish< RA > > = 0, If< IsInvocable< View, XA > > = 0, If< TensorTrain::IsTensorish< RB > > = 0, If< IsInvocable< View, XB > > = 0, If< IsSame< typename RA::N, typename RB::N > > = 0>

static constexpr auto pRC::operator* ( XA && a, XB && b )

inlinestaticconstexpr

operator*() [17/17]

template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< Any< TensorTrain::IsOperatorish< RA >, TensorTrain::IsTensorish< RA > > > = 0, If< Any< TensorTrain::IsOperatorish< RB >, TensorTrain::IsTensorish< RB > > > = 0, If< Not< All< IsInvocable< View, XA >, IsInvocable< View, XB > > > > = 0, If< IsInvocable< Mul, XA &, XB & > > = 0>

static constexpr auto pRC::operator* ( XA && a, XB && b )

inlinestaticconstexpr

operator+() [1/18]

template<Size M, Size N>

static constexpr auto pRC::operator+ ( char const (&) lhs[M], String< N > const & rhs )

inlinestaticconstexpr

operator+() [2/18]

template<class T >

static constexpr auto pRC::operator+ ( Complex< T > const & a )

inlinestaticconstexpr

operator+() [3/18]

template<class TA , class TB , If< IsInvocable< Add, TA, TB > > = 0>

static constexpr auto pRC::operator+ ( Complex< TA > const & a, Complex< TB > const & b )

inlinestaticconstexpr

operator+() [4/18]

template<class TA , class TB , If< IsValue< TB > > = 0, If< IsInvocable< Add, TA, TB > > = 0>

static constexpr auto pRC::operator+ ( Complex< TA > const & a, TB const & b )

inlinestaticconstexpr

operator+() [5/18]

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  )

inlinestaticconstexpr

operator+() [6/18]

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  )

inlinestaticconstexpr

operator+() [7/18]

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  )

inlinestaticconstexpr

operator+() [8/18]

template<Size M, Size N>

static constexpr auto pRC::operator+ ( String< M > const & lhs, char const (&) rhs[N] )

inlinestaticconstexpr

operator+() [9/18]

template<Size M, Size N>

static constexpr auto pRC::operator+ ( String< M > const & lhs, String< N > const & rhs )

inlinestaticconstexpr

operator+() [10/18]

template<Size... Ns>

static constexpr auto pRC::operator+ ( Subscripts< Ns... > const & lhs, Subscripts< Ns... > const & rhs )

inlinestaticconstexpr

operator+() [11/18]

template<class T , If< IsValue< T > > = 0>

static constexpr auto pRC::operator+ ( T const & a )

inlinestaticconstexpr

operator+() [12/18]

template<class TA , class TB , If< IsValue< TA > > = 0, If< IsInvocable< Add, TA, TB > > = 0>

static constexpr auto pRC::operator+ ( TA const & a, Complex< TB > const & b )

inlinestaticconstexpr

operator+() [13/18]

template<class TA , class TB , If< IsFloat< TA > > = 0, If< IsFloat< TB > > = 0>

static constexpr auto pRC::operator+ ( TA const & a, TB const & b )

inlinestaticconstexpr

operator+() [14/18]

template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Plus >, X > > = 0>

static constexpr auto pRC::operator+ ( X && a )

inlinestaticconstexpr

operator+() [15/18]

template<class X , class R = RemoveReference<X>, If< Any< TensorTrain::IsTensorish< R >, TensorTrain::IsOperatorish< R > > > = 0, If< IsInvocable< Loop< Plus >, X > > = 0>

static constexpr auto pRC::operator+ ( X && a )

inlinestaticconstexpr

operator+() [16/18]

template<class XA , class XB , If< IsTensorish< RemoveReference< XA > > > = 0, If< IsTensorish< RemoveReference< XB > > > = 0, If< IsInvocable< Loop< Add >, XA, XB > > = 0>

static constexpr auto pRC::operator+ ( XA && a, XB && b )

inlinestaticconstexpr

operator+() [17/18]

template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< TensorTrain::IsOperatorish< RA > > = 0, If< TensorTrain::IsOperatorish< RB > > = 0, If< IsSame< typename RA::Sizes, typename RB::Sizes > > = 0, If< HasCommon< typename RA::Type, typename RB::Type > > = 0>

static constexpr auto pRC::operator+ ( XA && a, XB && b )

inlinestaticconstexpr

operator+() [18/18]

template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< TensorTrain::IsTensorish< RA > > = 0, If< TensorTrain::IsTensorish< RB > > = 0, If< IsSame< typename RA::Sizes, typename RB::Sizes > > = 0, If< HasCommon< typename RA::Type, typename RB::Type > > = 0>

static constexpr auto pRC::operator+ ( XA && a, XB && b )

inlinestaticconstexpr

operator,()

template<class T , T... As, T... Bs>

static constexpr auto pRC::operator, ( Sequence< T, As... > const , Sequence< T, Bs... > const  )

inlinestaticconstexpr

operator-() [1/14]

template<class T >

static constexpr auto pRC::operator- ( Complex< T > const & a )

inlinestaticconstexpr

operator-() [2/14]

template<class TA , class TB , If< IsInvocable< Sub, TA, TB > > = 0>

static constexpr auto pRC::operator- ( Complex< TA > const & a, Complex< TB > const & b )

inlinestaticconstexpr

operator-() [3/14]

template<class TA , class TB , If< IsValue< TB > > = 0, If< IsInvocable< Sub, TA, TB > > = 0>

static constexpr auto pRC::operator- ( Complex< TA > const & a, TB const & b )

inlinestaticconstexpr

operator-() [4/14]

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  )

inlinestaticconstexpr

operator-() [5/14]

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  )

inlinestaticconstexpr

operator-() [6/14]

template<class T , T... Is, If< IsInvocable< Minus, T > > = 0>

static constexpr auto pRC::operator- ( Sequence< T, Is... > const )

inlinestaticconstexpr

operator-() [7/14]

template<Size... Ns>

static constexpr auto pRC::operator- ( Subscripts< Ns... > const & lhs, Subscripts< Ns... > const & rhs )

inlinestaticconstexpr

operator-() [8/14]

template<class T , If< IsValue< T > > = 0>

static constexpr auto pRC::operator- ( T const & a )

inlinestaticconstexpr

operator-() [9/14]

template<class TA , class TB , If< IsValue< TA > > = 0, If< IsInvocable< Sub, TA, TB > > = 0>

static constexpr auto pRC::operator- ( TA const & a, Complex< TB > const & b )

inlinestaticconstexpr

operator-() [10/14]

template<class TA , class TB , If< IsFloat< TA > > = 0, If< IsFloat< TB > > = 0>

static constexpr auto pRC::operator- ( TA const & a, TB const & b )

inlinestaticconstexpr

operator-() [11/14]

template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Minus >, X > > = 0>

static constexpr auto pRC::operator- ( X && a )

inlinestaticconstexpr

operator-() [12/14]

template<class X , class R = RemoveReference<X>, If< Any< TensorTrain::IsTensorish< R >, TensorTrain::IsOperatorish< R > > > = 0>

static constexpr auto pRC::operator- ( X && a )

inlinestaticconstexpr

operator-() [13/14]

template<class XA , class XB , If< IsTensorish< RemoveReference< XA > > > = 0, If< IsTensorish< RemoveReference< XB > > > = 0, If< IsInvocable< Loop< Sub >, XA, XB > > = 0>

static constexpr auto pRC::operator- ( XA && a, XB && b )

inlinestaticconstexpr

operator-() [14/14]

template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< Any< All< TensorTrain::IsTensorish< RA >, TensorTrain::IsTensorish< RB > >, All< TensorTrain::IsOperatorish< RA >, TensorTrain::IsOperatorish< RB > > > > = 0, If< IsInvocable< Minus, XB > > = 0, If< IsInvocable< Add, XA, ResultOf< Minus, XB > > > = 0>

static constexpr auto pRC::operator- ( XA && a, XB && b )

inlinestaticconstexpr

operator/() [1/12]

template<class TA , class TB >

static constexpr auto pRC::operator/ ( Complex< TA > const & a, Complex< TB > const & b )

inlinestaticconstexpr

operator/() [2/12]

template<class TA , class TB , If< IsValue< TB > > = 0, If< IsInvocable< Div, TA, TB > > = 0>

static constexpr auto pRC::operator/ ( Complex< TA > const & a, TB const & b )

inlinestaticconstexpr

operator/() [3/12]

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  )

inlinestaticconstexpr

operator/() [4/12]

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  )

inlinestaticconstexpr

operator/() [5/12]

template<Size... Ns, Size... Ss, If< IsSatisfied<(sizeof...(Ns)==sizeof...(Ss))> > = 0>

static constexpr auto pRC::operator/ ( Subscripts< Ns... > const & lhs, Sizes< Ss... > const  )

inlinestaticconstexpr

operator/() [6/12]

template<class TA , class TB , If< IsValue< TA > > = 0>

static constexpr auto pRC::operator/ ( TA const & a, Complex< TB > const & b )

inlinestaticconstexpr

operator/() [7/12]

template<class TA , class TB , If< IsFloat< TA > > = 0, If< IsFloat< TB > > = 0>

static constexpr auto pRC::operator/ ( TA const & a, TB const & b )

inlinestaticconstexpr

operator/() [8/12]

template<class XA , class XB , If< IsTensorish< RemoveReference< XA > > > = 0, If< IsTensorish< RemoveReference< XB > > > = 0, If< IsInvocable< Loop< Div >, XA, XB > > = 0>

static constexpr auto pRC::operator/ ( XA && a, XB && b )

inlinestaticconstexpr

operator/() [9/12]

template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< IsTensorish< RA > > = 0, If< IsTensorish< RB > > = 0, class DA = typename RA::Dimension, class DB = typename RB::Dimension, If< IsSatisfied<(DA()==0 &&DB() !=0)> > = 0, If< IsInvocable< Div, decltype(unit< typename RB::template ChangeType< typename RA::Type > >(declval< XA >()())), XB > >

static constexpr auto pRC::operator/ ( XA && a, XB && b )

inlinestaticconstexpr

operator/() [10/12]

template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< IsTensorish< RA > > = 0, If< Any< IsValue< RB >, IsComplex< RB > > > = 0, If< IsInvocable< Div, XA, decltype(unit< Tensor< RB > >(declval< XB >()))> >

static constexpr auto pRC::operator/ ( XA && a, XB && b )

inlinestaticconstexpr

operator/() [11/12]

template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< Any< TensorTrain::IsTensorish< RA >, TensorTrain::IsOperatorish< RA > > > = 0, If< IsInvocable< View, XA > > = 0, If< Any< IsValue< RB >, IsComplex< RB > > > = 0, If< IsInvocable< Div, typename RA::Type, RB const & > > = 0>

static constexpr auto pRC::operator/ ( XA && a, XB && b )

inlinestaticconstexpr

operator/() [12/12]

template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< Any< TensorTrain::IsTensorish< RA >, TensorTrain::IsOperatorish< RA > > > = 0, If< IsTensorish< RB > > = 0, If< IsInvocable< Div, XA, typename RB::Type > > = 0>

static constexpr auto pRC::operator/ ( XA && a, XB && b )

inlinestaticconstexpr

operator<() [1/9]

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  )

inlinestaticconstexpr

operator<() [2/9]

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  )

inlinestaticconstexpr

operator<() [3/9]

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  )

inlinestaticconstexpr

operator<() [4/9]

template<class TA , class TB , If< IsValue< TA > > = 0, If< IsValue< TB > > = 0, If< Any< IsFloat< TA >, IsFloat< TB > > > = 0>

static constexpr auto pRC::operator< ( TA const & a, TB const & b )

inlinestaticconstexpr

operator<() [5/9]

template<class TA , class TB , If< IsInteger< TA > > = 0, If< IsInteger< TB > > = 0>

static constexpr auto pRC::operator< ( TA const & a, TB const & b )

inlinestaticconstexpr

operator<() [6/9]

template<class X >

static constexpr auto pRC::operator< ( X && a, Zero<> const  )

inlinestaticconstexpr

operator<() [7/9]

template<class XA , class XB , If< IsTensorish< RemoveReference< XA > > > = 0, If< IsTensorish< RemoveReference< XB > > > = 0, If< IsInvocable< Loop< Less >, XA, XB > > = 0>

static constexpr auto pRC::operator< ( XA && a, XB && b )

inlinestaticconstexpr

operator<() [8/9]

template<class X >

static constexpr auto pRC::operator< ( Zero<> const , X && b )

inlinestaticconstexpr

operator<() [9/9]

static constexpr auto pRC::operator< ( Zero<> const , Zero<> const  )

inlinestaticconstexpr

operator<=() [1/8]

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  )

inlinestaticconstexpr

operator<=() [2/8]

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  )

inlinestaticconstexpr

operator<=() [3/8]

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  )

inlinestaticconstexpr

operator<=() [4/8]

template<class TA , class TB , If< IsValue< TA > > = 0, If< IsValue< TB > > = 0>

static constexpr auto pRC::operator<= ( TA const & a, TB const & b )

inlinestaticconstexpr

operator<=() [5/8]

template<class X >

static constexpr auto pRC::operator<= ( X && a, Zero<> const  )

inlinestaticconstexpr

operator<=() [6/8]

template<class XA , class XB , If< IsTensorish< RemoveReference< XA > > > = 0, If< IsTensorish< RemoveReference< XB > > > = 0, If< IsInvocable< Loop< LessEqual >, XA, XB > > = 0>

static constexpr auto pRC::operator<= ( XA && a, XB && b )

inlinestaticconstexpr

operator<=() [7/8]

template<class X >

static constexpr auto pRC::operator<= ( Zero<> const , X && b )

inlinestaticconstexpr

operator<=() [8/8]

static constexpr auto pRC::operator<= ( Zero<> const , Zero<> const  )

inlinestaticconstexpr

operator==() [1/18]

template<Allocation A1, Allocation A2, class TA , class TB , Size... Ns, If< IsInvocable< Equal, TA, TB > > = 0>

static constexpr auto pRC::operator== ( CommonArray< A1, TA, Ns... > const & lhs, CommonArray< A2, TB, Ns... > const & rhs )

inlinestaticconstexpr

operator==() [2/18]

template<class TA , class TB , If< IsInvocable< Equal, TA, TB > > = 0>

static constexpr auto pRC::operator== ( Complex< TA > const & a, Complex< TB > const & b )

inlinestaticconstexpr

operator==() [3/18]

template<class TA , class TB , If< IsValue< TB > > = 0, If< IsInvocable< Equal, TA, TB > > = 0>

static constexpr auto pRC::operator== ( Complex< TA > const & a, TB const & b )

inlinestaticconstexpr

operator==() [4/18]

template<class T , T A, T... Bs>

static constexpr auto pRC::operator== ( Constant< T, A > const , Sequence< T, Bs... > const  )

inlinestaticconstexpr

operator==() [5/18]

template<class T >

constexpr auto pRC::operator== ( GaussianDistribution< T > const & lhs, GaussianDistribution< T > const & rhs )

constexpr

operator==() [6/18]

template<class TA , class TB >

static constexpr auto pRC::operator== ( JacobiRotation< TA > const & a, JacobiRotation< TB > const & b )

inlinestaticconstexpr

operator==() [7/18]

template<class T >

constexpr auto pRC::operator== ( LaplaceDistribution< T > const & lhs, LaplaceDistribution< T > const & rhs )

constexpr

operator==() [8/18]

template<class T , T... As, T B>

static constexpr auto pRC::operator== ( Sequence< T, As... > const , Constant< T, B > const  )

inlinestaticconstexpr

operator==() [9/18]

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  )

inlinestaticconstexpr

operator==() [10/18]

template<Size... Ns>

static constexpr auto pRC::operator== ( Subscripts< Ns... > const & lhs, Subscripts< Ns... > const & rhs )

inlinestaticconstexpr

operator==() [11/18]

template<class TA , class TB , If< IsValue< TA > > = 0, If< IsInvocable< Equal, TA, TB > > = 0>

static constexpr auto pRC::operator== ( TA const & a, Complex< TB > const & b )

inlinestaticconstexpr

operator==() [12/18]

template<class TA , class TB , If< IsValue< TA > > = 0, If< IsValue< TB > > = 0, If< Any< IsFloat< TA >, IsFloat< TB > > > = 0>

static constexpr auto pRC::operator== ( TA const & a, TB const & b )

inlinestaticconstexpr

operator==() [13/18]

template<class TA , class TB , If< IsInteger< TA > > = 0, If< IsInteger< TB > > = 0>

static constexpr auto pRC::operator== ( TA const & a, TB const & b )

inlinestaticconstexpr

operator==() [14/18]

template<class T >

constexpr auto pRC::operator== ( UniformDistribution< T > const & lhs, UniformDistribution< T > const & rhs )

constexpr

operator==() [15/18]

template<class X >

static constexpr auto pRC::operator== ( X && a, Zero<> const  )

inlinestaticconstexpr

operator==() [16/18]

template<class XA , class XB , If< IsTensorish< RemoveReference< XA > > > = 0, If< IsTensorish< RemoveReference< XB > > > = 0, If< IsInvocable< Loop< Equal >, XA, XB > > = 0>

static constexpr auto pRC::operator== ( XA && a, XB && b )

inlinestaticconstexpr

operator==() [17/18]

template<class X >

static constexpr auto pRC::operator== ( Zero<> const , X && b )

inlinestaticconstexpr

operator==() [18/18]

static constexpr auto pRC::operator== ( Zero<> const , Zero<> const  )

inlinestaticconstexpr

operator>() [1/8]

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  )

inlinestaticconstexpr

operator>() [2/8]

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  )

inlinestaticconstexpr

operator>() [3/8]

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  )

inlinestaticconstexpr

operator>() [4/8]

template<class TA , class TB , If< IsValue< TA > > = 0, If< IsValue< TB > > = 0>

static constexpr auto pRC::operator> ( TA const & a, TB const & b )

inlinestaticconstexpr

operator>() [5/8]

template<class X >

static constexpr auto pRC::operator> ( X && a, Zero<> const  )

inlinestaticconstexpr

operator>() [6/8]

template<class XA , class XB , If< IsTensorish< RemoveReference< XA > > > = 0, If< IsTensorish< RemoveReference< XB > > > = 0, If< IsInvocable< Loop< Greater >, XA, XB > > = 0>

static constexpr auto pRC::operator> ( XA && a, XB && b )

inlinestaticconstexpr

operator>() [7/8]

template<class X >

static constexpr auto pRC::operator> ( Zero<> const , X && b )

inlinestaticconstexpr

operator>() [8/8]

static constexpr auto pRC::operator> ( Zero<> const , Zero<> const  )

inlinestaticconstexpr

operator>=() [1/8]

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  )

inlinestaticconstexpr

operator>=() [2/8]

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  )

inlinestaticconstexpr

operator>=() [3/8]

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  )

inlinestaticconstexpr

operator>=() [4/8]

template<class TA , class TB , If< IsValue< TA > > = 0, If< IsValue< TB > > = 0>

static constexpr auto pRC::operator>= ( TA const & a, TB const & b )

inlinestaticconstexpr

operator>=() [5/8]

template<class X >

static constexpr auto pRC::operator>= ( X && a, Zero<> const  )

inlinestaticconstexpr

operator>=() [6/8]

template<class XA , class XB , If< IsTensorish< RemoveReference< XA > > > = 0, If< IsTensorish< RemoveReference< XB > > > = 0, If< IsInvocable< Loop< GreaterEqual >, XA, XB > > = 0>

static constexpr auto pRC::operator>= ( XA && a, XB && b )

inlinestaticconstexpr

operator>=() [7/8]

template<class X >

static constexpr auto pRC::operator>= ( Zero<> const , X && b )

inlinestaticconstexpr

operator>=() [8/8]

static constexpr auto pRC::operator>= ( Zero<> const , Zero<> const  )

inlinestaticconstexpr

operator||()

template<class XA , class XB , If< IsTensorish< RemoveReference< XA > > > = 0, If< IsTensorish< RemoveReference< XB > > > = 0, If< IsInvocable< Loop< LogicalOr >, XA, XB > > = 0>

static constexpr auto pRC::operator|| ( XA && a, XB && b )

inlinestaticconstexpr

optimizationBarrier()

template<class T , class... Ts>

static auto pRC::optimizationBarrier ( const T & basic, Ts &... basics )

inlinestatic

optimize() [1/4]

template<class Optimizer , class XX , class RX = RemoveReference<XX>, class TX = typename RX::Type, class VX = typename TX::Value, If< IsTensorish< RX > > = 0, class RXE = RemoveConstReference<ResultOf<Eval, XX>>, class FF , If< IsInvocable< FF, RXE const &, RXE & > > = 0, If< IsFloat< ResultOf< FF, RXE const &, RXE & > > > = 0, class FC , If< IsInvocable< FC, RXE & > > = 0, class VT = VX, If< All< IsFloat< VX >, IsFloat< VT > > > = 0, If< IsInvocable< Optimizer, XX, FF, FC, VT > > = 0>

static constexpr auto pRC::optimize ( Optimizer && optimizer, XX && x, FF && function, FC && callback, VT const & tolerance = NumericLimits<VT>::tolerance() )

inlinestaticconstexpr

optimize() [2/4]

template<class Optimizer , class XX , class RX = RemoveReference<XX>, class TX = typename RX::Type, class VX = typename TX::Value, If< IsTensorish< RX > > = 0, class RXE = RemoveConstReference<ResultOf<Eval, XX>>, class FF , If< IsInvocable< FF, RXE const &, RXE & > > = 0, If< IsFloat< ResultOf< FF, RXE const &, RXE & > > > = 0, class VT = VX, If< All< IsFloat< VX >, IsFloat< VT > > > = 0, If< IsInvocable< Optimizer, XX, FF, void(RXE const), VT > > = 0>

static constexpr auto pRC::optimize ( Optimizer && optimizer, XX && x, FF && function, VT const & tolerance = NumericLimits<VT>::tolerance() )

inlinestaticconstexpr

optimize() [3/4]

template<class Optimizer , class XX , class RX = RemoveReference<XX>, class TX = typename RX::Type, class VX = typename TX::Value, If< IsTensorish< RX > > = 0, class RXE = RemoveConstReference<ResultOf<Eval, XX>>, class FF , If< IsInvocable< FF, RXE const &, RXE & > > = 0, If< IsFloat< ResultOf< FF, RXE const &, RXE & > > > = 0, class FC , If< IsInvocable< FC, RXE & > > = 0, class VT = VX, If< All< IsFloat< VX >, IsFloat< VT > > > = 0, If< IsInvocable< Optimizer, XX, FF, FC, VT > > = 0>

static constexpr auto pRC::optimize ( XX && x, FF && function, FC && callback, VT const & tolerance = NumericLimits<VT>::tolerance() )

inlinestaticconstexpr

optimize() [4/4]

template<class Optimizer , class XX , class RX = RemoveReference<XX>, class TX = typename RX::Type, class VX = typename TX::Value, If< IsTensorish< RX > > = 0, class RXE = RemoveConstReference<ResultOf<Eval, XX>>, class FF , If< IsInvocable< FF, RXE const &, RXE & > > = 0, If< IsFloat< ResultOf< FF, RXE const &, RXE & > > > = 0, class VT = VX, If< All< IsFloat< VX >, IsFloat< VT > > > = 0, If< IsInvocable< Optimizer, XX, FF, void(RXE const), VT > > = 0>

static constexpr auto pRC::optimize ( XX && x, FF && function, VT const & tolerance = NumericLimits<VT>::tolerance() )

inlinestaticconstexpr

orthogonalize()

template<Position P, class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsFloat< typename R::Value > > = 0, If< IsSatisfied<(P==Position::Left||P==Position::Right)> > = 0>

static constexpr auto pRC::orthogonalize ( X && a )

inlinestaticconstexpr

outerProduct() [1/2]

template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< IsTensorish< RA > > = 0, If< IsInvocable< View, XA > > = 0, If< IsTensorish< RB > > = 0, If< IsInvocable< View, XB > > = 0, If< IsInvocable< Conj, XA > > = 0, If< IsInvocable< TensorProduct, XA, ResultOf< Conj, XB > > > = 0>

static constexpr auto pRC::outerProduct ( XA && a, XB && b )

inlinestaticconstexpr

outerProduct() [2/2]

template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< IsTensorish< RA > > = 0, If< IsTensorish< RB > > = 0, If< Not< All< IsInvocable< View, XA >, IsInvocable< View, XB > > > > = 0, If< IsInvocable< OuterProduct, XA &, XB & > > = 0>

static constexpr auto pRC::outerProduct ( XA && a, XB && b )

inlinestaticconstexpr

parameter() [1/4]

template<Context C, class T , class A , class N , class D , If< True< decltype(String(declval< A >()))> , If< True< decltype(String(declval< N >()))> , If< True< decltype(String(declval< D >()))> , If< IsSatisfied<(C==Context::RunTime)> > = 0>

static constexpr auto pRC::parameter ( A && argument, N && name, D && description )

inlinestaticconstexpr

parameter() [2/4]

template<Context C, class T , class A , class N , class D , If< True< decltype(String(declval< A >()))> , If< True< decltype(String(declval< N >()))> , If< True< decltype(String(declval< D >()))> , If< IsSatisfied<(C==Context::CompileTime||C==Context::RunTime)> > = 0>

static constexpr auto pRC::parameter ( A && argument, N && name, D && description, T const & defaultValue )

inlinestaticconstexpr

parameter() [3/4]

template<Context C, class T , class A , class N , class D , If< True< decltype(String(declval< A >()))> , If< True< decltype(String(declval< N >()))> , If< True< decltype(String(declval< D >()))> , If< IsSatisfied<(C==Context::RunTime)> > = 0>

static constexpr auto pRC::parameter ( A && argument, N && name, D && description, T(*)(char const *const) convert )

inlinestaticconstexpr

parameter() [4/4]

template<Context C, class T , class A , class N , class D , If< True< decltype(String(declval< A >()))> , If< True< decltype(String(declval< N >()))> , If< True< decltype(String(declval< D >()))> , If< IsSatisfied<(C==Context::RunTime)> > = 0>

static constexpr auto pRC::parameter ( A && argument, N && name, D && description, T(*)(char const *const) convert, T const & defaultValue )

inlinestaticconstexpr

parse()

template<class N , class D , class... Ps, If< True< decltype(String(declval< N >()))> , If< True< decltype(String(declval< D >()))> >

static constexpr auto pRC::parse ( int const argc, char const *const *const argv, N && appName, D && appDescription, Ps &... parameters )

inlinestaticconstexpr

permute() [1/5]

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 )

inlinestaticconstexpr

permute() [2/5]

template<Index... Ps, Size... Ns, If< IsSatisfied<(sizeof...(Ps)==sizeof...(Ns))> > = 0, If< IsSatisfied<(max(Ps...)< sizeof...(Ns))> > = 0, If< IsUnique< Constant< Index, Ps >... > > = 0>

static constexpr auto pRC::permute ( Subscripts< Ns... > const & arg )

inlinestaticconstexpr

permute() [3/5]

template<Index... Ps, class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< View, X > > = 0, If< IsSatisfied<(sizeof...(Ps)==typename R::Dimension())> > = 0, If< IsSatisfied<(max(Ps...)< typename R::Dimension())> > = 0, If< IsUnique< Constant< Index, Ps >... > > = 0>

static constexpr auto pRC::permute ( X && a )

inlinestaticconstexpr

permute() [4/5]

template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< View, X > > = 0, If< IsSatisfied<(0==typename R::Dimension())> > = 0>

static constexpr auto pRC::permute ( X && a )

inlinestaticconstexpr

permute() [5/5]

template<Index... Ps, class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< Not< IsInvocable< View, X > > > = 0, If< IsInvocable< Permute< Ps... >, X & > > = 0>

static constexpr auto pRC::permute ( X && a )

inlinestaticconstexpr

pi() [1/2]

template<class T , If< IsFloat< T > > = 0>

static constexpr T pRC::pi ( )

inlinestaticconstexpr

pi() [2/2]

template<class T , If< IsInteger< T > > = 0>

static constexpr auto pRC::pi ( )

inlinestaticconstexpr

pick()

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 ... )

inlinestaticconstexpr

polar()

template<class TA , class TB , If< All< IsValue< TA >, IsValue< TB > > > = 0, If< IsInvocable< Cos, TB > > = 0, If< IsInvocable< Sin, TB > > = 0, If< IsInvocable< Mul, TA, TB > > = 0>

static constexpr auto pRC::polar ( TA const & rho, TB const & theta )

inlinestaticconstexpr

pow() [1/5]

template<class B , class N , If< IsFloat< B > > = 0, If< IsFloat< N > > = 0>

static constexpr auto pRC::pow ( B const & base, N const & exp )

inlinestaticconstexpr

pow() [2/5]

template<class X , class Y >

static constexpr auto pRC::pow ( Complex< X > const & x, Complex< Y > const & y )

inlinestaticconstexpr

pow() [3/5]

template<class X , class Y , If< IsValue< Y > > = 0>

static constexpr auto pRC::pow ( Complex< X > const & x, Y const & y )

inlinestaticconstexpr

pow() [4/5]

template<class X , class Y , If< IsValue< X > > = 0>

static constexpr auto pRC::pow ( X const & x, Complex< Y > const & y )

inlinestaticconstexpr

pow() [5/5]

template<class XA , class XB , If< IsTensorish< RemoveReference< XA > > > = 0, If< IsTensorish< RemoveReference< XB > > > = 0, If< IsInvocable< Loop< Pow >, XA, XB > > = 0>

static constexpr auto pRC::pow ( XA && a, XB && b )

inlinestaticconstexpr

print() [1/18]

template<class S >

static auto pRC::print ( Allocation const alloc, S && stream )

inlinestatic

print() [2/18]

static auto pRC::print ( char const *const string, std::FILE * stream )

inlinestatic

print() [3/18]

template<Allocation A, class T , Size... Ns, class S >

static auto pRC::print ( CommonArray< A, T, Ns... > const & arg, S && stream )

inlinestatic

print() [4/18]

template<class T , T V, class S >

static auto pRC::print ( Constant< T, V > const , S && stream )

inlinestatic

print() [5/18]

template<class S >

static auto pRC::print ( Context const context, S && stream )

inlinestatic

print() [6/18]

template<class S >

static auto pRC::print ( Direction const direction, S && stream )

inlinestatic

print() [7/18]

template<Size N, class S >

static auto pRC::print ( Indices< N > const & a, S && stream )

inlinestatic

print() [8/18]

template<Size N, class S >

static auto pRC::print ( SeedSequence< N > const & seq, S && stream )

inlinestatic

print() [9/18]

template<class T , T... Is, class S >

static auto pRC::print ( Sequence< T, Is... > const , S && stream )

inlinestatic

print() [10/18]

template<Size... Ns, class S >

static auto pRC::print ( Sizes< Ns... > const , S && stream )

inlinestatic

print() [11/18]

static auto pRC::print ( std::string const & string, std::FILE * stream )

inlinestatic

print() [12/18]

template<Size N>

static auto pRC::print ( String< N > const & string, std::FILE * stream )

inlinestatic

print() [13/18]

template<Size... Ns, class S >

static auto pRC::print ( Subscripts< Ns... > const & a, S && stream )

inlinestatic

print() [14/18]

template<class T , class S , If< IsComplex< T > > = 0>

static auto pRC::print ( T const & value, S && stream )

inlinestatic

print() [15/18]

template<class T , If< IsFloat< T > > = 0>

static auto pRC::print ( T const & value, std::FILE * stream )

inlinestatic

print() [16/18]

template<class T , If< IsSame< T, Bool > > = 0>

static auto pRC::print ( T const value, std::FILE * stream )

inlinestatic

print() [17/18]

template<class X , class S , class R = RemoveReference<X>, If< IsTensorish< R > > = 0>

static void pRC::print ( X && arg, S && stream )

inlinestatic

print() [18/18]

template<class X , class S , class R = RemoveReference<X>, If< Any< TensorTrain::IsTensorish< R >, TensorTrain::IsOperatorish< R > > > = 0>

static void pRC::print ( X && arg, S && stream )

inlinestatic

qr()

template<Size B = 32, class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsFloat< typename R::Value > > = 0, If< IsSatisfied<(typename R::Dimension()==2)> > = 0>

static constexpr auto pRC::qr ( X && input )

inlinestaticconstexpr

random()

template<class T , class D , If< IsConstructible< Random< T, D >, RandomEngine &, D & > > = 0>

static constexpr auto pRC::random ( RandomEngine & rng, D & distribution )

inlinestaticconstexpr

range() [1/7]

template<Context C, Size I, Size L, Direction D = Direction::Forwards, Size S = 1, class F , class... Xs>

static constexpr auto pRC::range ( F && f, Xs &&... args )

inlinestaticconstexpr

range() [2/7]

template<Size I, Size L, Direction D = Direction::Forwards, Size S = 1, class F , class... Xs>

static constexpr auto pRC::range ( F && f, Xs &&... args )

inlinestaticconstexpr

range() [3/7]

template<Size L, Direction D = Direction::Forwards, Size S = 1, class F , class... Xs>

static constexpr auto pRC::range ( F && f, Xs &&... args )

inlinestaticconstexpr

range() [4/7]

template<Context C, class I , class L , Direction O, class D , class S = decltype(makeConstantSequence<Size, typename I::Dimension{}, 1>()), class F , class... Xs, If< IsSizes< I > > = 0, If< IsSizes< L > > = 0, If< IsSequence< D > > = 0, If< IsSizes< S > > = 0, If< IsSame< Direction, typename D::Type > > = 0, If< IsSame< typename I::Dimension, typename L::Dimension, typename D::Dimension, typename S::Dimension > > = 0, If< IsSatisfied<((L() - I()) % S()==Constant< Size, 0 >())> , If< IsSatisfied<(O==Direction::LeftToRight||O==Direction::RightToLeft)> > = 0>

static constexpr auto pRC::range ( F && f, Xs &&... args )

inlinestaticconstexpr

range() [5/7]

template<Context C, class L , Direction O, class D , class S = decltype(makeConstantSequence<Size, typename L::Dimension{}, 1>()), class F , class... Xs, If< IsSizes< L > > = 0, If< IsSequence< D > > = 0, If< IsSizes< S > > = 0, If< IsSame< Direction, typename D::Type > > = 0, If< IsSame< typename L::Dimension, typename D::Dimension, typename S::Dimension > > = 0, If< IsSatisfied<(L() % S()==Constant< Size, 0 >())> , If< IsSatisfied<(O==Direction::LeftToRight||O==Direction::RightToLeft)> > = 0>

static constexpr auto pRC::range ( F && f, Xs &&... args )

inlinestaticconstexpr

range() [6/7]

template<class I , class L , Direction O, class D , class S = decltype(makeConstantSequence<Size, typename I::Dimension{}, 1>()), class F , class... Xs, If< IsSizes< I > > = 0, If< IsSizes< L > > = 0, If< IsSequence< D > > = 0, If< IsSizes< S > > = 0, If< IsSame< Direction, typename D::Type > > = 0, If< IsSame< typename I::Dimension, typename L::Dimension, typename D::Dimension, typename S::Dimension > > = 0, If< IsSatisfied<((L() - I()) % S()==Constant< Size, 0 >())> , If< IsSatisfied<(O==Direction::LeftToRight||O==Direction::RightToLeft)> > = 0>

static constexpr auto pRC::range ( F && f, Xs &&... args )

inlinestaticconstexpr

range() [7/7]

template<class L , Direction O, class D , class S = decltype(makeConstantSequence<Size, typename L::Dimension{}, 1>()), class F , class... Xs, If< IsSizes< L > > = 0, If< IsSequence< D > > = 0, If< IsSizes< S > > = 0, If< IsSame< Direction, typename D::Type > > = 0, If< IsSame< typename L::Dimension, typename D::Dimension, typename S::Dimension > > = 0, If< IsSatisfied<(L() % S()==Constant< Size, 0 >())> , If< IsSatisfied<(O==Direction::LeftToRight||O==Direction::RightToLeft)> > = 0>

static constexpr auto pRC::range ( F && f, Xs &&... args )

inlinestaticconstexpr

rcp() [1/3]

template<class T >

static constexpr auto pRC::rcp ( Complex< T > const & b )

inlinestaticconstexpr

rcp() [2/3]

template<class T , If< IsValue< T > > = 0>

static constexpr auto pRC::rcp ( T const & a )

inlinestaticconstexpr

rcp() [3/3]

template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Rcp >, X > > = 0>

static constexpr auto pRC::rcp ( X && a )

inlinestaticconstexpr

real() [1/3]

template<class X , If< IsComplex< RemoveReference< X > > > = 0>

static constexpr decltype(auto) pRC::real ( X && a )

inlinestaticconstexpr

real() [2/3]

template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Real >, X > > = 0>

static constexpr auto pRC::real ( X && a )

inlinestaticconstexpr

real() [3/3]

template<class X , If< IsValue< RemoveReference< X > > > = 0>

static constexpr X pRC::real ( X && a )

inlinestaticconstexpr

RecursiveLambda()

template<class X >

pRC::RecursiveLambda

(

X &&

)

-> RecursiveLambda< RemoveReference< X > >

reduce() [1/5]

template<class F , class T , T I>

static constexpr auto pRC::reduce ( Sequence< T, I > const )

inlinestaticconstexpr

reduce() [2/5]

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 )

inlinestaticconstexpr

reduce() [3/5]

template<class F , Index... Is, class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< View, X > > = 0, If< IsSatisfied<(sizeof...(Is)<=typename R::Dimension())> > = 0, If< IsUnique< Constant< Index, Is >... > > = 0, If< IsSatisfied<(max(Is...)< typename R::Dimension())> > = 0, class E = ResultOf<X, typename R::Subscripts>, If< IsInvocable< F, E, E > > = 0, If< IsInvocable< F, decltype(F::template Identity< typename R::Type >()), E > >

static constexpr auto pRC::reduce ( X && a )

inlinestaticconstexpr

reduce() [4/5]

template<class F , class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< View, X > > = 0, class E = ResultOf<X, typename R::Subscripts>, If< IsInvocable< F, E, E > > = 0, If< IsInvocable< F, decltype(F::template Identity< typename R::Type >()), E > >

static constexpr auto pRC::reduce ( X && a )

inlinestaticconstexpr

reduce() [5/5]

template<class F , Index... Is, class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< Not< IsInvocable< View, X > > > = 0, If< IsInvocable< Reduce< F, Is... >, X & > > = 0>

static constexpr auto pRC::reduce ( X && a )

inlinestaticconstexpr

relativeError()

template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< IsFloat< typename RA::Value > > = 0, If< IsFloat< typename RB::Value > > = 0, If< IsInvocable< AbsoluteError, XA, XB > > = 0, If< IsInvocable< Norm<>, XA > > = 0, If< IsInvocable< Div, ResultOf< AbsoluteError, XA, XB >, ResultOf< Norm<>, XA > > > = 0>

static constexpr auto pRC::relativeError ( XA && a, XB && b )

inlinestaticconstexpr

report()

template<class... Ps>

static constexpr auto pRC::report ( Ps &&... parameters )

inlinestaticconstexpr

reshape()

template<Size... Ns, class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< View, X > > = 0, If< IsSatisfied<(Sizes< Ns... >::size()==R::size())> >

static constexpr auto pRC::reshape ( X && a )

inlinestaticconstexpr

restrict() [1/2]

template<Operator::Restrict OR = Operator::Restrict::None, class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0>

static constexpr decltype(auto) pRC::restrict ( X && a )

inlinestaticconstexpr

restrict() [2/2]

template<Operator::Restrict OR = Operator::Restrict::None, class X , class R = RemoveReference<X>, If< TensorTrain::IsOperatorish< R > > = 0>

static constexpr decltype(auto) pRC::restrict ( X && a )

inlinestaticconstexpr

reverse() [1/4]

static constexpr auto pRC::reverse ( Direction const D )

inlinestaticconstexpr

reverse() [2/4]

template<class T , T... Is>

static constexpr auto pRC::reverse ( Sequence< T, Is... > const )

inlinestaticconstexpr

reverse() [3/4]

template<Size... Ns>

static constexpr auto pRC::reverse ( Subscripts< Ns... > const & arg )

inlinestaticconstexpr

reverse() [4/4]

template<Bool... Rs, class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< View, X > > = 0, If< IsSatisfied<(sizeof...(Rs)==typename R::Dimension())> > = 0>

static constexpr auto pRC::reverse ( X && a )

inlinestaticconstexpr

rotate() [1/4]

template<Direction D, Size Step, class T , If< IsSatisfied<(D==Direction::Leftwards||D==Direction::Rightwards)> > = 0>

static constexpr auto pRC::rotate ( Sequence< T > const )

inlinestaticconstexpr

rotate() [2/4]

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 )

inlinestaticconstexpr

rotate() [3/4]

template<Direction D, Size Step, Size... Ns, If< True< decltype(rotate< D, Step >(makeSeriesFor< Index, Ns... >()))> >

static constexpr auto pRC::rotate ( Subscripts< Ns... > const & arg )

inlinestaticconstexpr

rotate() [4/4]

template<Direction D, Size S = 1, class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsSatisfied<(D==Direction::Leftwards||D==Direction::Rightwards)> > = 0>

static constexpr auto pRC::rotate ( X && a )

inlinestaticconstexpr

round() [1/6]

template<std::int64_t D = 0, class T , If< IsInvocable< Round< D >, T > > = 0>

static constexpr auto pRC::round ( Complex< T > const & a )

inlinestaticconstexpr

round() [2/6]

template<std::int64_t D = 0, class T , If< IsFloat< T > > = 0>

static constexpr auto pRC::round ( T const & a )

inlinestaticconstexpr

round() [3/6]

template<std::int64_t D = 0, class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Round< D > >, X > > = 0>

static constexpr auto pRC::round ( X && a )

inlinestaticconstexpr

round() [4/6]

template<class Ranks , class X , class R = RemoveReference<X>, class V = typename R::Value, class VT = V, If< All< IsFloat< V >, IsFloat< VT > > > = 0, If< Any< TensorTrain::IsTensorish< R >, TensorTrain::IsOperatorish< R > > > = 0, If< IsSizes< Ranks > > = 0, If< IsSatisfied<(typename Ranks::Dimension()==typename R::Dimension() - 1)> > = 0>

static constexpr auto pRC::round ( X && a, VT const & tolerance = NumericLimits<VT>::epsilon() )

inlinestaticconstexpr

round() [5/6]

template<class X , class R = RemoveReference<X>, class V = typename R::Value, class VT = V, If< All< IsFloat< V >, IsFloat< VT > > > = 0, If< Any< TensorTrain::IsTensorish< R >, TensorTrain::IsOperatorish< R > > > = 0>

static constexpr auto pRC::round ( X && a, VT const & tolerance = NumericLimits<VT>::epsilon() )

inlinestaticconstexpr

round() [6/6]

template<Size C, class X , class R = RemoveReference<X>, class V = typename R::Value, class VT = V, If< All< IsFloat< V >, IsFloat< VT > > > = 0, If< Any< TensorTrain::IsTensorish< R >, TensorTrain::IsOperatorish< R > > > = 0>

static constexpr auto pRC::round ( X && a, VT const & tolerance = NumericLimits<VT>::epsilon() )

inlinestaticconstexpr

scalar()

template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsSatisfied<(R::Sizes::size()==1)> > = 0, If< IsInvocable< Reshape<>, X > > = 0>

static constexpr auto pRC::scalar ( X && a )

inlinestaticconstexpr

scalarProduct() [1/8]

template<class TA , class TB , If< IsInvocable< Mul, Complex< TA >, Complex< TB > > > = 0>

static constexpr auto pRC::scalarProduct ( Complex< TA > const & a, Complex< TB > const & b )

inlinestaticconstexpr

scalarProduct() [2/8]

template<class TA , class TB , If< IsValue< TB > > = 0, If< IsInvocable< Mul, Complex< TA >, TB > > = 0>

static constexpr auto pRC::scalarProduct ( Complex< TA > const & a, TB const & b )

inlinestaticconstexpr

scalarProduct() [3/8]

template<class TA , class TB , If< IsValue< TA > > = 0, If< IsInvocable< Mul, TA, Complex< TB > > > = 0>

static constexpr auto pRC::scalarProduct ( TA const & a, Complex< TB > const & b )

inlinestaticconstexpr

scalarProduct() [4/8]

template<class TA , class TB , If< IsValue< TA > > = 0, If< IsValue< TB > > = 0>

static constexpr auto pRC::scalarProduct ( TA const & a, TB const & b )

inlinestaticconstexpr

scalarProduct() [5/8]

template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< IsTensorish< RA > > = 0, If< IsInvocable< View, XA > > = 0, If< IsTensorish< RB > > = 0, If< IsInvocable< View, XB > > = 0, If< IsSame< typename RA::Sizes, typename RB::Sizes > > = 0, If< IsInvocable< HadamardProduct, XA, XB > > = 0, If< IsInvocable< Reduce< Add >, ResultOf< HadamardProduct, XA, XB > > > = 0>

static constexpr auto pRC::scalarProduct ( XA && a, XB && b )

inlinestaticconstexpr

scalarProduct() [6/8]

template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< IsTensorish< RA > > = 0, If< IsTensorish< RB > > = 0, If< Not< All< IsInvocable< View, XA >, IsInvocable< View, XB > > > > = 0, If< IsInvocable< ScalarProduct, XA &, XB & > > = 0>

static constexpr auto pRC::scalarProduct ( XA && a, XB && b )

inlinestaticconstexpr

scalarProduct() [7/8]

template<class XA , class XB , If< TensorTrain::IsOperatorish< RemoveReference< XA > > > = 0, If< TensorTrain::IsOperatorish< RemoveReference< XB > > > = 0, If< IsInvocable< HadamardProduct, XA, XB > > = 0>

static constexpr auto pRC::scalarProduct ( XA && a, XB && b )

inlinestaticconstexpr

scalarProduct() [8/8]

template<class XA , class XB , If< TensorTrain::IsTensorish< RemoveReference< XA > > > = 0, If< TensorTrain::IsTensorish< RemoveReference< XB > > > = 0, If< IsInvocable< HadamardProduct, XA, XB > > = 0>

static constexpr auto pRC::scalarProduct ( XA && a, XB && b )

inlinestaticconstexpr

SeedSequence()

template<class... Ts>

pRC::SeedSequence

(

Ts &&

...

)

-> SeedSequence< sizeof...(Ts)>

select() [1/2]

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 )

inlinestaticconstexpr

select() [2/2]

template<class T , T... Is>

static constexpr auto pRC::select ( Sequence< T, Is... > const )

inlinestaticconstexpr

Sequence() [1/2]

template<Size... Ns>

pRC::Sequence

(

Sizes< Ns... > const

)

-> Sequence< Size, Ns... >

Sequence() [2/2]

template<class T , T... Seq>

pRC::Sequence

(

std::integer_sequence< T, Seq... > const

)

-> Sequence< T, Seq... >

sign() [1/3]

template<class T , If< IsInvocable< Sign, T > > = 0>

static constexpr auto pRC::sign ( Complex< T > const & a )

inlinestaticconstexpr

sign() [2/3]

template<class T , If< IsValue< T > > = 0, If< IsSatisfied<(typename T::Signed()==true)> > = 0>

static constexpr auto pRC::sign ( T const & a )

inlinestaticconstexpr

sign() [3/3]

template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Sign >, X > > = 0>

static constexpr auto pRC::sign ( X && a )

inlinestaticconstexpr

sin() [1/3]

template<class T >

static constexpr auto pRC::sin ( Complex< T > const & a )

inlinestaticconstexpr

sin() [2/3]

template<class T , If< IsFloat< T > > = 0>

static constexpr auto pRC::sin ( T const a )

inlinestaticconstexpr

sin() [3/3]

template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Sin >, X > > = 0>

static constexpr auto pRC::sin ( X && a )

inlinestaticconstexpr

sinh() [1/3]

template<class T >

static constexpr auto pRC::sinh ( Complex< T > const & a )

inlinestaticconstexpr

sinh() [2/3]

template<class T , If< IsFloat< T > > = 0>

static constexpr auto pRC::sinh ( T const a )

inlinestaticconstexpr

sinh() [3/3]

template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Sinh >, X > > = 0>

static constexpr auto pRC::sinh ( X && a )

inlinestaticconstexpr

slice() [1/2]

template<Size... Es, class X , class... Os, class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< View, X > > = 0, If< All< IsConvertible< Os, Index >... > > = 0, If< IsSatisfied<(sizeof...(Es)==typename R::Dimension())> > = 0, If< IsSatisfied<(sizeof...(Os)==typename R::Dimension())> > = 0, If< IsSatisfied<(Sizes< Es... >()<=typename R::Sizes())> >

static constexpr auto pRC::slice ( X && a, Os const ... offsets )

inlinestaticconstexpr

slice() [2/2]

template<Size... Es, class X , class... Os, class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< Not< IsInvocable< View, X > > > = 0, If< IsInvocable< Slice< Es... >, X &, Os... > > = 0>

static constexpr auto pRC::slice ( X && a, Os const ... offsets )

inlinestaticconstexpr

solve() [1/8]

template<Operator::Transform T = Operator::Transform::None, Operator::Restrict R = Operator::Restrict::None, Operator::Hint H = Operator::Hint::None, class Solver , class XA , class XB , If< IsInvocable< Solver, XA, XB > > = 0>

static constexpr decltype(auto) pRC::solve ( Solver && solver, XA && A, XB && b )

inlinestaticconstexpr

solve() [2/8]

template<Operator::Transform T = Operator::Transform::None, Operator::Restrict R = Operator::Restrict::None, Operator::Hint H = Operator::Hint::None, class Solver , class XA , class XB , class VT , If< IsInvocable< Solver, XA, XB, VT > > = 0>

static constexpr decltype(auto) pRC::solve ( Solver && solver, XA && A, XB && b, VT const & tolerance )

inlinestaticconstexpr

solve() [3/8]

template<Operator::Transform T = Operator::Transform::None, Operator::Restrict R = Operator::Restrict::None, Operator::Hint H = Operator::Hint::None, class Solver , class XA , class XB , class XX , If< IsInvocable< Solver, XA, XB, XX > > = 0>

static constexpr decltype(auto) pRC::solve ( Solver && solver, XA && A, XB && b, XX && x0 )

inlinestaticconstexpr

solve() [4/8]

template<Operator::Transform T = Operator::Transform::None, Operator::Restrict R = Operator::Restrict::None, Operator::Hint H = Operator::Hint::None, class Solver , class XA , class XB , class XX , class VT , If< IsInvocable< Solver, XA, XB, XX, VT > > = 0>

static constexpr decltype(auto) pRC::solve ( Solver && solver, XA && A, XB && b, XX && x0, VT const & tolerance )

inlinestaticconstexpr

solve() [5/8]

template<class Solver , Operator::Transform T = Operator::Transform::None, Operator::Restrict R = Operator::Restrict::None, Operator::Hint H = Operator::Hint::None, class XA , class XB , If< IsInvocable< Solver, XA, XB > > = 0>

static constexpr decltype(auto) pRC::solve ( XA && A, XB && b )

inlinestaticconstexpr

solve() [6/8]

template<class Solver , Operator::Transform T = Operator::Transform::None, Operator::Restrict R = Operator::Restrict::None, Operator::Hint H = Operator::Hint::None, class XA , class XB , class VT , If< IsInvocable< Solver, XA, XB, VT > > = 0>

static constexpr decltype(auto) pRC::solve ( XA && A, XB && b, VT const & tolerance )

inlinestaticconstexpr

solve() [7/8]

template<class Solver , Operator::Transform T = Operator::Transform::None, Operator::Restrict R = Operator::Restrict::None, Operator::Hint H = Operator::Hint::None, class XA , class XB , class XX , If< IsInvocable< Solver, XA, XB, XX > > = 0>

static constexpr decltype(auto) pRC::solve ( XA && A, XB && b, XX && x0 )

inlinestaticconstexpr

solve() [8/8]

template<class Solver , Operator::Transform T = Operator::Transform::None, Operator::Restrict R = Operator::Restrict::None, Operator::Hint H = Operator::Hint::None, class XA , class XB , class XX , class VT , If< IsInvocable< Solver, XA, XB, XX, VT > > = 0>

static constexpr decltype(auto) pRC::solve ( XA && A, XB && b, XX && x0, VT const & tolerance )

inlinestaticconstexpr

sort() [1/3]

template<class C , class T , If< IsSubscriptable< T > > = 0, class S = ResultOf<Subscript, T &, Index>, If< IsInvocable< C, S, S > > = 0, If< IsAssignable< S > > = 0>

static constexpr void pRC::sort ( C const & compare, T & a, Size const k = T::size(), Size const d = 0 )

inlinestaticconstexpr

sort() [2/3]

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 )

inlinestaticconstexpr

sort() [3/3]

template<class C = Less, class T , If< IsSubscriptable< T > > = 0, class S = ResultOf<Subscript, T &, Index>, If< IsInvocable< C, S, S > > = 0, If< IsAssignable< S > > = 0>

static constexpr void pRC::sort ( T & a, Size const k = T::size(), Size const d = 0 )

inlinestaticconstexpr

sqrt() [1/3]

template<class T >

static constexpr auto pRC::sqrt ( Complex< T > const & a )

inlinestaticconstexpr

sqrt() [2/3]

template<class T , If< IsFloat< T > > = 0>

static constexpr auto pRC::sqrt ( T const & a )

inlinestaticconstexpr

sqrt() [3/3]

template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Sqrt >, X > > = 0>

static constexpr auto pRC::sqrt ( X && a )

inlinestaticconstexpr

square() [1/3]

template<class T , If< IsInvocable< Mul, T, T > > = 0, If< IsInvocable< Sub, T, T > > = 0>

static constexpr auto pRC::square ( Complex< T > const & a )

inlinestaticconstexpr

square() [2/3]

template<class T , If< IsValue< T > > = 0>

static constexpr auto pRC::square ( T const & a )

inlinestaticconstexpr

square() [3/3]

template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Square >, X > > = 0>

static constexpr auto pRC::square ( X && a )

inlinestaticconstexpr

squeeze()

template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0>

static constexpr auto pRC::squeeze ( X && a )

inlinestaticconstexpr

strictlyLowerTriangular()

template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< View, X > > = 0, If< IsSatisfied<(typename R::Dimension()==2)> > = 0>

static constexpr auto pRC::strictlyLowerTriangular ( X && a )

inlinestaticconstexpr

strictlyUpperTriangular()

template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< View, X > > = 0, If< IsSatisfied<(typename R::Dimension()==2)> > = 0>

static constexpr auto pRC::strictlyUpperTriangular ( X && a )

inlinestaticconstexpr

stride() [1/2]

template<Size... Ss, class X , class... Os, class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< View, X > > = 0, If< All< IsConvertible< Os, Index >... > > = 0, If< IsSatisfied<(sizeof...(Ss)==typename R::Dimension())> > = 0, If< IsSatisfied<(sizeof...(Os)==typename R::Dimension())> > = 0, If< IsSatisfied<(typename R::Sizes() % Sizes< Ss... >()==Constant< Size, 0 >())> >

static constexpr auto pRC::stride ( X && a, Os const ... offsets )

inlinestaticconstexpr

stride() [2/2]

template<Size... Ss, class X , class... Os, class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< Not< IsInvocable< View, X > > > = 0, If< IsInvocable< Stride< Ss... >, X &, Os... > > = 0>

static constexpr auto pRC::stride ( X && a, Os const ... offsets )

inlinestaticconstexpr

String() [1/2]

pRC::String

(

char const &

)

-> String< 1 >

String() [2/2]

template<Size N>

pRC::String

(

char

const(&)[N]

)

-> String< N - 1 >

svd() [1/2]

template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsFloat< typename R::Value > > = 0, If< IsSatisfied<(typename R::Dimension()==2)> > = 0>

static constexpr auto pRC::svd ( X && input )

inlinestaticconstexpr

svd() [2/2]

template<Size C, class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, class V = typename R::Value, class VT = V, If< All< IsFloat< V >, IsFloat< VT > > > = 0, If< IsSatisfied<(typename R::Dimension()==2)> > = 0, If< IsSatisfied<(C< min(R::size(0), R::size(1)))> > = 0>

static constexpr auto pRC::svd ( X && input, VT const & tolerance = NumericLimits<VT>::tolerance() )

inlinestaticconstexpr

swap()

template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< IsTensorish< RA > > = 0, If< IsInvocable< View, XA > > = 0, If< IsTensorish< RB > > = 0, If< IsInvocable< View, XB > > = 0, If< IsSame< typename RA::Sizes, typename RB::Sizes > > = 0, class EA = ResultOf<XA, typename RA::Subscripts>, class EB = ResultOf<XB, typename RB::Subscripts>, If< IsInvocable< Swap, EA, EB > > = 0>

static constexpr auto pRC::swap ( XA && a, XB && b )

inlinestaticconstexpr

tan() [1/3]

template<class T >

static constexpr auto pRC::tan ( Complex< T > const & a )

inlinestaticconstexpr

tan() [2/3]

template<class T , If< IsFloat< T > > = 0>

static constexpr auto pRC::tan ( T const a )

inlinestaticconstexpr

tan() [3/3]

template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Tan >, X > > = 0>

static constexpr auto pRC::tan ( X && a )

inlinestaticconstexpr

tanh() [1/3]

template<class T >

static constexpr auto pRC::tanh ( Complex< T > const & a )

inlinestaticconstexpr

tanh() [2/3]

template<class T , If< IsFloat< T > > = 0>

static constexpr auto pRC::tanh ( T const a )

inlinestaticconstexpr

tanh() [3/3]

template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Tanh >, X > > = 0>

static constexpr auto pRC::tanh ( X && a )

inlinestaticconstexpr

Tensor() [1/5]

template<class T , Size... Ms, Size... Ns, class R >

pRC::Tensor

(

TensorTrain::Operator< T, Sizes< Ms... >, Sizes< Ns... >, R > const &

)

-> Tensor< T, Ms..., Ns... >

Tensor() [2/5]

template<class T , Size... Ms, Size... Ns, class R , class F >

pRC::Tensor

(

TensorTrain::OperatorViews::View< T, Sizes< Ms... >, Sizes< Ns... >, R, F > const &

)

-> Tensor< T, Ms..., Ns... >

Tensor() [3/5]

template<class T , Size... Ns, class R >

pRC::Tensor

(

TensorTrain::Tensor< T, Sizes< Ns... >, R > const &

)

-> Tensor< T, Ns... >

Tensor() [4/5]

template<class T , Size... Ns, class R , class F >

pRC::Tensor

(

TensorTrain::TensorViews::View< T, Sizes< Ns... >, R, F > const &

)

-> Tensor< T, Ns... >

Tensor() [5/5]

template<class F , class T , Size... Ns>

pRC::Tensor

(

TensorViews::View< T, Sizes< Ns... >, F > const &

)

-> Tensor< T, Ns... >

tensorProduct() [1/2]

template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< IsTensorish< RA > > = 0, If< IsInvocable< View, XA > > = 0, If< IsTensorish< RB > > = 0, If< IsInvocable< View, XB > > = 0, class EA = ResultOf<XA, typename RA::Subscripts>, class EB = ResultOf<XB, typename RB::Subscripts>, If< IsInvocable< Mul, EA, EB > > = 0>

static constexpr auto pRC::tensorProduct ( XA && a, XB && b )

inlinestaticconstexpr

tensorProduct() [2/2]

template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< IsTensorish< RA > > = 0, If< IsTensorish< RB > > = 0, If< Not< All< IsInvocable< View, XA >, IsInvocable< View, XB > > > > = 0, If< IsInvocable< TensorProduct, XA &, XB & > > = 0>

static constexpr auto pRC::tensorProduct ( XA && a, XB && b )

inlinestaticconstexpr

trace() [1/2]

template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< View, X > > = 0, If< IsInvocable< ExtractDiagonal, X > > = 0, If< IsInvocable< Reduce< Add >, ResultOf< ExtractDiagonal, X > > > = 0>

static constexpr auto pRC::trace ( X && a )

inlinestaticconstexpr

trace() [2/2]

template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< Not< IsInvocable< View, X > > > = 0, If< IsInvocable< Trace, X & > > = 0>

static constexpr auto pRC::trace ( X && a )

inlinestaticconstexpr

transform() [1/2]

template<Operator::Transform OT = Operator::Transform::None, class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0>

static constexpr decltype(auto) pRC::transform ( X && a )

inlinestaticconstexpr

transform() [2/2]

template<Operator::Transform OT = Operator::Transform::None, class X , class R = RemoveReference<X>, If< TensorTrain::IsOperatorish< R > > = 0>

static constexpr decltype(auto) pRC::transform ( X && a )

inlinestaticconstexpr

transpose() [1/3]

template<class T >

static constexpr auto pRC::transpose ( JacobiRotation< T > const & a )

inlinestaticconstexpr

transpose() [2/3]

template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsSatisfied<(isEven(typename R::Dimension()))> > = 0>

static constexpr auto pRC::transpose ( X && a )

inlinestaticconstexpr

transpose() [3/3]

template<class X , class R = RemoveReference<X>, If< TensorTrain::IsOperatorish< R > > = 0, If< IsInvocable< Loop< Permute< 0, 2, 1, 3 > >, X > > = 0>

static constexpr auto pRC::transpose ( X && a )

inlinestaticconstexpr

trim()

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 )

inlinestaticconstexpr

trunc() [1/3]

template<class T , If< IsInvocable< Trunc, T > > = 0>

static constexpr auto pRC::trunc ( Complex< T > const & a )

inlinestaticconstexpr

trunc() [2/3]

template<class T , If< IsFloat< T > > = 0>

static constexpr auto pRC::trunc ( T const & a )

inlinestaticconstexpr

trunc() [3/3]

template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Trunc >, X > > = 0>

static constexpr auto pRC::trunc ( X && a )

inlinestaticconstexpr

truncate()

template<Size C, Position P, class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, class V = typename R::Value, class VT = V, If< All< IsFloat< V >, IsFloat< VT > > > = 0, If< IsSatisfied<(P==Position::Left||P==Position::Right)> > = 0>

static constexpr auto pRC::truncate ( X && a, VT const & tolerance = NumericLimits<VT>::epsilon() )

inlinestaticconstexpr

unfolding()

template<Index K, class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsSatisfied<(typename R::Dimension{} > 1)> , If< IsSatisfied<(K+1< typename R::Dimension{})> > = 0, If< IsInvocable< Reshape< R::size(K), R::Sizes::size()/R::size(K)>, X > > = 0>

static constexpr auto pRC::unfolding ( X && a )

inlinestaticconstexpr

unit() [1/3]

template<class T , If< IsDefined< Unit< T > > > = 0, If< IsConstructible< Unit< T > > > = 0, If< IsInvocable< Unit< T > > > = 0>

static constexpr auto pRC::unit ( )

inlinestaticconstexpr

unit() [2/3]

static constexpr auto pRC::unit ( )

inlinestaticconstexpr

unit() [3/3]

template<class T , class X , If< IsDefined< Unit< T > > > = 0, If< IsConstructible< Unit< T > > > = 0, If< IsInvocable< Unit< T >, X > > = 0>

static constexpr auto pRC::unit ( X && value )

inlinestaticconstexpr

unitLowerTriangular()

template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< View, X > > = 0, If< IsSatisfied<(typename R::Dimension()==2)> > = 0>

static constexpr auto pRC::unitLowerTriangular ( X && a )

inlinestaticconstexpr

unitUpperTriangular()

template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< View, X > > = 0, If< IsSatisfied<(typename R::Dimension()==2)> > = 0>

static constexpr auto pRC::unitUpperTriangular ( X && a )

inlinestaticconstexpr

upperTriangular()

template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< View, X > > = 0, If< IsSatisfied<(typename R::Dimension()==2)> > = 0>

static constexpr auto pRC::upperTriangular ( X && a )

inlinestaticconstexpr

view() [1/12]

template<class T , Size... Ns>

static constexpr auto pRC::view ( Tensor< T, Ns... > & a )

inlinestaticconstexpr

view() [2/12]

template<class T , Size... Ns>

static constexpr auto pRC::view ( Tensor< T, Ns... > const && )

inlinestaticconstexprdelete

view() [3/12]

template<class T , Size... Ns>

static constexpr auto pRC::view ( Tensor< T, Ns... > const & a )

inlinestaticconstexpr

view() [4/12]

template<class T , class M , class N , class R >

static constexpr auto pRC::view ( TensorTrain::Operator< T, M, N, R > & a )

inlinestaticconstexpr

view() [5/12]

template<class T , class M , class N , class R >

static constexpr auto pRC::view ( TensorTrain::Operator< T, M, N, R > const && )

inlinestaticconstexprdelete

view() [6/12]

template<class T , class M , class N , class R >

static constexpr auto pRC::view ( TensorTrain::Operator< T, M, N, R > const & a )

inlinestaticconstexpr

view() [7/12]

template<class T , class N , class R >

static constexpr auto pRC::view ( TensorTrain::Tensor< T, N, R > & a )

inlinestaticconstexpr

view() [8/12]

template<class T , class N , class R >

static constexpr auto pRC::view ( TensorTrain::Tensor< T, N, R > const && )

inlinestaticconstexprdelete

view() [9/12]

template<class T , class N , class R >

static constexpr auto pRC::view ( TensorTrain::Tensor< T, N, R > const & a )

inlinestaticconstexpr

view() [10/12]

template<class X , If< IsTensorView< RemoveReference< X > > > = 0>

static constexpr X pRC::view ( X && a )

inlinestaticconstexpr

view() [11/12]

template<class X , If< TensorTrain::IsOperatorView< RemoveReference< X > > > = 0>

static constexpr X pRC::view ( X && a )

inlinestaticconstexpr

view() [12/12]

template<class X , If< TensorTrain::IsTensorView< RemoveReference< X > > > = 0>

static constexpr X pRC::view ( X && a )

inlinestaticconstexpr

where() [1/5]

template<class TE , class T , If< IsBool< TE > > = 0>

static constexpr T pRC::where ( TE const e, T && a, T && b )

inlinestaticconstexpr

where() [2/5]

template<class TE , class T , If< IsBool< TE > > = 0>

static constexpr T const & pRC::where ( TE const e, T & a, T const & b )

inlinestaticconstexpr

where() [3/5]

template<class TE , class T , If< IsBool< TE > > = 0>

static constexpr T const & pRC::where ( TE const e, T const & a, T & b )

inlinestaticconstexpr

where() [4/5]

template<class TE , class XA , class XB , If< IsBool< TE > > = 0>

static constexpr auto pRC::where ( TE const e, XA && a, XB && b )

inlinestaticconstexpr

where() [5/5]

template<class XE , class XA , class XB , If< IsTensorish< RemoveReference< XE > > > = 0, If< IsTensorish< RemoveReference< XA > > > = 0, If< IsTensorish< RemoveReference< XB > > > = 0, If< IsInvocable< Loop< Where >, XE, XA, XB > > = 0>

static constexpr auto pRC::where ( XE && e, XA && a, XB && b )

inlinestaticconstexpr

zero() [1/2]

template<class T , If< IsDefined< Zero< T > > > = 0, If< IsConstructible< Zero< T > > > = 0, If< IsInvocable< Zero< T > > > = 0>

static constexpr auto pRC::zero ( )

inlinestaticconstexpr

zero() [2/2]

static constexpr auto pRC::zero ( )

inlinestaticconstexpr

zip()

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 ... )

inlinestaticconstexpr

Variable Documentation

cCacheLineSizeByte

constexpr Size pRC::cCacheLineSizeByte = 64

constexpr

cDebugLevel

constexpr auto pRC::cDebugLevel = DebugLevel::Low

constexpr

cHugepageSizeByte

constexpr Size pRC::cHugepageSizeByte = 2 * 1024 * 1024

constexpr

cLogLevel

constexpr auto pRC::cLogLevel = LogLevel::Info

constexpr

cPageSizeByte

constexpr Size pRC::cPageSizeByte = 4 * 1024

constexpr

cSimdSizeByte

constexpr Size pRC::cSimdSizeByte

constexpr

Initial value:

=
 
 
 
 
 
        16

isDefined

False pRC::isDefined(...)

(

...

)