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 >
class	Complex
struct	Complexify
struct	Conj
struct	Contract
struct	Cos
struct	Cosh
class	CRTP
struct	Delta
class	Deque
struct	Diagonal
struct	DirectSum
struct	Div
struct	Enumerate
struct	Equal
struct	Eval
struct	Exclude
struct	Exp
struct	ExtractDiagonal
struct	Flatten
class	Float
struct	Floor
struct	FMod
struct	Fold
struct	Folding
struct	FromDiagonal
class	GaussianDistribution
struct	Greater
struct	GreaterEqual
struct	HadamardProduct
struct	Identity
struct	Identity< Complex< T > >
struct	Identity< Float< 16 > >
struct	Identity< T >
struct	Identity< T const >
struct	Imag
struct	Inflate
struct	InnerProduct
class	Integer
struct	IsApprox
struct	IsDiagonal
struct	IsFinite
struct	IsIdentity
struct	IsLowerTriangular
struct	IsNaN
struct	IsOffDiagonal
struct	IsSelfAdjoint
struct	IsStrictlyLowerTriangular
struct	IsStrictlyUpperTriangular
struct	IsSymmetric
struct	IsUnit
struct	IsUnitary
struct	IsUnitLowerTriangular
struct	IsUnitUpperTriangular
struct	IsUpperTriangular
struct	IsZero
class	JacobiRotation
struct	KroneckerProduct
class	LaplaceDistribution
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 >
struct	NumericLimits< T const >
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 >, URNG, D< T > >
struct	Random< T, URNG, D< T > >
struct	Random< Tensor< T, Ns... >, URNG, D< Value< T > > >
struct	Random< TensorTrain::Operator< T, M, N, Ranks >, URNG, D< Value< T > > >
struct	Random< TensorTrain::Tensor< T, N, Ranks >, URNG, D< Value< T > > >
class	RandomDistribution
class	RandomEngine
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
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
struct	TensorProduct
class	Threefry
struct	Trace
struct	Transform
struct	Transpose
struct	Trunc
struct	Unfolding
class	UniformDistribution
struct	Unit
struct	Unit< T >
struct	Unit< T const >
struct	UnitLowerTriangular
struct	UnitUpperTriangular
struct	UpperTriangular
struct	ValueType
struct	ValueType< T >
struct	View
struct	Where
struct	Zero
struct	Zero< Complex< T > >
struct	Zero< Float< 16 > >
struct	Zero< T >
struct	Zero< T const >

Concepts
concept	HasCommon
concept	IsDefined
concept	IsReference
concept	IsPointer
concept	IsConst
concept	IsSame
concept	IsInvocable
concept	IsPredicate
concept	IsConstructible
concept	IsAssignable
concept	IsConvertible
concept	IsDerivedFrom
concept	IsBaseOf
concept	IsStandardLayout
concept	IsVoid
concept	IsBool
concept	IsSize
concept	IsIndex
concept	IsSeed
concept	IsIntegral
concept	IsSignedIntegral
concept	IsUnsignedIntegral
concept	IsConstant
concept	IsSequence
concept	IsSizes
concept	IsString
concept	IsComplex
concept	IsComplexified
concept	IsArray
concept	IsDeque
concept	IsSubscripts
concept	IsSubscriptable
concept	IsRandomDistribution
concept	IsRandomEngine
concept	IsTensor
concept	IsTensorView
concept	IsTensorish
concept	IsScalar
concept	IsScalarish
concept	IsVector
concept	IsVectorish
concept	IsMatrix
concept	IsMatrixish
concept	IsFloat
concept	IsInteger
concept	IsSignedInteger
concept	IsUnsignedInteger
concept	IsValue

Typedefs
template<class... Ts>
using	Tuple = std::tuple<Ts...>
template<std::size_t I, class T >
using	TupleElement = std::tuple_element_t<I, T>
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	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... Ts>
using	Common = std::common_type_t<Ts...>
template<Bool B, class T , class F >
using	Conditional = std::conditional_t<B, T, F>
template<class F , class... Args>
using	ResultOf = std::invoke_result_t<F, Args...>
template<class T >
using	UnderlyingType = std::underlying_type_t<T>
using	Mutex = std::mutex
template<Size... Ns>
using	Sizes = Sequence<Size, Ns...>
template<class T >
using	NonComplex = RemoveConstReference<ResultOf<Eval, ResultOf<Real, T>>>
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
using	DefaultRandomEngine = Threefry<20>
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	Value = typename ValueType<T>::Type

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 , IsTensorish R = RemoveReference<X>> requires (R::Dimension == 2) && (R::size(0) == R::size(1))
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 , IsTensorish R = RemoveReference<X>> requires (R::Dimension == 2) && ((IsTensor<R> && !IsReference<X>) || IsAssignable<X>)
static constexpr decltype(auto)	apply (JacobiRotation< T > const &r, X &&m, Index const p, Index const q)
template<class T , class X , IsTensorish R = RemoveReference<X>> requires (R::Dimension == 2) && ((IsTensor<R> && !IsReference<X>) || IsAssignable<X>)
static constexpr decltype(auto)	apply (X &&m, JacobiRotation< T > const &r, Index const p, Index const q)
template<class T , class X , IsTensorish R = RemoveReference<X>> requires (R::Dimension == 1) && ((IsTensor<R> && !IsReference<X>) || IsAssignable<X>)
static constexpr decltype(auto)	apply (JacobiRotation< T > const &r, X &&v, Index const p, Index const q)
template<class T , class X , IsTensorish R = RemoveReference<X>> requires (R::Dimension == 1) && ((IsTensor<R> && !IsReference<X>) || IsAssignable<X>)
static constexpr decltype(auto)	apply (X &&v, JacobiRotation< T > const &r, Index const p, Index const q)
template<Size B = 32, class X , IsTensorish R = RemoveReference<X>> requires IsFloat<Value<R>> && (R::Dimension == 2)
static constexpr auto	lq (X &&input)
template<Operator::Hint H = Operator::Hint::None, class X , IsTensorish R = RemoveReference<X>> requires (R::Dimension == 2) && (R::size(0) == R::size(1))
static constexpr auto	lu (X &&a)
	LU decomposition of a square matrix.
template<class Optimizer , class XX , class FF , class FC , class VT > requires IsInvocable<Optimizer, XX, FF, FC, VT>
static constexpr auto	optimize (Optimizer &&optimizer, XX &&x, FF &&function, FC &&callback, VT const &tolerance=NumericLimits< Value< RemoveReference< XX > > >::tolerance())
template<class Optimizer , class XX , class FF , class VT > requires IsInvocable<Optimizer, XX, FF, void(RemoveConstReference<ResultOf<Eval, XX>> const), VT>
static constexpr auto	optimize (Optimizer &&optimizer, XX &&x, FF &&function, VT const &tolerance=NumericLimits< Value< RemoveReference< XX > > >::tolerance())
template<class Optimizer , class XX , class FF , class FC , class VT > requires IsInvocable<Optimizer, XX, FF, FC, VT>
static constexpr auto	optimize (XX &&x, FF &&function, FC &&callback, VT const &tolerance=NumericLimits< Value< RemoveReference< XX > > >::tolerance())
template<class Optimizer , class XX , class FF , class VT > requires IsInvocable<Optimizer, XX, FF, void(RemoveConstReference<ResultOf<Eval, XX>> const), VT>
static constexpr auto	optimize (XX &&x, FF &&function, VT const &tolerance=NumericLimits< Value< RemoveReference< XX > > >::tolerance())
template<Size B = 32, class X , IsTensorish R = RemoveReference<X>> requires IsFloat<Value<R>> && (R::Dimension == 2)
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 > requires IsInvocable<Solver, XA, XB>
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 > requires IsInvocable<Solver, XA, XB, XX>
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 > requires IsInvocable<Solver, XA, XB, VT>
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 > requires IsInvocable<Solver, XA, XB, XX, VT>
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 > requires IsInvocable<Solver, XA, XB>
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 > requires IsInvocable<Solver, XA, XB, XX>
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 > requires IsInvocable<Solver, XA, XB, VT>
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 > requires IsInvocable<Solver, XA, XB, XX, VT>
static constexpr decltype(auto)	solve (XA &&A, XB &&b, XX &&x0, VT const &tolerance)
template<class C , IsSubscriptable T, class S = ResultOf<Subscript, T &, Index>> requires IsInvocable<C, S, S> && IsAssignable<S>
static constexpr void	sort (C const &compare, T &a, Size const k=T::size(), Size const d=0)
template<class C = Less, IsSubscriptable T, class S = ResultOf<Subscript, T &, Index>> requires IsInvocable<C, S, S> && IsAssignable<S>
static constexpr void	sort (T &a, Size const k=T::size(), Size const d=0)
template<class X , IsTensorish R = RemoveReference<X>> requires IsFloat<Value<R>> && (R::Dimension == 2)
static constexpr auto	svd (X &&input)
template<Size C, class X , IsTensorish R = RemoveReference<X>, IsFloat V = Value<R>, IsFloat VT = V> requires (R::Dimension == 2) && (C < reduce<Min>(typename R::Sizes()))
static constexpr auto	svd (X &&input, VT const &tolerance=NumericLimits< VT >::tolerance())
template<Size C, class X , IsTensorish R = RemoveReference<X>, IsFloat V = Value<R>, IsFloat VT = V> requires (R::Dimension == 2) && (C == reduce<Min>(typename R::Sizes()))
static constexpr auto	svd (X &&input, VT const &tolerance=NumericLimits< VT >::tolerance())
template<class... Xs>
static constexpr auto	forwardAsTuple (Xs &&...args)
template<class X >
static constexpr AddConst< X > &	asConst (X &a)
template<class X >
static constexpr RemoveConst< X >	asConst (X &&a)
template<class X >
static constexpr RemoveConst< X >	as (X &&a)
static constexpr auto	reverse (Direction const D)
template<IsUnsignedIntegral TA, IsUnsignedIntegral TB>
static constexpr auto	bitRotateLeft (TA const value, TB count)
template<IsUnsignedIntegral TA, IsUnsignedIntegral TB>
static constexpr auto	bitRotateRight (TA const value, TB count)
template<IsUnsignedIntegral TA, IsUnsignedIntegral TB>
static constexpr auto	ceilDiv (TA const a, TB const b)
template<Bool C = true, class X >
static constexpr Conditional< C, RemoveConstReference< X >, RemoveConst< X > >	copy (X &&a)
template<class X , template< class > class T> requires IsSame<T<Void>, Identity<>> || IsSame<T<Void>, Unit<>> || IsSame<T<Void>, Zero<>>
static constexpr auto	operator== (X &&a, T< Void > const)
template<class X , template< class > class T> requires IsSame<T<Void>, Identity<>> || IsSame<T<Void>, Unit<>> || IsSame<T<Void>, Zero<>>
static constexpr auto	operator== (T< Void > const, X &&b)
template<template< class > class TA, template< class > class TB> requires ((IsSame<TA<Void>, Identity<>> || IsSame<TA<Void>, Unit<>> || IsSame<TA<Void>, Zero<>>) && (IsSame<TB<Void>, Identity<>> || IsSame<TB<Void>, Unit<>> || IsSame<TB<Void>, Zero<>>))
static constexpr auto	operator== (TA< Void > const, TB< Void > const)
template<class X , template< class > class T> requires IsSame<T<Void>, Identity<>> || IsSame<T<Void>, Unit<>> || IsSame<T<Void>, Zero<>>
static constexpr auto	operator> (X &&a, T< Void > const)
template<class X , template< class > class T> requires IsSame<T<Void>, Identity<>> || IsSame<T<Void>, Unit<>> || IsSame<T<Void>, Zero<>>
static constexpr auto	operator> (T< Void > const, X &&b)
template<template< class > class TA, template< class > class TB> requires ((IsSame<TA<Void>, Identity<>> || IsSame<TA<Void>, Unit<>> || IsSame<TA<Void>, Zero<>>) && (IsSame<TB<Void>, Identity<>> || IsSame<TB<Void>, Unit<>> || IsSame<TB<Void>, Zero<>>))
static constexpr auto	operator> (TA< Void > const, TB< Void > const)
template<class X , template< class > class T> requires IsSame<T<Void>, Identity<>> || IsSame<T<Void>, Unit<>> || IsSame<T<Void>, Zero<>>
static constexpr auto	operator>= (X &&a, T< Void > const)
template<class X , template< class > class T> requires IsSame<T<Void>, Identity<>> || IsSame<T<Void>, Unit<>> || IsSame<T<Void>, Zero<>>
static constexpr auto	operator>= (T< Void > const, X &&b)
template<template< class > class TA, template< class > class TB> requires ((IsSame<TA<Void>, Identity<>> || IsSame<TA<Void>, Unit<>> || IsSame<TA<Void>, Zero<>>) && (IsSame<TB<Void>, Identity<>> || IsSame<TB<Void>, Unit<>> || IsSame<TB<Void>, Zero<>>))
static constexpr auto	operator>= (TA< Void > const, TB< Void > const)
template<class T > requires IsDefined<Identity<T>> && IsConstructible<Identity<T>> && IsInvocable<Identity<T>>
static constexpr auto	identity ()
static constexpr auto	identity ()
template<class T , class X > requires IsDefined<Identity<T>> && IsConstructible<Identity<T>> && IsInvocable<Identity<T>, X>
static constexpr auto	identity (X &&value)
template<Size B, IsUnsignedIntegral T>
static constexpr T	iLog (T const a)
template<IsIntegral B, IsUnsignedIntegral N>
static constexpr B	iPow (B const base, N const exp)
template<IsIntegral T>
static constexpr auto	isEven (T const a)
template<IsIntegral T, T V>
static constexpr auto	isEven (Constant< T, V > const)
template<IsIntegral T>
static constexpr auto	isIdentity (T const a)
template<IsIntegral T, T V>
static constexpr auto	isIdentity (Constant< T, V > const)
template<IsIntegral T>
static constexpr auto	isOdd (T const a)
template<IsIntegral T, T V>
static constexpr auto	isOdd (Constant< T, V > const)
template<IsIntegral T>
static constexpr auto	isPowerOfTwo (T const v)
template<class X , class... Xs>
static constexpr auto	isSame (X &&arg, Xs &&...args)
template<IsIntegral T>
static constexpr auto	isUnit (T const a)
template<IsIntegral T, T V>
static constexpr auto	isUnit (Constant< T, V > const)
template<IsIntegral T>
static constexpr auto	isZero (T const a)
template<IsIntegral T, T V>
static constexpr auto	isZero (Constant< T, V > const)
template<IsUnsignedIntegral T>
static constexpr T	iSqrt (T const a)
template<class X , template< class > class T> requires IsSame<T<Void>, Identity<>> || IsSame<T<Void>, Unit<>> || IsSame<T<Void>, Zero<>>
static constexpr auto	operator< (X &&a, T< Void > const)
template<class X , template< class > class T> requires IsSame<T<Void>, Identity<>> || IsSame<T<Void>, Unit<>> || IsSame<T<Void>, Zero<>>
static constexpr auto	operator< (T< Void > const, X &&b)
template<template< class > class TA, template< class > class TB> requires ((IsSame<TA<Void>, Identity<>> || IsSame<TA<Void>, Unit<>> || IsSame<TA<Void>, Zero<>>) && (IsSame<TB<Void>, Identity<>> || IsSame<TB<Void>, Unit<>> || IsSame<TB<Void>, Zero<>>))
static constexpr auto	operator< (TA< Void > const, TB< Void > const)
template<class X , template< class > class T> requires IsSame<T<Void>, Identity<>> || IsSame<T<Void>, Unit<>> || IsSame<T<Void>, Zero<>>
static constexpr auto	operator<= (X &&a, T< Void > const)
template<class X , template< class > class T> requires IsSame<T<Void>, Identity<>> || IsSame<T<Void>, Unit<>> || IsSame<T<Void>, Zero<>>
static constexpr auto	operator<= (T< Void > const, X &&b)
template<template< class > class TA, template< class > class TB> requires ((IsSame<TA<Void>, Identity<>> || IsSame<TA<Void>, Unit<>> || IsSame<TA<Void>, Zero<>>) && (IsSame<TB<Void>, Identity<>> || IsSame<TB<Void>, Unit<>> || IsSame<TB<Void>, Zero<>>))
static constexpr auto	operator<= (TA< Void > const, TB< Void > const)
template<class X >
static constexpr decltype(auto)	max (X &&a)
template<class XA , class XB > requires IsInvocable<Greater, XA, XB>
static constexpr decltype(auto)	max (XA &&a, XB &&b)
template<class XA , class XB , class... Xs> requires IsInvocable<Greater, XA, XB> && (IsInvocable<Greater, ResultOf<Where, ResultOf<Greater, XA, XB>, XA, XB>, Xs> && ...)
static constexpr decltype(auto)	max (XA &&a, XB &&b, Xs &&...args)
template<class X >
static constexpr decltype(auto)	min (X &&a)
template<class XA , class XB > requires IsInvocable<Less, XA, XB>
static constexpr decltype(auto)	min (XA &&a, XB &&b)
template<class XA , class XB , class... Xs> requires IsInvocable<Less, XA, XB> && (IsInvocable<Less, ResultOf<Where, ResultOf<Less, XA, XB>, XA, XB>, Xs> && ...)
static constexpr decltype(auto)	min (XA &&a, XB &&b, Xs &&...args)
template<class X , template< class > class T> requires IsSame<T<Void>, Identity<>> || IsSame<T<Void>, Unit<>> || IsSame<T<Void>, Zero<>>
static constexpr auto	operator!= (X &&a, T< Void > const)
template<class X , template< class > class T> requires IsSame<T<Void>, Identity<>> || IsSame<T<Void>, Unit<>> || IsSame<T<Void>, Zero<>>
static constexpr auto	operator!= (T< Void > const, X &&b)
template<template< class > class TA, template< class > class TB> requires ((IsSame<TA<Void>, Identity<>> || IsSame<TA<Void>, Unit<>> || IsSame<TA<Void>, Zero<>>) && (IsSame<TB<Void>, Identity<>> || IsSame<TB<Void>, Unit<>> || IsSame<TB<Void>, Zero<>>))
static constexpr auto	operator!= (TA< Void > const, TB< Void > 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<class S >
static auto	print (Direction const direction, S &&stream)
template<class S >
static auto	print (Context const context, S &&stream)
template<class T , IsRandomEngine URNG, IsRandomDistribution D> requires IsDefined<Random<T, URNG, D>> && IsConstructible<Random<T, URNG, D>, URNG &, D &>
static constexpr auto	random (URNG &rng, D &distribution)
template<class T > requires IsDefined<Unit<T>> && IsConstructible<Unit<T>> && IsInvocable<Unit<T>>
static constexpr auto	unit ()
static constexpr auto	unit ()
template<class T , class X > requires IsDefined<Unit<T>> && IsConstructible<Unit<T>> && IsInvocable<Unit<T>, X>
static constexpr auto	unit (X &&value)
template<IsBool TE, class XA , class XB >
static constexpr decltype(auto)	where (TE const e, XA &&a, XB &&b)
template<class T > requires IsDefined<Zero<T>> && IsConstructible<Zero<T>>
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> requires (D == Direction::Forwards || D == Direction::Backwards) && (C == Context::CompileTime)
static constexpr auto	range (F &&f, Xs &&...args)
template<Context C, Size I, Size L, Direction D = Direction::Forwards, Size S = 1, class F , class... Xs> requires (D == Direction::Forwards) && (C == Context::RunTime)
static constexpr auto	range (F &&f, Xs &&...args)
template<Context C, Size I, Size L, Direction D = Direction::Forwards, Size S = 1, class F , class... Xs> requires (D == Direction::Backwards) && (C == Context::RunTime)
static constexpr auto	range (F &&f, Xs &&...args)
template<Size I, Size L, Direction D = Direction::Forwards, Size S = 1, class F , class... Xs> requires (D == Direction::Forwards || D == Direction::Backwards)
static constexpr auto	range (F &&f, Xs &&...args)
template<Size L, Direction D = Direction::Forwards, Size S = 1, class F , class... Xs> requires (D == Direction::Forwards || D == Direction::Backwards)
static constexpr auto	range (F &&f, Xs &&...args)
template<Context C, IsSizes I, IsSizes L, Direction O = Direction::LeftToRight, IsSequence D = decltype(makeConstantSequence<Direction, L::Dimension, Direction::Forwards>()), IsSizes S = decltype(makeConstantSequence<Size, L::Dimension, 1>()), class F , class... Xs> requires IsSame<Direction, typename D::Type> && (L::Dimension == I::Dimension) && (L::Dimension == D::Dimension) && (L::Dimension == S::Dimension) && (O == Direction::LeftToRight || O == Direction::RightToLeft)
static constexpr auto	range (F &&f, Xs &&...args)
template<IsSizes I, IsSizes L, Direction O = Direction::LeftToRight, IsSequence D = decltype(makeConstantSequence<Direction, L::Dimension, Direction::Forwards>()), IsSizes S = decltype(makeConstantSequence<Size, L::Dimension, 1>()), class F , class... Xs> requires IsSame<Direction, typename D::Type> && (L::Dimension == I::Dimension) && (L::Dimension == D::Dimension) && (L::Dimension == S::Dimension) && (O == Direction::LeftToRight || O == Direction::RightToLeft)
static constexpr auto	range (F &&f, Xs &&...args)
template<Context C, IsSizes L, Direction O = Direction::LeftToRight, IsSequence D = decltype(makeConstantSequence<Direction, L::Dimension, Direction::Forwards>()), IsSizes S = decltype(makeConstantSequence<Size, L::Dimension, 1>()), class F , class... Xs> requires IsSame<Direction, typename D::Type> && (L::Dimension == D::Dimension) && (L::Dimension == S::Dimension) && (O == Direction::LeftToRight || O == Direction::RightToLeft)
static constexpr auto	range (F &&f, Xs &&...args)
template<IsSizes L, Direction O = Direction::LeftToRight, IsSequence D = decltype(makeConstantSequence<Direction, L::Dimension, Direction::Forwards>()), IsSizes S = decltype(makeConstantSequence<Size, L::Dimension, 1>()), class F , class... Xs> requires IsSame<Direction, typename D::Type> && (L::Dimension == D::Dimension) && (L::Dimension == S::Dimension) && (O == Direction::LeftToRight || O == Direction::RightToLeft)
static constexpr auto	range (F &&f, Xs &&...args)
template<class X >
	RecursiveLambda (X &&) -> RecursiveLambda< RemoveReference< X > >
template<class T , T... As, T... Bs> requires IsInvocable<Add, T, T> && (sizeof...(As) == sizeof...(Bs))
static constexpr auto	operator+ (Sequence< T, As... > const, Sequence< T, Bs... > const)
template<class T , T... As, T B> requires IsInvocable<Add, T, T>
static constexpr auto	operator+ (Sequence< T, As... > const, Constant< T, B > const)
template<class T , T A, T... Bs> requires IsInvocable<Add, T, T>
static constexpr auto	operator+ (Constant< T, A > const, Sequence< T, Bs... > const)
template<class T , T... As, T... Bs> requires IsInvocable<Sub, T, T> && (sizeof...(As) == sizeof...(Bs))
static constexpr auto	operator- (Sequence< T, As... > const, Sequence< T, Bs... > const)
template<class T , T... As, T B> requires IsInvocable<Sub, T, T>
static constexpr auto	operator- (Sequence< T, As... > const, Constant< T, B > const)
template<class T , T A, T... Bs> requires IsInvocable<Sub, T, T>
static constexpr auto	operator- (Constant< T, A > const, Sequence< T, Bs... > const)
template<class T , T... As, T... Bs> requires IsInvocable<Mul, T, T> && (sizeof...(As) == sizeof...(Bs))
static constexpr auto	operator* (Sequence< T, As... > const, Sequence< T, Bs... > const)
template<class T , T... As, T B> requires IsInvocable<Mul, T, T>
static constexpr auto	operator* (Sequence< T, As... > const, Constant< T, B > const)
template<class T , T A, T... Bs> requires IsInvocable<Mul, T, T>
static constexpr auto	operator* (Constant< T, A > const, Sequence< T, Bs... > const)
template<class T , T... As, T... Bs> requires IsInvocable<Div, T, T> && (sizeof...(As) == sizeof...(Bs))
static constexpr auto	operator/ (Sequence< T, As... > const, Sequence< T, Bs... > const)
template<class T , T... As, T B> requires IsInvocable<Div, T, T>
static constexpr auto	operator/ (Sequence< T, As... > const, Constant< T, B > const)
template<class T , T A, T... Bs> requires IsInvocable<Div, T, T>
static constexpr auto	operator/ (Constant< T, A > const, Sequence< T, Bs... > const)
template<class T , T... As, T... Bs> requires IsInvocable<Mod, T, T> && (sizeof...(As) == sizeof...(Bs))
static constexpr auto	operator% (Sequence< T, As... > const, Sequence< T, Bs... > const)
template<class T , T... As, T B> requires IsInvocable<Mod, T, T>
static constexpr auto	operator% (Sequence< T, As... > const, Constant< T, B > const)
template<class T , T A, T... Bs> requires IsInvocable<Mod, T, T>
static constexpr auto	operator% (Constant< T, A > const, Sequence< T, Bs... > const)
template<class T , T... Is> requires IsInvocable<Minus, T>
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<IsSequence A, IsSequence B>
static constexpr auto	operator== (A const, B const)
template<class T , T... As, T B> requires IsInvocable<Equal, T, T>
static constexpr auto	operator== (Sequence< T, As... > const, Constant< T, B > const)
template<class T , T A, T... Bs> requires IsInvocable<Equal, T, T>
static constexpr auto	operator== (Constant< T, A > const, Sequence< T, Bs... > const)
template<IsSequence A, IsSequence B>
static constexpr auto	operator!= (A const, B const)
template<class T , T... As, T B> requires IsInvocable<NotEqual, T, T>
static constexpr auto	operator!= (Sequence< T, As... > const, Constant< T, B > const)
template<class T , T A, T... Bs> requires IsInvocable<NotEqual, T, T>
static constexpr auto	operator!= (Constant< T, A > const, Sequence< T, Bs... > const)
template<class T , T... As, T... Bs> requires IsInvocable<LessEqual, T, T> && (sizeof...(As) == sizeof...(Bs))
static constexpr auto	operator<= (Sequence< T, As... > const, Sequence< T, Bs... > const)
template<class T , T... As, T B> requires IsInvocable<LessEqual, T, T>
static constexpr auto	operator<= (Sequence< T, As... > const, Constant< T, B > const)
template<class T , T A, T... Bs> requires IsInvocable<LessEqual, T, T>
static constexpr auto	operator<= (Constant< T, A > const, Sequence< T, Bs... > const)
template<class T , T... As, T... Bs> requires IsInvocable<GreaterEqual, T, T> && (sizeof...(As) == sizeof...(Bs))
static constexpr auto	operator>= (Sequence< T, As... > const, Sequence< T, Bs... > const)
template<class T , T... As, T B> requires IsInvocable<GreaterEqual, T, T>
static constexpr auto	operator>= (Sequence< T, As... > const, Constant< T, B > const)
template<class T , T A, T... Bs> requires IsInvocable<GreaterEqual, T, T>
static constexpr auto	operator>= (Constant< T, A > const, Sequence< T, Bs... > const)
template<class T , T... As, T... Bs> requires IsInvocable<Less, T, T> && (sizeof...(As) == sizeof...(Bs))
static constexpr auto	operator< (Sequence< T, As... > const, Sequence< T, Bs... > const)
template<class T , T... As, T B> requires IsInvocable<Less, T, T>
static constexpr auto	operator< (Sequence< T, As... > const, Constant< T, B > const)
template<class T , T A, T... Bs> requires IsInvocable<Less, T, T>
static constexpr auto	operator< (Constant< T, A > const, Sequence< T, Bs... > const)
template<class T , T... As, T... Bs> requires IsInvocable<Greater, T, T> && (sizeof...(As) == sizeof...(Bs))
static constexpr auto	operator> (Sequence< T, As... > const, Sequence< T, Bs... > const)
template<class T , T... As, T B> requires IsInvocable<Greater, T, T>
static constexpr auto	operator> (Sequence< T, As... > const, Constant< T, B > const)
template<class T , T A, T... Bs> requires IsInvocable<Greater, T, T>
static constexpr auto	operator> (Constant< T, A > const, Sequence< T, Bs... > const)
template<class T , T... Seq, class F , class... Xs> requires IsInvocable<F, Xs..., Constant<T, Seq>...>
static constexpr decltype(auto)	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> requires (sizeof...(Ts) > 0)
static constexpr auto	makeSeriesFor ()
template<class T , T First, T Last, Direction D = Direction::Forwards, T Step = T(1)> requires (D == Direction::Forwards)
static constexpr auto	makeRange ()
template<class T , T First, T Last, Direction D = Direction::Forwards, T Step = T(1)> requires (D == Direction::Backwards)
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> requires IsInvocable<F, T, T>
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<class F , class T >
static constexpr auto	reduce (Sequence< T > const)
template<Index... Ps, class T , T... Is> requires ((sizeof...(Is) == sizeof...(Ps))) && (((Ps < sizeof...(Is)) && ...))
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... Is> requires (D == Direction::Leftwards || D == Direction::Rightwards)
static constexpr auto	rotate (Sequence< T, Is... > const)
template<Index O = 0, class T , T... Is, class... Seqs> requires ((Sequence<T, Is...>::size() == Seqs::size()) && ...)
static constexpr auto	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> requires IsInvocable<F, T, T> && (sizeof...(As) == sizeof...(Bs)) && ((sizeof...(As) == Seqs::Dimension) && ...)
static constexpr auto	pick (Sequence< T, As... > const, Sequence< T, Bs... > const, Seqs const ...)
template<Index D, Index... Ds, class T , T... Is> requires (sizeof...(Ds) < sizeof...(Is) && max(D, Ds...) < sizeof...(Is))
static constexpr auto	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> requires (sizeof...(Ss) < sizeof...(Is) && max(S, Ss...) < sizeof...(Is))
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> requires (sizeof...(Is) % B == 0 && P < B)
static constexpr auto	cut (Sequence< T, Is... > const)
template<Index I, Index L, class T , T... Is> requires (L <= sizeof...(Is) && I < L)
static constexpr auto	trim (Sequence< T, Is... > const)
template<class F = Less, class T , T I, T... Is> requires IsPredicate<F, T, T>
static constexpr auto	sort (Sequence< T, I, Is... > const)
template<class T , T From, T... Froms, T To, T... Tos, T P, T... Ps> requires (sizeof...(Froms) == sizeof...(Tos) && sizeof...(Froms) == sizeof...(Ps))
static constexpr auto	getPermutation (Sequence< T, From, Froms... > const, Sequence< T, To, Tos... > const, Sequence< T, P, Ps... > const)
template<class T , T... Froms, T... Tos> requires (sizeof...(Froms) == sizeof...(Tos))
static constexpr auto	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<IsFloat T>
	Complex (T const &) -> Complex< T >
template<IsFloat R, IsFloat I>
	Complex (R const &, I const &) -> Complex< Common< R, I > >
template<IsComplex T>
static constexpr auto	abs (T const &a)
template<IsComplex T>
static constexpr auto	acos (T const &a)
template<IsComplex T>
static constexpr auto	acosh (T const &a)
template<IsComplex TA, IsComplex TB>
static constexpr auto	operator+ (TA const &a, TB const &b)
template<IsComplex T>
static constexpr auto	arg (T const &a)
template<IsComplex T>
static constexpr auto	asin (T const &a)
template<IsComplex T>
static constexpr auto	asinh (T const &a)
template<IsComplex T>
static constexpr auto	atan (T const &a)
template<IsComplex T>
static constexpr auto	atanh (T const &a)
template<IsValue C, IsComplex T>
static constexpr auto	cast (T const &a)
template<class X > requires IsComplex<RemoveReference<X>>
static constexpr decltype(auto)	complexify (X &&a)
template<IsComplex T>
static constexpr auto	conj (T const &a)
template<IsComplex T>
static constexpr auto	cos (T const &a)
template<IsComplex T>
static constexpr auto	cosh (T const &a)
template<IsComplex TA, IsComplex TB>
static constexpr auto	delta (TA const &a, TB const &b)
template<IsComplex TA, IsComplex TB>
static constexpr auto	operator/ (TA const &a, TB const &b)
template<IsComplex TA, IsComplex TB>
static constexpr auto	operator== (TA const &a, TB const &b)
template<class X > requires IsComplex<RemoveReference<X>>
static constexpr decltype(auto)	eval (X &&a)
template<IsComplex T>
static constexpr auto	exp (T const &a)
template<class X > requires IsComplex<RemoveReference<X>>
static constexpr decltype(auto)	imag (X &&a)
template<IsComplex TA, IsComplex TB>
static constexpr auto	innerProduct (TA const &a, TB const &b)
template<IsComplex T>
static constexpr auto	log (T const &a)
template<IsComplex T>
static constexpr auto	log10 (T const &a)
template<IsComplex T>
static constexpr auto	log2 (T const &a)
template<IsComplex T>
static constexpr auto	operator- (T const &a)
template<IsComplex TA, IsComplex TB>
static constexpr auto	operator* (TA const &a, TB const &b)
template<Index P, Index Q = P, IsComplex T> requires (P == 1 && Q == 1)
static constexpr auto	norm (T const &a)
template<Index P, Index Q, IsComplex T> requires (P == 2 && Q == 1)
static constexpr auto	norm (T const &a)
template<Index P = 2, Index Q = P, IsComplex T> requires (P == 2 && Q == 2)
static constexpr auto	norm (T const &a)
template<IsComplex TA, IsComplex TB>
static constexpr auto	operator!= (TA const &a, TB const &b)
template<IsComplex T>
static constexpr auto	operator+ (T const &a)
template<IsValue TA, IsValue TB>
static constexpr auto	polar (TA const &rho, TB const &theta)
template<IsComplex X, IsComplex Y>
static constexpr auto	pow (X const &x, Y const &y)
template<IsComplex T, class S >
static auto	print (T const &value, S &&stream)
template<IsComplex T>
static constexpr auto	rcp (T const &b)
template<class X > requires IsComplex<RemoveReference<X>>
static constexpr decltype(auto)	real (X &&a)
template<Size D = 0, IsComplex T>
static constexpr auto	round (T const &a)
template<IsComplex TA, IsComplex TB>
static constexpr auto	scalarProduct (TA const &a, TB const &b)
template<IsComplex T>
static constexpr auto	sign (T const &a)
template<IsComplex T>
static constexpr auto	sin (T const &a)
template<IsComplex T>
static constexpr auto	sinh (T const &a)
template<IsComplex T>
static constexpr auto	sqrt (T const &a)
template<IsComplex T>
static constexpr auto	square (T const &a)
template<IsComplex TA, IsComplex TB>
static constexpr auto	operator- (TA const &a, TB const &b)
template<IsComplex T>
static constexpr auto	tan (T const &a)
template<IsComplex T>
static constexpr auto	tanh (T const &a)
template<IsComplex T>
static constexpr auto	trunc (T const &a)
static constexpr auto	isProperAlignment (Size const alignment)
template<Size S, Size P = cMaxDefaultAlignment> requires (isProperAlignment(P))
static consteval auto	alignment ()
static auto	alloc (Size size, Size const alignment=cMaxDefaultAlignment)
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> requires IsInvocable<Equal, TA, TB>
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> requires IsPredicate<Equal, CommonArray<A1, TA, Ns...>, CommonArray<A2, TA, 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<Allocation A, class T , Size... Ns, class S >
static auto	print (CommonArray< A, T, Ns... > const &arg, S &&stream)
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> requires (sizeof...(Ns) == sizeof...(Ss))
static constexpr auto	operator* (Subscripts< Ns... > const &lhs, Sizes< Ss... > const)
template<Size... Ns, Size... Ss> requires (sizeof...(Ns) == sizeof...(Ss))
static constexpr auto	operator* (Sizes< Ss... > const, Subscripts< Ns... > const &rhs)
template<Size... Ns, Size... Ss> requires (sizeof...(Ns) == sizeof...(Ss))
static constexpr auto	operator/ (Subscripts< Ns... > const &lhs, Sizes< Ss... > const)
template<Size... Ns, Size... Ss> requires (sizeof...(Ns) == sizeof...(Ss))
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> requires requires { permute<Ps...>(makeSeriesFor<Index, Ns...>()); }
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> requires requires { rotate<D, Step>(makeSeriesFor<Index, Ns...>()); }
static constexpr auto	rotate (Subscripts< Ns... > const &arg)
template<Index... Ds, Size... Ns> requires requires { 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)
static auto	print (Bool const value, std::FILE *stream)
template<IsIntegral T>
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 > requires (C == Context::CompileTime || C == Context::RunTime) && requires { String(declval<A>()); String(declval<N>()); String(declval<D>()); }
static constexpr auto	parameter (A &&argument, N &&name, D &&description, T const &defaultValue)
template<Context C, class T , class A , class N , class D > requires (C == Context::CompileTime || C == Context::RunTime) && requires { String(declval<A>()); String(declval<N>()); String(declval<D>()); }
static constexpr auto	parameter (A &&argument, N &&name, D &&description)
template<Context C, class T , class A , class N , class D > requires (C == Context::RunTime) && requires { String(declval<A>()); String(declval<N>()); String(declval<D>()); }
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 > requires (C == Context::RunTime) && requires { String(declval<A>()); String(declval<N>()); String(declval<D>()); }
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> requires requires { Logging::log(declval<N>()); Logging::log(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<IsFloat T, IsRandomEngine RNG> requires (RNG::max() - RNG::min() < NumericLimits<Size>::max())
static constexpr auto	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<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<Size N, class S >
static auto	print (SeedSequence< N > const &seq, S &&stream)
template<class... Ts>
	SeedSequence (Ts &&...) -> SeedSequence< sizeof...(Ts)>
template<class X > requires IsTensorish<RemoveReference<X>> && IsInvocable<Loop<Abs>, X>
static constexpr auto	abs (X &&a)
template<class X > requires IsTensorish<RemoveReference<X>> && IsInvocable<Loop<Acos>, X>
static constexpr auto	acos (X &&a)
template<class X > requires IsTensorish<RemoveReference<X>> && IsInvocable<Loop<Acosh>, X>
static constexpr auto	acosh (X &&a)
template<class XA , class XB > requires IsTensorish<RemoveReference<XA>> && IsTensorish<RemoveReference<XB>> && IsInvocable<Loop<Add>, XA, XB>
static constexpr auto	operator+ (XA &&a, XB &&b)
template<class X > requires IsTensorish<RemoveReference<X>> && IsInvocable<Loop<Arg>, X>
static constexpr auto	arg (X &&a)
template<class X > requires IsTensorish<RemoveReference<X>> && IsInvocable<Loop<Asin>, X>
static constexpr auto	asin (X &&a)
template<class X > requires IsTensorish<RemoveReference<X>> && IsInvocable<Loop<Asinh>, X>
static constexpr auto	asinh (X &&a)
template<class X > requires IsTensorish<RemoveReference<X>> && IsInvocable<Loop<Atan>, X>
static constexpr auto	atan (X &&a)
template<class XA , class XB > requires IsTensorish<RemoveReference<XA>> && IsTensorish<RemoveReference<XB>> && IsInvocable<Loop<Atan2>, XA, XB>
static constexpr auto	atan2 (XA &&a, XB &&b)
template<class X > requires IsTensorish<RemoveReference<X>> && IsInvocable<Loop<Atanh>, X>
static constexpr auto	atanh (X &&a)
template<class X , IsTensorish R = RemoveReference<X>>
static constexpr auto	backwards (X &&a)
template<Size... Bs, class X , IsConvertible< Index >... Os, IsTensorish R = RemoveReference<X>> requires (sizeof...(Bs) == R::Dimension && sizeof...(Os) == R::Dimension && typename R::Sizes() % Sizes<Bs...>() == Constant<Size, 0>())
static constexpr auto	block (X &&a, Os const ... offsets)
template<Size... Bs, class X , IsTensorish R = RemoveReference<X>> requires (sizeof...(Bs) == R::Dimension)
static constexpr auto	broadcast (X &&a)
template<class C , class X > requires IsTensorish<RemoveReference<X>> && IsInvocable<Loop<Cast<C>>, X>
static constexpr auto	cast (X &&a)
template<class X > requires IsTensorish<RemoveReference<X>> && IsInvocable<Loop<Ceil>, X>
static constexpr auto	ceil (X &&a)
template<Index... Ds, class X , IsConvertible< Index >... Is, IsTensorish R = RemoveReference<X>> requires (sizeof...(Is) == sizeof...(Ds)) && requires { chip<Ds...>(typename R::Sizes()); }
static constexpr auto	chip (X &&a, Is const ... indices)
template<class X > requires IsTensorish<RemoveReference<X>> && IsInvocable<Loop<Complexify>, X>
static constexpr auto	complexify (X &&a)
template<class X > requires IsTensorish<RemoveReference<X>> && IsInvocable<Loop<Conj>, X>
static constexpr auto	conj (X &&a)
template<Index... Is, class X , IsTensorish R = RemoveReference<X>> requires (isEven(sizeof...(Is)) && sizeof...(Is) <= R::Dimension) && (max(Is...) < R::Dimension) && (cut<2, 0>(select<Is...>(typename R::Sizes())) == cut<2, 1>(select<Is...>(typename R::Sizes())))
static constexpr auto	contract (X &&a)
template<Index... Is, class XA , class XB , IsTensorish RA = RemoveReference<XA>, IsTensorish RB = RemoveReference<XB>> requires (isEven(sizeof...(Is)) && sizeof...(Is) / 2 <= min(RA::Dimension, RB::Dimension)) && (reduce<Max>(cut<2, 0>(Sizes<Is...>())) < RA::Dimension && reduce<Max>(cut<2, 1>(Sizes<Is...>())) < RB::Dimension) && (expand(cut<2, 0>(Sizes<Is...>()), [](auto const... indices) { return select<indices...>(typename RA::Sizes()); }) == expand(cut<2, 1>(Sizes<Is...>()), [](auto const... indices) { return select<indices...>(typename RB::Sizes()); }))
static constexpr auto	contract (XA &&a, XB &&b)
template<class X > requires IsTensorish<RemoveReference<X>> && IsInvocable<Loop<Cos>, X>
static constexpr auto	cos (X &&a)
template<class X > requires IsTensorish<RemoveReference<X>> && IsInvocable<Loop<Cosh>, X>
static constexpr auto	cosh (X &&a)
template<class XA , class XB > requires IsTensorish<RemoveReference<XA>> && IsTensorish<RemoveReference<XB>> && IsInvocable<Loop<Delta>, XA, XB>
static constexpr auto	delta (XA &&a, XB &&b)
template<class XA , class XB , IsTensorish RA = RemoveReference<XA>, IsTensorish RB = RemoveReference<XB>> requires (RA::Dimension == RB::Dimension) && HasCommon<typename RA::Type, typename RB::Type>
static constexpr auto	directSum (XA &&a, XB &&b)
template<class XA , class XB > requires IsTensorish<RemoveReference<XA>> && IsTensorish<RemoveReference<XB>> && IsInvocable<Loop<Div>, XA, XB>
static constexpr auto	operator/ (XA &&a, XB &&b)
template<class XA , class XB > requires IsTensorish<RemoveReference<XA>> && IsTensorish<RemoveReference<XB>> && IsInvocable<Loop<Equal>, XA, XB>
static constexpr auto	operator== (XA &&a, XB &&b)
template<class X > requires IsTensor<RemoveReference<X>>
static constexpr decltype(auto)	eval (X &&a)
template<class X > requires IsTensorView<RemoveReference<X>>
static constexpr auto	eval (X &&a)
template<Index... Es, class F , class... Xs> requires (IsTensorish<RemoveReference<Xs>> && ...) && (sizeof...(Xs) > 0) && ((select<Es...>(typename TupleElement<0, Tuple<RemoveReference<Xs>...>>::Sizes()) == select<Es...>(typename RemoveReference<Xs>::Sizes())) && ...) && IsInvocable<F, ResultOf<Chip<Es...>, Xs, decltype(Es)...>...>
static constexpr auto	exclude (F &&f, Xs &&...args)
template<class F , Index... Es, class... Xs> requires (IsTensorish<RemoveReference<Xs>> && ...) && requires { exclude<Es...>(declval<F>(), declval<Xs>()...); }
static constexpr auto	exclude (Xs &&...args)
template<class X > requires IsTensorish<RemoveReference<X>> && IsInvocable<Loop<Exp>, X>
static constexpr auto	exp (X &&a)
template<Index K, class X , IsTensorish R = RemoveReference<X>> requires (K < R::Dimension)
static constexpr auto	flatten (X &&a)
template<class X > requires IsTensorish<RemoveReference<X>> && IsInvocable<Loop<Floor>, X>
static constexpr auto	floor (X &&a)
template<class XA , class XB > requires IsTensorish<RemoveReference<XA>> && IsTensorish<RemoveReference<XB>> && IsInvocable<Loop<FMod>, XA, XB>
static constexpr auto	fmod (XA &&a, XB &&b)
template<Position P, class X , IsTensorish R = RemoveReference<X>> requires (P == Position::Left) && IsInvocable<Unfolding<R::Dimension - 2>, X>
static constexpr auto	folding (X &&a)
template<Position P, class X , IsTensorish R = RemoveReference<X>> requires (P == Position::Right) && IsInvocable<Unfolding<0>, X>
static constexpr auto	folding (X &&a)
template<class XA , class XB > requires IsTensorish<RemoveReference<XA>> && IsTensorish<RemoveReference<XB>> && IsInvocable<Loop<Greater>, XA, XB>
static constexpr auto	operator> (XA &&a, XB &&b)
template<class XA , class XB > requires IsTensorish<RemoveReference<XA>> && IsTensorish<RemoveReference<XB>> && IsInvocable<Loop<GreaterEqual>, XA, XB>
static constexpr auto	operator>= (XA &&a, XB &&b)
template<class XA , class XB > requires IsTensorish<RemoveReference<XA>> && IsTensorish<RemoveReference<XB>> && IsInvocable<Loop<Mul>, XA, XB>
static constexpr auto	hadamardProduct (XA &&a, XB &&b)
template<class X > requires IsTensorish<RemoveReference<X>> && IsInvocable<Loop<Imag>, X>
static constexpr auto	imag (X &&a)
template<Size... Is, class X , IsTensorish R = RemoveReference<X>> requires (sizeof...(Is) == R::Dimension)
static constexpr auto	inflate (X &&a)
template<class XA , class XB , IsTensorish RA = RemoveReference<XA>, IsTensorish RB = RemoveReference<XB>> requires IsInvocable<ScalarProduct, ResultOf<Conj, XA>, XB>
static constexpr auto	innerProduct (XA &&a, XB &&b)
template<class XA , class XB , IsTensorish RA = RemoveReference<XA>, IsTensorish RB = RemoveReference<XB>> requires (RA::Dimension == RB::Dimension) && IsInvocable<Mul, ResultOf<XA, typename RA::Subscripts>, ResultOf<XB, typename RB::Subscripts>>
static constexpr auto	kroneckerProduct (XA &&a, XB &&b)
template<class XA , class XB > requires IsTensorish<RemoveReference<XA>> && IsTensorish<RemoveReference<XB>> && IsInvocable<Loop<Less>, XA, XB>
static constexpr auto	operator< (XA &&a, XB &&b)
template<class XA , class XB > requires IsTensorish<RemoveReference<XA>> && IsTensorish<RemoveReference<XB>> && IsInvocable<Loop<LessEqual>, XA, XB>
static constexpr auto	operator<= (XA &&a, XB &&b)
template<class X , IsTensorish R = RemoveReference<X>> requires (R::Dimension > 0)
static constexpr auto	linearize (X &&a)
template<class X > requires IsTensorish<RemoveReference<X>> && IsInvocable<Loop<Log>, X>
static constexpr auto	log (X &&a)
template<class X > requires IsTensorish<RemoveReference<X>> && IsInvocable<Loop<Log10>, X>
static constexpr auto	log10 (X &&a)
template<class X > requires IsTensorish<RemoveReference<X>> && IsInvocable<Loop<Log2>, X>
static constexpr auto	log2 (X &&a)
template<class XA , class XB > requires IsTensorish<RemoveReference<XA>> && IsTensorish<RemoveReference<XB>> && IsInvocable<Loop<LogicalAnd>, XA, XB>
static constexpr auto	operator&& (XA &&a, XB &&b)
template<class X > requires IsTensorish<RemoveReference<X>> && IsInvocable<Loop<LogicalNot>, X>
static constexpr auto	operator! (X &&a)
template<class XA , class XB > requires IsTensorish<RemoveReference<XA>> && IsTensorish<RemoveReference<XB>> && IsInvocable<Loop<LogicalOr>, XA, XB>
static constexpr auto	operator|| (XA &&a, XB &&b)
template<class F , class... Xs> requires (IsTensorish<RemoveReference<Xs>> && ...) && (sizeof...(Xs) > 0) && (IsSame<typename TupleElement<0, Tuple<RemoveReference<Xs>...>>::Sizes, typename RemoveReference<Xs>::Sizes> && ...) && IsInvocable<F, ResultOf<Xs, typename RemoveReference<Xs>::Subscripts>...>
static constexpr auto	loop (F &&f, Xs &&...args)
template<class F , class... Xs> requires (IsTensorish<RemoveReference<Xs>> && ...) && requires { loop(declval<F>(), declval<Xs>()...); }
static constexpr auto	loop (Xs &&...args)
template<class X > requires IsTensorish<RemoveReference<X>> && IsInvocable<Loop<Minus>, X>
static constexpr auto	operator- (X &&a)
template<class XA , class XB > requires IsTensorish<RemoveReference<XA>> && IsTensorish<RemoveReference<XB>> && IsInvocable<Loop<Mod>, XA, XB>
static constexpr auto	operator% (XA &&a, XB &&b)
template<Index... Ns, class F , class... Xs> requires (IsTensorish<RemoveReference<Xs>> && ...) && (sizeof...(Xs) > 0) && ((chip<Ns...>(typename TupleElement<0, Tuple<RemoveReference<Xs>...>>::Sizes()) == chip<Ns...>(RemoveReference<Xs>::Sizes())) && ...)
static constexpr auto	narrow (F &&f, Xs &&...args)
template<class F , Index... Ns, class... Xs> requires (IsTensorish<RemoveReference<Xs>> && ...) && requires { narrow<Ns...>(declval<F>(), declval<Xs>()...); }
static constexpr auto	exclude (Xs &&...args)
template<Index P, Index Q = P, class X > requires IsTensorish<RemoveReference<X>> && (Q == 1) && IsInvocable<Loop<Norm<P, 1>>, X>
static constexpr auto	norm (X &&a)
template<Index P = 2, Index Q = P, class X > requires IsTensorish<RemoveReference<X>> && (Q == 2) && IsInvocable<Loop<Norm<P, 1>>, X>
static constexpr auto	norm (X &&a)
template<Index P, Index Q, class X > requires IsTensorish<RemoveReference<X>> && (Q == 0 && P != 0) && IsInvocable<Loop<Norm<P, P>>, X>
static constexpr auto	norm (X &&a)
template<class XA , class XB > requires IsTensorish<RemoveReference<XA>> && IsTensorish<RemoveReference<XB>> && IsInvocable<Loop<NotEqual>, XA, XB>
static constexpr auto	operator!= (XA &&a, XB &&b)
template<class XA , class XB , IsTensorish RA = RemoveReference<XA>, IsTensorish RB = RemoveReference<XB>> requires IsInvocable<TensorProduct, XA, ResultOf<Conj, XB>>
static constexpr auto	outerProduct (XA &&a, XB &&b)
template<Index... Ps, class X , IsTensorish R = RemoveReference<X>> requires requires { permute<Ps...>(typename R::Sizes()); }
static constexpr auto	permute (X &&a)
template<class X > requires IsTensorish<RemoveReference<X>> && IsInvocable<Loop<Plus>, X>
static constexpr auto	operator+ (X &&a)
template<class XA , class XB > requires IsTensorish<RemoveReference<XA>> && IsTensorish<RemoveReference<XB>> && IsInvocable<Loop<Pow>, XA, XB>
static constexpr auto	pow (XA &&a, XB &&b)
template<class X , class S , IsTensorish R = RemoveReference<X>> requires (R::Dimension == 0)
static void	print (X &&arg, S &&stream)
template<class X , class S , IsTensorish R = RemoveReference<X>>
static void	print (X &&arg, S &&stream)
template<class X > requires IsTensorish<RemoveReference<X>> && IsInvocable<Loop<Rcp>, X>
static constexpr auto	rcp (X &&a)
template<class X > requires IsTensorish<RemoveReference<X>> && IsInvocable<Loop<Real>, X>
static constexpr auto	real (X &&a)
template<class F , Index... Is, class X , IsTensorish R = RemoveReference<X>, class E = ResultOf<X, typename R::Subscripts>> requires (sizeof...(Is) <= R::Dimension && max(Is...) < R::Dimension) && IsInvocable<F, E, E> && IsInvocable<F, decltype(F::template Identity<typename R::Type>()), E> && requires { chip<Is...>(typename R::Sizes()); }
static constexpr auto	reduce (X &&a)
template<class F , class X , IsTensorish R = RemoveReference<X>, class E = ResultOf<X, typename R::Subscripts>> requires IsInvocable<F, E, E> && IsInvocable<F, decltype(F::template Identity<typename R::Type>()), E>
static constexpr auto	reduce (X &&a)
template<Size... Ns, class X , IsTensorish R = RemoveReference<X>> requires (Sizes<Ns...>::size() == R::size())
static constexpr auto	reshape (X &&a)
template<Bool... Rs, class X , IsTensorish R = RemoveReference<X>> requires (sizeof...(Rs) == R::Dimension)
static constexpr auto	reverse (X &&a)
template<Direction D, Size S = 1, class X , IsTensorish R = RemoveReference<X>> requires (D == Direction::Leftwards || D == Direction::Rightwards)
static constexpr auto	rotate (X &&a)
template<Size D = 0, class X > requires IsTensorish<RemoveReference<X>> && IsInvocable<Loop<Round<D>>, X>
static constexpr auto	round (X &&a)
template<class X , IsTensorish R = RemoveReference<X>> requires IsInvocable<Reshape<>, X>
static constexpr auto	scalar (X &&a)
template<class XA , class XB , IsTensorish RA = RemoveReference<XA>, IsTensorish RB = RemoveReference<XB>> requires IsInvocable<HadamardProduct, XA, XB>
static constexpr auto	scalarProduct (XA &&a, XB &&b)
template<class XA , class XB , IsTensorish RA = RemoveReference<XA>, IsTensorish RB = RemoveReference<XB>> requires (RA::Dimension == 0 || RB::Dimension == 0) && IsInvocable<TensorProduct, XA, XB>
static constexpr auto	operator* (XA &&a, XB &&b)
template<class XA , class XB , IsTensorish RA = RemoveReference<XA>, IsTensorish RB = RemoveReference<XB>> requires (RA::Dimension == 0 && RB::Dimension != 0) && IsInvocable<Div, typename RB::template ChangeType<typename RA::Type>, XB>
static constexpr auto	operator/ (XA &&a, XB &&b)
template<class XA , class XB , IsTensorish RA = RemoveReference<XA>, IsTensorish RB = RemoveReference<XB>> requires (RA::Dimension != 0 && RB::Dimension == 0) && IsInvocable<Div, XA, typename RA::template ChangeType<typename RB::Type>>
static constexpr auto	operator/ (XA &&a, XB &&b)
template<class XA , class XB , IsTensorish RA = RemoveReference<XA>, class RB = RemoveReference<XB>> requires IsDefined<Tensor<RB>> && IsInvocable<Mul, XA, Tensor<RB>>
static constexpr auto	operator* (XA &&a, XB &&b)
template<class XA , class XB , class RA = RemoveReference<XA>, IsTensorish RB = RemoveReference<XB>> requires IsDefined<Tensor<RA>> && IsInvocable<Mul, Tensor<RA>, XB>
static constexpr auto	operator* (XA &&a, XB &&b)
template<class XA , class XB , IsTensorish RA = RemoveReference<XA>, class RB = RemoveReference<XB>> requires IsDefined<Tensor<RB>> && IsInvocable<Div, XA, Tensor<RB>>
static constexpr auto	operator/ (XA &&a, XB &&b)
template<class XA , class XB , class RA = RemoveReference<XA>, IsTensorish RB = RemoveReference<XB>> requires IsDefined<Tensor<RA>> && IsInvocable<Div, Tensor<RA>, XB>
static constexpr auto	operator/ (XA &&a, XB &&b)
template<class X > requires IsTensorish<RemoveReference<X>> && IsInvocable<Loop<Sign>, X>
static constexpr auto	sign (X &&a)
template<class X > requires IsTensorish<RemoveReference<X>> && IsInvocable<Loop<Sin>, X>
static constexpr auto	sin (X &&a)
template<class X > requires IsTensorish<RemoveReference<X>> && IsInvocable<Loop<Sinh>, X>
static constexpr auto	sinh (X &&a)
template<Size... Es, class X , IsConvertible< Index >... Os, IsTensorish R = RemoveReference<X>> requires (sizeof...(Es) == R::Dimension && sizeof...(Os) == R::Dimension && Sizes<Es...>() <= typename R::Sizes())
static constexpr auto	slice (X &&a, Os const ... offsets)
template<class X > requires IsTensorish<RemoveReference<X>> && IsInvocable<Loop<Sqrt>, X>
static constexpr auto	sqrt (X &&a)
template<class X > requires IsTensorish<RemoveReference<X>> && IsInvocable<Loop<Square>, X>
static constexpr auto	square (X &&a)
template<class X , IsTensorish R = RemoveReference<X>>
static constexpr auto	squeeze (X &&a)
template<Size... Ss, class X , IsConvertible< Index >... Os, IsTensorish R = RemoveReference<X>> requires (sizeof...(Ss) == R::Dimension && sizeof...(Os) == R::Dimension && typename R::Sizes() % Sizes<Ss...>() == Constant<Size, 0>())
static constexpr auto	stride (X &&a, Os const ... offsets)
template<class XA , class XB > requires IsTensorish<RemoveReference<XA>> && IsTensorish<RemoveReference<XB>> && IsInvocable<Loop<Sub>, XA, XB>
static constexpr auto	operator- (XA &&a, XB &&b)
template<class XA , class XB , IsTensorish RA = RemoveReference<XA>, IsTensorish RB = RemoveReference<XB>, class EA = ResultOf<XA, typename RA::Subscripts>, class EB = ResultOf<XB, typename RB::Subscripts>> requires IsSame<typename RA::Sizes, typename RB::Sizes> && IsInvocable<Swap, EA, EB> && IsInvocable<View, XA> && IsInvocable<View, XB>
static constexpr auto	swap (XA &&a, XB &&b)
template<class X > requires IsTensorish<RemoveReference<X>> && IsInvocable<Loop<Tan>, X>
static constexpr auto	tan (X &&a)
template<class X > requires IsTensorish<RemoveReference<X>> && IsInvocable<Loop<Tanh>, X>
static constexpr auto	tanh (X &&a)
template<class XA , class XB , IsTensorish RA = RemoveReference<XA>, IsTensorish RB = RemoveReference<XB>, class EA = ResultOf<XA, typename RA::Subscripts>, class EB = ResultOf<XB, typename RB::Subscripts>> requires IsInvocable<Mul, EA, EB>
static constexpr auto	tensorProduct (XA &&a, XB &&b)
template<class X > requires IsTensorish<RemoveReference<X>> && IsInvocable<Loop<Trunc>, X>
static constexpr auto	trunc (X &&a)
template<Index K, class X , IsTensorish R = RemoveReference<X>> requires (K + 1 < R::Dimension)
static constexpr auto	unfolding (X &&a)
template<class X > requires IsTensorView<RemoveReference<X>>
static constexpr decltype(auto)	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 > requires IsTensorish<RemoveReference<XE>> && IsTensorish<RemoveReference<XA>> && IsTensorish<RemoveReference<XB>> && IsInvocable<Loop<Where>, XE, XA, XB>
static constexpr auto	where (XE &&e, XA &&a, XB &&b)
template<class X > requires IsTensorish<RemoveReference<X>> && IsInvocable<Transpose, X>
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 > requires IsTensorish<RemoveReference<XA>> && IsTensorish<RemoveReference<XB>> && IsInvocable<Transform<OT>, XA> && IsInvocable<Mul, ResultOf<Restrict<OR>, ResultOf<Transform<OT>, XA>>, XB>
static constexpr auto	apply (XA &&a, XB &&b)
template<class X , IsTensorish R = RemoveReference<X>> requires (isEven(R::Dimension))
static constexpr auto	diagonal (X &&a)
template<class X , IsTensorish R = RemoveReference<X>> requires (isEven(R::Dimension))
static constexpr auto	extractDiagonal (X &&a)
template<Size... Ds, class X , IsTensorish R = RemoveReference<X>> requires (isEven(sizeof...(Ds))) && (sizeof...(Ds) / 2 == R::Dimension) && (cut<2, 0>(Sizes<Ds...>()) == typename R::Sizes() || cut<2, 1>(Sizes<Ds...>()) == typename R::Sizes())
static constexpr auto	fromDiagonal (X &&a)
template<class X , IsTensorish R = RemoveReference<X>>
static constexpr auto	fromDiagonal (X &&a)
template<class X , IsTensorish R = RemoveReference<X>, IsValue TT = Value<R>> requires IsInvocable<Diagonal, X>
static constexpr auto	isDiagonal (X &&a, TT const &tolerance=NumericLimits< TT >::tolerance())
template<class X , IsTensorish R = RemoveReference<X>, IsValue TT = Value<R>> requires IsInvocable<LowerTriangular, X>
static constexpr auto	isLowerTriangular (X &&a, TT const &tolerance=NumericLimits< TT >::tolerance())
template<class X , IsTensorish R = RemoveReference<X>, IsValue TT = Value<R>> requires IsInvocable<OffDiagonal, X>
static constexpr auto	isOffDiagonal (X &&a, TT const &tolerance=NumericLimits< TT >::tolerance())
template<class X , IsTensorish R = RemoveReference<X>, IsValue TT = Value<R>> requires IsInvocable<Adjoint, X>
static constexpr auto	isSelfAdjoint (X &&a, TT const &tolerance=NumericLimits< TT >::tolerance())
template<class X , IsTensorish R = RemoveReference<X>, IsValue TT = Value<R>> requires IsInvocable<StrictlyLowerTriangular, X>
static constexpr auto	isStrictlyLowerTriangular (X &&a, TT const &tolerance=NumericLimits< TT >::tolerance())
template<class X , IsTensorish R = RemoveReference<X>, IsValue TT = Value<R>> requires IsInvocable<StrictlyUpperTriangular, X>
static constexpr auto	isStrictlyUpperTriangular (X &&a, TT const &tolerance=NumericLimits< TT >::tolerance())
template<class X , IsTensorish R = RemoveReference<X>, IsValue TT = Value<R>> requires IsInvocable<Transpose, X>
static constexpr auto	isSymmetric (X &&a, TT const &tolerance=NumericLimits< TT >::tolerance())
template<class X , IsTensorish R = RemoveReference<X>, IsValue TT = Value<R>> requires IsInvocable<UnitLowerTriangular, X>
static constexpr auto	isUnitLowerTriangular (X &&a, TT const &tolerance=NumericLimits< TT >::tolerance())
template<class X , IsTensorish R = RemoveReference<X>, IsValue TT = Value<R>> requires IsInvocable<UnitUpperTriangular, X>
static constexpr auto	isUnitUpperTriangular (X &&a, TT const &tolerance=NumericLimits< TT >::tolerance())
template<class X , IsTensorish R = RemoveReference<X>, IsValue TT = Value<R>> requires IsInvocable<Adjoint, X>
static constexpr auto	isUnitary (X &&a, TT const &tolerance=NumericLimits< TT >::tolerance())
template<class X , IsTensorish R = RemoveReference<X>, IsValue TT = Value<R>> requires IsInvocable<UpperTriangular, X>
static constexpr auto	isUpperTriangular (X &&a, TT const &tolerance=NumericLimits< TT >::tolerance())
template<class X , IsTensorish R = RemoveReference<X>> requires (R::Dimension == 2)
static constexpr auto	lowerTriangular (X &&a)
template<class X , IsTensorish R = RemoveReference<X>> requires (R::Dimension > 0 && isEven(R::Dimension))
static constexpr auto	matricize (X &&a)
template<class XA , class XB , IsTensorish RA = RemoveReference<XA>, IsTensorish RB = RemoveReference<XB>> requires (isEven(RA::Dimension)) && (RA::Dimension / 2 == RB::Dimension) && IsSame<decltype(cut<2, 1>(typename RA::Sizes())), typename RB::Sizes> && IsInvocable<Contract<RB::Dimension, 0>, XA, XB>
static constexpr auto	operator* (XA &&a, XB &&b)
template<class XA , class XB , IsTensorish RA = RemoveReference<XA>, IsTensorish RB = RemoveReference<XB>> requires (isEven(RB::Dimension)) && (RA::Dimension == RB::Dimension / 2) && IsSame<typename RA::Sizes, decltype(cut<2, 0>(typename RB::Sizes()))> && IsInvocable<Contract<0, 0>, XA, XB>
static constexpr auto	operator* (XA &&a, XB &&b)
template<class XA , class XB , IsTensorish RA = RemoveReference<XA>, IsTensorish RB = RemoveReference<XB>> requires (isEven(RA::Dimension)) && (isEven(RB::Dimension)) && (RA::Dimension == RB::Dimension) && IsSame<decltype(cut<2, 1>(typename RA::Sizes())), decltype(cut<2, 0>(typename RB::Sizes()))> && IsInvocable<Contract<RA::Dimension / 2, 0>, XA, XB>
static constexpr auto	operator* (XA &&a, XB &&b)
template<class X , IsTensorish R = RemoveReference<X>> requires (isEven(R::Dimension))
static constexpr auto	offDiagonal (X &&a)
template<Operator::Restrict OR = Operator::Restrict::None, class X > requires IsTensorish<RemoveReference<X>> && (OR == Operator::Restrict::Diagonal)
static constexpr auto	restrict (X &&a)
template<Operator::Restrict OR = Operator::Restrict::None, class X > requires IsTensorish<RemoveReference<X>> && (OR == Operator::Restrict::LowerTriangular)
static constexpr auto	restrict (X &&a)
template<Operator::Restrict OR = Operator::Restrict::None, class X > requires IsTensorish<RemoveReference<X>> && (OR == Operator::Restrict::StrictlyLowerTriangular)
static constexpr auto	restrict (X &&a)
template<Operator::Restrict OR = Operator::Restrict::None, class X > requires IsTensorish<RemoveReference<X>> && (OR == Operator::Restrict::UpperTriangular)
static constexpr auto	restrict (X &&a)
template<Operator::Restrict OR = Operator::Restrict::None, class X > requires IsTensorish<RemoveReference<X>> && (OR == Operator::Restrict::StrictlyUpperTriangular)
static constexpr auto	restrict (X &&a)
template<Operator::Restrict OR = Operator::Restrict::None, class X > requires IsTensorish<RemoveReference<X>> && (OR == Operator::Restrict::OffDiagonal)
static constexpr auto	restrict (X &&a)
template<Operator::Restrict OR = Operator::Restrict::None, class X > requires IsTensorish<RemoveReference<X>> && (OR == Operator::Restrict::None)
static constexpr decltype(auto)	restrict (X &&a)
template<class X , IsTensorish R = RemoveReference<X>> requires (R::Dimension == 2)
static constexpr auto	strictlyLowerTriangular (X &&a)
template<class X , IsTensorish R = RemoveReference<X>> requires (R::Dimension == 2)
static constexpr auto	strictlyUpperTriangular (X &&a)
template<class X , IsTensorish R = RemoveReference<X>> requires IsInvocable<ExtractDiagonal, X>
static constexpr auto	trace (X &&a)
template<Operator::Transform OT = Operator::Transform::None, class X > requires IsTensorish<RemoveReference<X>> && (OT == Operator::Transform::Transpose)
static constexpr auto	transform (X &&a)
template<Operator::Transform OT = Operator::Transform::None, class X > requires IsTensorish<RemoveReference<X>> && (OT == Operator::Transform::Adjoint)
static constexpr auto	transform (X &&a)
template<Operator::Transform OT = Operator::Transform::None, class X > requires IsTensorish<RemoveReference<X>> && (OT == Operator::Transform::None)
static constexpr decltype(auto)	transform (X &&a)
template<class X , IsTensorish R = RemoveReference<X>> requires (isEven(R::Dimension))
static constexpr auto	transpose (X &&a)
template<class X , IsTensorish R = RemoveReference<X>> requires (R::Dimension == 2)
static constexpr auto	unitLowerTriangular (X &&a)
template<class X , IsTensorish R = RemoveReference<X>> requires (R::Dimension == 2)
static constexpr auto	unitUpperTriangular (X &&a)
template<class X , IsTensorish R = RemoveReference<X>> requires (R::Dimension == 2)
static constexpr auto	upperTriangular (X &&a)
template<class F , class T , Size... Ns>
	Tensor (TensorViews::View< T, Sizes< Ns... >, F > const &) -> Tensor< T, Ns... >
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<IsValue T>
static constexpr auto	abs (T const &a)
template<class XA , class XB > requires IsInvocable<Sub, XA, XB> && IsInvocable<Norm<>, ResultOf<Sub, XA, XB>>
static constexpr auto	absoluteError (XA &&a, XB &&b)
template<IsFloat T>
static constexpr auto	acos (T const &a)
template<IsFloat T>
static constexpr auto	acosh (T const a)
template<IsFloat TA, IsFloat TB>
static constexpr auto	operator+ (TA const &a, TB const &b)
template<IsFloat T>
static constexpr auto	arg (T const &a)
template<IsFloat T>
static constexpr auto	asin (T const &a)
template<IsFloat T>
static constexpr auto	asinh (T const &a)
template<IsFloat T>
static constexpr auto	atan (T const &a)
template<IsFloat Y, IsFloat X>
static constexpr auto	atan2 (Y const &y, X const &x)
template<IsFloat T>
static constexpr auto	atanh (T const &a)
template<IsValue C, IsValue T> requires IsConstructible<C, typename T::Fundamental>
static constexpr auto	cast (T const &a)
template<IsFloat T>
static constexpr auto	ceil (T const a)
template<IsValue T> requires IsConstructible<Complex<T>, T>
static constexpr auto	complexify (T const &a)
template<IsValue T>
static constexpr auto	conj (T const &a)
template<IsFloat T>
static constexpr auto	cos (T const a)
template<IsFloat T>
static constexpr auto	cosh (T const &a)
template<IsValue TA, IsValue TB>
static constexpr auto	delta (TA const &a, TB const &b)
template<IsValue TA, IsValue TB> requires IsUnsignedInteger<TA> || IsUnsignedInteger<TB>
static constexpr auto	delta (TA const &a, TB const &b)
template<IsFloat TA, IsFloat TB>
static constexpr auto	operator/ (TA const &a, TB const &b)
template<IsValue TA, IsValue TB>
static constexpr auto	operator== (TA const &a, TB const &b)
template<class X > requires IsValue<RemoveReference<X>> || IsBool<RemoveReference<X>>
static constexpr decltype(auto)	eval (X &&a)
template<IsFloat T>
static constexpr auto	exp (T const &a)
template<IsFloat T>
static constexpr auto	floor (T const &a)
template<IsFloat TA, IsFloat TB>
static constexpr auto	fmod (TA const &a, TB const &b)
template<class F , Bool E = false, Direction D = Direction::Forwards, class X > requires (D == Direction::Forwards || D == Direction::Backwards)
static constexpr decltype(auto)	fold (X &&a)
template<class F , Bool E = false, Direction D = Direction::Forwards, class XA , class XB > requires IsInvocable<F, XA, XB> && (D == Direction::Forwards || D == Direction::Backwards)
static constexpr decltype(auto)	fold (XA &&a, XB &&b)
template<class F , Bool E = false, Direction D = Direction::Forwards, class XA , class XB , class... Xs> requires IsInvocable<F, XA, XB> && ((D == Direction::Forwards || D == Direction::Backwards) && sizeof...(Xs) > 0) && requires { fold<F, E, D>(fold<F, E, D>(declval<XA>(), declval<XB>()), declval<Xs>()...); }
static constexpr decltype(auto)	fold (XA &&a, XB &&b, Xs &&...args)
template<IsValue TA, IsValue TB>
static constexpr auto	operator> (TA const &a, TB const &b)
template<IsValue TA, IsValue TB>
static constexpr auto	operator>= (TA const &a, TB const &b)
template<IsValue T>
static constexpr auto	imag (T const)
template<IsValue TA, IsValue TB>
static constexpr auto	innerProduct (TA const &a, TB const &b)
template<class XE , class XA , IsValue TT = Value<RemoveReference<XE>>> requires IsInvocable<RelativeError, XE, XA>
static constexpr auto	isApprox (XE &&expected, XA &&approx, TT const &tolerance=NumericLimits< TT >::tolerance())
template<IsFloat T>
static constexpr auto	isFinite (T const &a)
template<class X , class R = RemoveReference<X>, IsValue TT = Value<R>> requires IsDefined<Identity<R>> && IsConstructible<Identity<R>> && IsInvocable<RelativeError, decltype(identity<R>()), X>
static constexpr auto	isIdentity (X &&a, TT const &tolerance=NumericLimits< TT >::tolerance())
template<IsFloat T>
static constexpr auto	isNaN (T const &a)
template<class X , class R = RemoveReference<X>, IsValue TT = Value<R>> requires IsDefined<Unit<R>> && IsConstructible<Unit<R>> && IsInvocable<RelativeError, decltype(unit<R>()), X>
static constexpr auto	isUnit (X &&a, TT const &tolerance=NumericLimits< TT >::tolerance())
template<class X , class R = RemoveReference<X>, IsValue TT = Value<R>> requires IsDefined<Zero<R>> && IsConstructible<Zero<R>> && IsInvocable<AbsoluteError, decltype(zero<R>()), X>
static constexpr auto	isZero (X &&a, TT const &tolerance=NumericLimits< TT >::tolerance())
template<IsValue TA, IsValue TB>
static constexpr auto	operator< (TA const &a, TB const &b)
template<IsValue TA, IsValue TB>
static constexpr auto	operator<= (TA const &a, TB const &b)
template<IsFloat T>
static constexpr auto	log (T const &a)
template<IsFloat T>
static constexpr auto	log10 (T const &a)
template<IsFloat T>
static constexpr auto	log2 (T const &a)
template<class... Xs> requires IsInvocable<Fold<Add>, Xs...>
static constexpr auto	mean (Xs &&...args)
template<IsFloat T>
static constexpr auto	operator- (T const &a)
template<IsInteger TA, IsInteger TB>
static constexpr auto	operator% (TA const &a, TB const &b)
template<IsFloat TA, IsFloat TB>
static constexpr auto	operator* (TA const &a, TB const &b)
template<Index P, Index Q, IsValue T> requires (P == 2 && Q == 1)
static constexpr auto	norm (T const &a)
template<Index P = 2, Index Q = P, IsValue T> requires (P == Q)
static constexpr auto	norm (T const &a)
template<IsValue TA, IsValue TB>
static constexpr auto	operator!= (TA const &a, TB const &b)
template<IsFloat T>
static constexpr T	pi ()
static constexpr auto	pi ()
template<IsFloat T>
static constexpr auto	operator+ (T const &a)
template<IsFloat B, IsFloat N>
static constexpr auto	pow (B const &base, N const &exp)
template<IsFloat T>
static auto	print (T const &value, std::FILE *stream)
template<IsValue T>
static constexpr auto	rcp (T const &a)
template<class X > requires IsValue<RemoveReference<X>>
static constexpr decltype(auto)	real (X &&a)
template<class XE , class XA > requires IsInvocable<AbsoluteError, XE, XA> && IsInvocable<Norm<>, XE>
static constexpr auto	relativeError (XE &&expected, XA &&approx)
template<Size D = 0, Position P = Position::Right, IsFloat T> requires (P == Position::Right) || (P == Position::Left)
static constexpr auto	round (T const &a)
template<IsValue TA, IsValue TB>
static constexpr auto	scalarProduct (TA const &a, TB const &b)
template<IsValue T>
static constexpr auto	sign (T const &a)
template<IsValue T> requires IsUnsignedInteger<T>
static constexpr auto	sign (T const &a)
template<IsFloat T>
static constexpr auto	sin (T const a)
template<IsFloat T>
static constexpr auto	sinh (T const a)
template<IsFloat T>
static constexpr auto	sqrt (T const &a)
template<IsValue T>
static constexpr auto	square (T const &a)
template<IsFloat TA, IsFloat TB>
static constexpr auto	operator- (TA const &a, TB const &b)
template<IsFloat T>
static constexpr auto	tan (T const a)
template<IsFloat T>
static constexpr auto	tanh (T const a)
template<IsFloat T>
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 , IsTensorish R = RemoveReference<X>> requires (P == Position::Left)
static constexpr auto	orthogonalize (X &&a)
template<Position P, class X , IsTensorish R = RemoveReference<X>> requires (P == Position::Right)
static constexpr auto	orthogonalize (X &&a)
template<Size C, Position P, class X , IsTensorish R = RemoveReference<X>, IsFloat VT = Value<R>> requires (C < reduce<Min>(RemoveReference<decltype(folding<!P>( declval<X>()))>::Sizes())) && (P == Position::Right)
static constexpr auto	truncate (X &&a, VT const &tolerance=NumericLimits< VT >::epsilon())
template<Size C, Position P, class X , IsTensorish R = RemoveReference<X>, IsFloat VT = Value<R>> requires (C < reduce<Min>(RemoveReference<decltype(folding<!P>( declval<X>()))>::Sizes())) && (P == Position::Left)
static constexpr auto	truncate (X &&a, VT const &tolerance=NumericLimits< VT >::epsilon())
template<Size C, Position P, class X , IsTensorish R = RemoveReference<X>, IsFloat VT = Value<R>>
static constexpr auto	truncate (X &&a, VT const &tolerance=NumericLimits< VT >::epsilon())
template<class X , class R = RemoveReference<X>> requires (TensorTrain::IsTensorish<R> || TensorTrain::IsOperatorish<R>) && IsInvocable<Loop<Conj>, X>
static constexpr auto	conj (X &&a)
template<class F , class... Xs> requires ((TensorTrain::IsTensorish<RemoveReference<Xs>> || TensorTrain::IsOperatorish<RemoveReference<Xs>>) && ...) && (sizeof...(Xs) > 0) && (isSame(RemoveReference<Xs>::Dimension...)) && requires { declval<F>().template operator()<0>( declval<Xs>().template core<0>()...); }
static constexpr auto	enumerate (F &&f, Xs &&...args)
template<class F , class... Xs> requires ((TensorTrain::IsTensorish<RemoveReference<Xs>> || TensorTrain::IsOperatorish<RemoveReference<Xs>>) && ...) && requires { enumerate(declval<F>(), declval<Xs>()...); }
static constexpr auto	enumerate (Xs &&...args)
template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>> requires ((TensorTrain::IsTensorish<RA> && TensorTrain::IsTensorish<RB>) || (TensorTrain::IsOperatorish<RA> && TensorTrain::IsOperatorish<RB>)) && IsInvocable<Conj, XA> && IsInvocable<ScalarProduct, ResultOf<Conj, XA>, XB>
static constexpr auto	innerProduct (XA &&a, XB &&b)
template<class F , class... Xs> requires ((TensorTrain::IsTensorish<RemoveReference<Xs>> || TensorTrain::IsOperatorish<RemoveReference<Xs>>) && ...) && (sizeof...(Xs) > 0) && (isSame(RemoveReference<Xs>::Dimension...)) && requires { declval<F>()(declval<Xs>().template core<0>()...); }
static constexpr auto	loop (F &&f, Xs &&...args)
template<class F , class... Xs> requires ((TensorTrain::IsTensorish<RemoveReference<Xs>> || TensorTrain::IsOperatorish<RemoveReference<Xs>>) && ...) && requires { loop(declval<F>(), declval<Xs>()...); }
static constexpr auto	loop (Xs &&...args)
template<class X , class R = RemoveReference<X>> requires (TensorTrain::IsTensorish<R> || TensorTrain::IsOperatorish<R>)
static constexpr auto	operator- (X &&a)
template<Index P = 2, Index Q = P, class X , class R = RemoveReference<X>> requires (TensorTrain::IsTensorish<R> || TensorTrain::IsOperatorish<R>) && (P == 2 && Q == 2)
static constexpr auto	norm (X &&a)
template<class X , class R = RemoveReference<X>> requires (TensorTrain::IsTensorish<R> || TensorTrain::IsOperatorish<R>) && IsInvocable<Loop<Plus>, X>
static constexpr auto	operator+ (X &&a)
template<class X , class S , class R = RemoveReference<X>> requires TensorTrain::IsTensorish<R> || TensorTrain::IsOperatorish<R>
static void	print (X &&arg, S &&stream)
template<IsSizes Ranks, class X , class R = RemoveReference<X>, IsFloat VT = Value<R>> requires (TensorTrain::IsTensorish<R> || TensorTrain::IsOperatorish<R>) && IsFloat<Value<R>> && (Ranks::Dimension == R::Dimension - 1)
static constexpr auto	round (X &&a, VT const &tolerance=NumericLimits< VT >::epsilon())
template<class X , class R = RemoveReference<X>, IsFloat VT = Value<R>> requires (TensorTrain::IsTensorish<R> || TensorTrain::IsOperatorish<R>) && IsFloat<Value<R>>
static constexpr auto	round (X &&a, VT const &tolerance=NumericLimits< VT >::epsilon())
template<Size C, class X , class R = RemoveReference<X>, IsFloat VT = Value<R>> requires (TensorTrain::IsTensorish<R> || TensorTrain::IsOperatorish<R>) && IsFloat<Value<R>>
static constexpr auto	round (X &&a, VT const &tolerance=NumericLimits< VT >::epsilon())
template<Size... Cs, class X , class R = RemoveReference<X>, IsFloat VT = Value<R>> requires (TensorTrain::IsTensorish<R> || TensorTrain::IsOperatorish<R>) && IsFloat<Value<R>> && (sizeof...(Cs) > 1) && (sizeof...(Cs) == R::Dimension - 1)
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>> requires (TensorTrain::IsTensorish<RA> || TensorTrain::IsOperatorish<RA>) && (IsValue<RB> || IsComplex<RB>) && IsInvocable<Mul, typename RA::Type, RB const &>
static constexpr auto	operator* (XA &&a, XB &&b)
template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>> requires (IsValue<RA> || IsComplex<RA>) && (TensorTrain::IsTensorish<RB> || TensorTrain::IsOperatorish<RB>) && IsInvocable<Mul, RA const &, typename RB::Type>
static constexpr auto	operator* (XA &&a, XB &&b)
template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>> requires (TensorTrain::IsTensorish<RA> || TensorTrain::IsOperatorish<RA>) && (IsValue<RB> || IsComplex<RB>) && IsInvocable<Div, typename RA::Type, RB const &>
static constexpr auto	operator/ (XA &&a, XB &&b)
template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>> requires (TensorTrain::IsTensorish<RA> || TensorTrain::IsOperatorish<RA>) && IsTensorish<RB> && IsInvocable<Mul, XA, typename RB::Type>
static constexpr auto	operator* (XA &&a, XB &&b)
template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>> requires IsTensorish<RA> && (TensorTrain::IsTensorish<RB> || TensorTrain::IsOperatorish<RB>) && IsInvocable<Mul, typename RA::Type, XB>
static constexpr auto	operator* (XA &&a, XB &&b)
template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>> requires (TensorTrain::IsTensorish<RA> || TensorTrain::IsOperatorish<RA>) && IsTensorish<RB> && IsInvocable<Div, XA, typename RB::Type>
static constexpr auto	operator/ (XA &&a, XB &&b)
template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>> requires ((TensorTrain::IsTensorish<RA> && TensorTrain::IsTensorish<RB>) || (TensorTrain::IsOperatorish<RA> && TensorTrain::IsOperatorish<RB>)) && IsInvocable<Minus, XB> && IsInvocable<Add, XA, ResultOf<Minus, XB>>
static constexpr auto	operator- (XA &&a, XB &&b)
template<class XA , class XB , TensorTrain::IsOperatorish RA = RemoveReference<XA>, TensorTrain::IsOperatorish RB = RemoveReference<XB>> requires IsSame<typename RA::Sizes, typename RB::Sizes>
static constexpr auto	operator+ (XA &&a, XB &&b)
template<class X > requires TensorTrain::IsOperatorish<RemoveReference<X>> && IsInvocable<Transpose, X> && IsInvocable<Conj, ResultOf<Transpose, X>>
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 , TensorTrain::IsOperatorish RA = RemoveReference<XA>, class RB = RemoveReference<XB>> requires (TensorTrain::IsOperatorish<RB> || TensorTrain::IsTensorish<RemoveReference<XB>>) && IsInvocable<Transform<OT>, XA> && IsInvocable<Mul, ResultOf<Restrict<OR>, ResultOf<Transform<OT>, XA>>, XB>
static constexpr auto	apply (XA &&a, XB &&b)
template<class X , TensorTrain::IsOperatorish R = RemoveReference<X>>
static constexpr auto	backwards (X &&a)
template<class X > requires TensorTrain::IsOperator<RemoveReference<X>>
static constexpr decltype(auto)	eval (X &&a)
template<class X > requires TensorTrain::IsOperatorView<RemoveReference<X>>
static constexpr auto	eval (X &&a)
template<class XA , class XB , TensorTrain::IsOperatorish RA = RemoveReference<XA>, TensorTrain::IsOperatorish RB = RemoveReference<XB>> requires IsSame<typename RA::Sizes, typename RB::Sizes>
static constexpr auto	hadamardProduct (XA &&a, XB &&b)
template<class XA , class XB , TensorTrain::IsOperatorish RA = RemoveReference<XA>, TensorTrain::IsTensorish RB = RemoveReference<XB>> requires IsSame<typename RA::N, typename RB::N>
static constexpr auto	operator* (XA &&a, XB &&b)
template<class XA , class XB , TensorTrain::IsTensorish RA = RemoveReference<XA>, TensorTrain::IsOperatorish RB = RemoveReference<XB>> requires IsSame<typename RA::N, typename RB::M>
static constexpr auto	operator* (XA &&a, XB &&b)
template<Operator::Restrict OR = Operator::Restrict::None, class X > requires TensorTrain::IsOperatorish<RemoveReference<X>> && (OR == Operator::Restrict::None)
static constexpr decltype(auto)	restrict (X &&a)
template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>> requires TensorTrain::IsOperatorish<RA> && TensorTrain::IsOperatorish<RB> && IsInvocable<HadamardProduct, XA, XB>
static constexpr auto	scalarProduct (XA &&a, XB &&b)
template<Operator::Transform OT = Operator::Transform::None, class X > requires TensorTrain::IsOperatorish<RemoveReference<X>> && (OT == Operator::Transform::Transpose)
static constexpr auto	transform (X &&a)
template<Operator::Transform OT = Operator::Transform::None, class X > requires TensorTrain::IsOperatorish<RemoveReference<X>> && (OT == Operator::Transform::Adjoint)
static constexpr auto	transform (X &&a)
template<Operator::Transform OT = Operator::Transform::None, class X > requires TensorTrain::IsOperatorish<RemoveReference<X>> && (OT == Operator::Transform::None)
static constexpr auto	transform (X &&a)
template<class X > requires TensorTrain::IsOperatorish<RemoveReference<X>> && IsInvocable<Loop<Permute<0, 2, 1, 3>>, X>
static constexpr auto	transpose (X &&a)
template<class X > requires TensorTrain::IsOperatorView<RemoveReference<X>>
static constexpr decltype(auto)	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 , TensorTrain::IsTensorish RA = RemoveReference<XA>, TensorTrain::IsTensorish RB = RemoveReference<XB>> requires IsSame<typename RA::Sizes, typename RB::Sizes>
static constexpr auto	operator+ (XA &&a, XB &&b)
template<class X , TensorTrain::IsTensorish R = RemoveReference<X>>
static constexpr auto	backwards (X &&a)
template<class X > requires TensorTrain::IsTensor<RemoveReference<X>>
static constexpr decltype(auto)	eval (X &&a)
template<class X > requires TensorTrain::IsTensorView<RemoveReference<X>>
static constexpr auto	eval (X &&a)
template<class XA , class XB , TensorTrain::IsTensorish RA = RemoveReference<XA>, TensorTrain::IsTensorish RB = RemoveReference<XB>> requires IsSame<typename RA::Sizes, typename RB::Sizes>
static constexpr auto	hadamardProduct (XA &&a, XB &&b)
template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>> requires TensorTrain::IsTensorish<RA> && TensorTrain::IsTensorish<RB> && IsInvocable<HadamardProduct, XA, XB>
static constexpr auto	scalarProduct (XA &&a, XB &&b)
template<class X > requires TensorTrain::IsTensorView<RemoveReference<X>>
static constexpr decltype(auto)	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	cMaxDefaultAlignment = alignof(std::max_align_t)
constexpr Size	cSimdSizeByte

Typedef Documentation

AddConst

template<class T >

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

Array

template<class T , Size... Ns>

using pRC::Array

Initial value:

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

Bool

using pRC::Bool = bool

Common

template<class... Ts>

using pRC::Common = std::common_type_t<Ts...>

Conditional

template<Bool 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>

DefaultRandomEngine

using pRC::DefaultRandomEngine = Threefry<20>

HeapArray

template<class T , Size... Ns>

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

Index

using pRC::Index = Size

Mutex

using pRC::Mutex = std::mutex

NonComplex

template<class T >

using pRC::NonComplex = RemoveConstReference<ResultOf<Eval, ResultOf<Real, T>>>

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

Tuple

template<class... Ts>

using pRC::Tuple = std::tuple<Ts...>

TupleElement

template<std::size_t I, class T >

using pRC::TupleElement = std::tuple_element_t<I, T>

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>

Value

template<class T >

using pRC::Value = typename ValueType<T>::Type

Void

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<IsComplex T>

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

inlinestaticconstexpr

abs() [2/3]

template<IsValue T>

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

inlinestaticconstexpr

abs() [3/3]

template<class X >
requires IsTensorish<RemoveReference<X>> && IsInvocable<Loop<Abs>, X>

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

inlinestaticconstexpr

absoluteError()

template<class XA , class XB >
requires IsInvocable<Sub, XA, XB> && IsInvocable<Norm<>, ResultOf<Sub, XA, XB>>

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

inlinestaticconstexpr

acos() [1/3]

template<IsComplex T>

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

inlinestaticconstexpr

acos() [2/3]

template<IsFloat T>

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

inlinestaticconstexpr

acos() [3/3]

template<class X >
requires IsTensorish<RemoveReference<X>> && IsInvocable<Loop<Acos>, X>

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

inlinestaticconstexpr

acosh() [1/3]

template<IsComplex T>

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

inlinestaticconstexpr

acosh() [2/3]

template<IsFloat T>

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

inlinestaticconstexpr

acosh() [3/3]

template<class X >
requires IsTensorish<RemoveReference<X>> && IsInvocable<Loop<Acosh>, X>

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

inlinestaticconstexpr

adjoint() [1/3]

template<class T >

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

inlinestaticconstexpr

adjoint() [2/3]

template<class X >
requires IsTensorish<RemoveReference<X>> && IsInvocable<Transpose, X>

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

inlinestaticconstexpr

adjoint() [3/3]

template<class X >
requires TensorTrain::IsOperatorish<RemoveReference<X>> && IsInvocable<Transpose, X> && IsInvocable<Conj, ResultOf<Transpose, X>>

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

inlinestaticconstexpr

alignment()

template<Size S, Size P = cMaxDefaultAlignment>
requires (isProperAlignment(P))

static consteval auto pRC::alignment ( )

inlinestaticconsteval

alloc()

static auto pRC::alloc ( Size size, Size const alignment = cMaxDefaultAlignment )

inlinestatic

apply() [1/6]

template<class T , class X , IsTensorish R = RemoveReference<X>>
requires (R::Dimension == 2) && ((IsTensor<R> && !IsReference<X>) || IsAssignable<X>)

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 , IsTensorish R = RemoveReference<X>>
requires (R::Dimension == 1) && ((IsTensor<R> && !IsReference<X>) || IsAssignable<X>)

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

inlinestaticconstexpr

apply() [3/6]

template<class T , class X , IsTensorish R = RemoveReference<X>>
requires (R::Dimension == 2) && ((IsTensor<R> && !IsReference<X>) || IsAssignable<X>)

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

inlinestaticconstexpr

apply() [4/6]

template<class T , class X , IsTensorish R = RemoveReference<X>>
requires (R::Dimension == 1) && ((IsTensor<R> && !IsReference<X>) || IsAssignable<X>)

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

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 >
requires IsTensorish<RemoveReference<XA>> && IsTensorish<RemoveReference<XB>> && IsInvocable<Transform<OT>, XA> && IsInvocable<Mul, ResultOf<Restrict<OR>, ResultOf<Transform<OT>, XA>>, XB>

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 , TensorTrain::IsOperatorish RA = RemoveReference<XA>, class RB = RemoveReference<XB>>
requires (TensorTrain::IsOperatorish<RB> || TensorTrain::IsTensorish<RemoveReference<XB>>) && IsInvocable<Transform<OT>, XA> && IsInvocable<Mul, ResultOf<Restrict<OR>, ResultOf<Transform<OT>, XA>>, XB>

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

inlinestaticconstexpr

arg() [1/3]

template<IsComplex T>

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

inlinestaticconstexpr

arg() [2/3]

template<IsFloat T>

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

inlinestaticconstexpr

arg() [3/3]

template<class X >
requires IsTensorish<RemoveReference<X>> && IsInvocable<Loop<Arg>, X>

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

inlinestaticconstexpr

as()

template<class X >

static constexpr RemoveConst< X > pRC::as ( X && a )

inlinestaticconstexpr

asConst() [1/2]

template<class X >

static constexpr RemoveConst< X > pRC::asConst ( X && a )

inlinestaticconstexpr

asConst() [2/2]

template<class X >

static constexpr AddConst< X > & pRC::asConst ( X & a )

inlinestaticconstexpr

asin() [1/3]

template<IsComplex T>

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

inlinestaticconstexpr

asin() [2/3]

template<IsFloat T>

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

inlinestaticconstexpr

asin() [3/3]

template<class X >
requires IsTensorish<RemoveReference<X>> && IsInvocable<Loop<Asin>, X>

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

inlinestaticconstexpr

asinh() [1/3]

template<IsComplex T>

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

inlinestaticconstexpr

asinh() [2/3]

template<IsFloat T>

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

inlinestaticconstexpr

asinh() [3/3]

template<class X >
requires IsTensorish<RemoveReference<X>> && IsInvocable<Loop<Asinh>, X>

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

inlinestaticconstexpr

atan() [1/3]

template<IsComplex T>

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

inlinestaticconstexpr

atan() [2/3]

template<IsFloat T>

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

inlinestaticconstexpr

atan() [3/3]

template<class X >
requires IsTensorish<RemoveReference<X>> && IsInvocable<Loop<Atan>, X>

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

inlinestaticconstexpr

atan2() [1/2]

template<class XA , class XB >
requires IsTensorish<RemoveReference<XA>> && IsTensorish<RemoveReference<XB>> && IsInvocable<Loop<Atan2>, XA, XB>

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

inlinestaticconstexpr

atan2() [2/2]

template<IsFloat Y, IsFloat X>

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

inlinestaticconstexpr

atanh() [1/3]

template<IsComplex T>

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

inlinestaticconstexpr

atanh() [2/3]

template<IsFloat T>

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

inlinestaticconstexpr

atanh() [3/3]

template<class X >
requires IsTensorish<RemoveReference<X>> && IsInvocable<Loop<Atanh>, X>

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

inlinestaticconstexpr

backwards() [1/3]

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

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

inlinestaticconstexpr

backwards() [2/3]

template<class X , TensorTrain::IsOperatorish R = RemoveReference<X>>

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

inlinestaticconstexpr

backwards() [3/3]

template<class X , TensorTrain::IsTensorish R = RemoveReference<X>>

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

inlinestaticconstexpr

bitRotateLeft()

template<IsUnsignedIntegral TA, IsUnsignedIntegral TB>

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

inlinestaticconstexpr

bitRotateRight()

template<IsUnsignedIntegral TA, IsUnsignedIntegral TB>

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

inlinestaticconstexpr

block()

template<Size... Bs, class X , IsConvertible< Index >... Os, IsTensorish R = RemoveReference<X>>
requires (sizeof...(Bs) == R::Dimension && sizeof...(Os) == R::Dimension && typename R::Sizes() % Sizes<Bs...>() == Constant<Size, 0>())

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

inlinestaticconstexpr

broadcast()

template<Size... Bs, class X , IsTensorish R = RemoveReference<X>>
requires (sizeof...(Bs) == R::Dimension)

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

inlinestaticconstexpr

cast() [1/3]

template<IsValue C, IsComplex T>

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

inlinestaticconstexpr

cast() [2/3]

template<IsValue C, IsValue T>
requires IsConstructible<C, typename T::Fundamental>

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

inlinestaticconstexpr

cast() [3/3]

template<class C , class X >
requires IsTensorish<RemoveReference<X>> && IsInvocable<Loop<Cast<C>>, X>

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

inlinestaticconstexpr

ceil() [1/2]

template<IsFloat T>

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

inlinestaticconstexpr

ceil() [2/2]

template<class X >
requires IsTensorish<RemoveReference<X>> && IsInvocable<Loop<Ceil>, X>

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

inlinestaticconstexpr

ceilDiv()

template<IsUnsignedIntegral TA, IsUnsignedIntegral TB>

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

inlinestaticconstexpr

chip() [1/4]

template<Index D, Index... Ds, class T , T... Is>
requires (sizeof...(Ds) < sizeof...(Is) && max(D, Ds...) < sizeof...(Is))

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

inlinestaticconstexpr

chip() [2/4]

template<class T , T... Is>

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

inlinestaticconstexpr

chip() [3/4]

template<Index... Ds, Size... Ns>
requires requires { chip<Ds...>(Sequence<Index, Ns...>()); }

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

inlinestaticconstexpr

chip() [4/4]

template<Index... Ds, class X , IsConvertible< Index >... Is, IsTensorish R = RemoveReference<X>>
requires (sizeof...(Is) == sizeof...(Ds)) && requires { chip<Ds...>(typename R::Sizes()); }

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

inlinestaticconstexpr

cholesky()

template<Operator::Hint H = Operator::Hint::None, class X , IsTensorish R = RemoveReference<X>>
requires (R::Dimension == 2) && (R::size(0) == R::size(1))

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<IsFloat R, IsFloat I>

pRC::Complex	(	R const &	,
		I const &	) -> Complex< Common< R, I > >

Complex() [2/2]

template<IsFloat T>

pRC::Complex

(

T const &

)

-> Complex< T >

complexify() [1/3]

template<IsValue T>
requires IsConstructible<Complex<T>, T>

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

inlinestaticconstexpr

complexify() [2/3]

template<class X >
requires IsComplex<RemoveReference<X>>

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

inlinestaticconstexpr

complexify() [3/3]

template<class X >
requires IsTensorish<RemoveReference<X>> && IsInvocable<Loop<Complexify>, X>

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

inlinestaticconstexpr

conj() [1/4]

template<IsComplex T>

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

inlinestaticconstexpr

conj() [2/4]

template<IsValue T>

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

inlinestaticconstexpr

conj() [3/4]

template<class X >
requires IsTensorish<RemoveReference<X>> && IsInvocable<Loop<Conj>, X>

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

inlinestaticconstexpr

conj() [4/4]

template<class X , class R = RemoveReference<X>>
requires (TensorTrain::IsTensorish<R> || TensorTrain::IsOperatorish<R>) && IsInvocable<Loop<Conj>, X>

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

inlinestaticconstexpr

contract() [1/2]

template<Index... Is, class X , IsTensorish R = RemoveReference<X>>
requires (isEven(sizeof...(Is)) && sizeof...(Is) <= R::Dimension) && (max(Is...) < R::Dimension) && (cut<2, 0>(select<Is...>(typename R::Sizes())) == cut<2, 1>(select<Is...>(typename R::Sizes())))

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

inlinestaticconstexpr

contract() [2/2]

template<Index... Is, class XA , class XB , IsTensorish RA = RemoveReference<XA>, IsTensorish RB = RemoveReference<XB>>
requires (isEven(sizeof...(Is)) && sizeof...(Is) / 2 <= min(RA::Dimension, RB::Dimension)) && (reduce<Max>(cut<2, 0>(Sizes<Is...>())) < RA::Dimension && reduce<Max>(cut<2, 1>(Sizes<Is...>())) < RB::Dimension) && (expand(cut<2, 0>(Sizes<Is...>()), [](auto const... indices) { return select<indices...>(typename RA::Sizes()); }) == expand(cut<2, 1>(Sizes<Is...>()), [](auto const... indices) { return select<indices...>(typename RB::Sizes()); }))

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

inlinestaticconstexpr

copy()

template<Bool C = true, class X >

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

inlinestaticconstexpr

cos() [1/3]

template<IsComplex T>

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

inlinestaticconstexpr

cos() [2/3]

template<IsFloat T>

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

inlinestaticconstexpr

cos() [3/3]

template<class X >
requires IsTensorish<RemoveReference<X>> && IsInvocable<Loop<Cos>, X>

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

inlinestaticconstexpr

cosh() [1/3]

template<IsComplex T>

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

inlinestaticconstexpr

cosh() [2/3]

template<IsFloat T>

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

inlinestaticconstexpr

cosh() [3/3]

template<class X >
requires IsTensorish<RemoveReference<X>> && IsInvocable<Loop<Cosh>, X>

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

inlinestaticconstexpr

cut()

template<Index B, Index P, class T , T... Is>
requires (sizeof...(Is) % B == 0 && P < B)

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

inlinestaticconstexpr

dealloc()

static auto pRC::dealloc ( void * ptr )

inlinestatic

delta() [1/4]

template<IsComplex TA, IsComplex TB>

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

inlinestaticconstexpr

delta() [2/4]

template<IsValue TA, IsValue TB>

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

inlinestaticconstexpr

delta() [3/4]

template<IsValue TA, IsValue TB>
requires IsUnsignedInteger<TA> || IsUnsignedInteger<TB>

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

inlinestaticconstexpr

delta() [4/4]

template<class XA , class XB >
requires IsTensorish<RemoveReference<XA>> && IsTensorish<RemoveReference<XB>> && IsInvocable<Loop<Delta>, XA, XB>

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

inlinestaticconstexpr

diagonal()

template<class X , IsTensorish R = RemoveReference<X>>
requires (isEven(R::Dimension))

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

inlinestaticconstexpr

directSum()

template<class XA , class XB , IsTensorish RA = RemoveReference<XA>, IsTensorish RB = RemoveReference<XB>>
requires (RA::Dimension == RB::Dimension) && HasCommon<typename RA::Type, typename RB::Type>

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

inlinestaticconstexpr

enumerate() [1/2]

template<class F , class... Xs>
requires ((TensorTrain::IsTensorish<RemoveReference<Xs>> || TensorTrain::IsOperatorish<RemoveReference<Xs>>) && ...) && (sizeof...(Xs) > 0) && (isSame(RemoveReference<Xs>::Dimension...)) && requires { declval<F>().template operator()<0>( declval<Xs>().template core<0>()...); }

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

inlinestaticconstexpr

enumerate() [2/2]

template<class F , class... Xs>
requires ((TensorTrain::IsTensorish<RemoveReference<Xs>> || TensorTrain::IsOperatorish<RemoveReference<Xs>>) && ...) && requires { enumerate(declval<F>(), declval<Xs>()...); }

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

inlinestaticconstexpr

eval() [1/8]

template<class X >
requires IsComplex<RemoveReference<X>>

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

inlinestaticconstexpr

eval() [2/8]

template<class X >
requires IsTensor<RemoveReference<X>>

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

inlinestaticconstexpr

eval() [3/8]

template<class X >
requires IsTensorView<RemoveReference<X>>

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

inlinestaticconstexpr

eval() [4/8]

template<class X >
requires IsValue<RemoveReference<X>> || IsBool<RemoveReference<X>>

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

inlinestaticconstexpr

eval() [5/8]

template<class X >
requires TensorTrain::IsOperator<RemoveReference<X>>

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

inlinestaticconstexpr

eval() [6/8]

template<class X >
requires TensorTrain::IsOperatorView<RemoveReference<X>>

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

inlinestaticconstexpr

eval() [7/8]

template<class X >
requires TensorTrain::IsTensor<RemoveReference<X>>

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

inlinestaticconstexpr

eval() [8/8]

template<class X >
requires TensorTrain::IsTensorView<RemoveReference<X>>

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

inlinestaticconstexpr

exclude() [1/3]

template<Index... Es, class F , class... Xs>
requires (IsTensorish<RemoveReference<Xs>> && ...) && (sizeof...(Xs) > 0) && ((select<Es...>(typename TupleElement<0, Tuple<RemoveReference<Xs>...>>::Sizes()) == select<Es...>(typename RemoveReference<Xs>::Sizes())) && ...) && IsInvocable<F, ResultOf<Chip<Es...>, Xs, decltype(Es)...>...>

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

inlinestaticconstexpr

exclude() [2/3]

template<class F , Index... Es, class... Xs>
requires (IsTensorish<RemoveReference<Xs>> && ...) && requires { exclude<Es...>(declval<F>(), declval<Xs>()...); }

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

inlinestaticconstexpr

exclude() [3/3]

template<class F , Index... Ns, class... Xs>
requires (IsTensorish<RemoveReference<Xs>> && ...) && requires { narrow<Ns...>(declval<F>(), declval<Xs>()...); }

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

inlinestaticconstexpr

exp() [1/3]

template<IsComplex T>

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

inlinestaticconstexpr

exp() [2/3]

template<IsFloat T>

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

inlinestaticconstexpr

exp() [3/3]

template<class X >
requires IsTensorish<RemoveReference<X>> && IsInvocable<Loop<Exp>, X>

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

inlinestaticconstexpr

expand()

template<class T , T... Seq, class F , class... Xs>
requires IsInvocable<F, Xs..., Constant<T, Seq>...>

static constexpr decltype(auto) pRC::expand ( Sequence< T, Seq... > const , F && f, Xs &&... args )

inlinestaticconstexpr

extractDiagonal()

template<class X , IsTensorish R = RemoveReference<X>>
requires (isEven(R::Dimension))

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 , IsTensorish R = RemoveReference<X>>
requires (K < R::Dimension)

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<IsFloat T>

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

inlinestaticconstexpr

floor() [2/2]

template<class X >
requires IsTensorish<RemoveReference<X>> && IsInvocable<Loop<Floor>, X>

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

inlinestaticconstexpr

fmod() [1/2]

template<IsFloat TA, IsFloat TB>

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

inlinestaticconstexpr

fmod() [2/2]

template<class XA , class XB >
requires IsTensorish<RemoveReference<XA>> && IsTensorish<RemoveReference<XB>> && IsInvocable<Loop<FMod>, XA, XB>

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

inlinestaticconstexpr

fold() [1/3]

template<class F , Bool E = false, Direction D = Direction::Forwards, class X >
requires (D == Direction::Forwards || D == Direction::Backwards)

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

inlinestaticconstexpr

fold() [2/3]

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

static constexpr decltype(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>
requires IsInvocable<F, XA, XB> && ((D == Direction::Forwards || D == Direction::Backwards) && sizeof...(Xs) > 0) && requires { fold<F, E, D>(fold<F, E, D>(declval<XA>(), declval<XB>()), declval<Xs>()...); }

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

inlinestaticconstexpr

folding() [1/2]

template<Position P, class X , IsTensorish R = RemoveReference<X>>
requires (P == Position::Left) && IsInvocable<Unfolding<R::Dimension - 2>, X>

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

inlinestaticconstexpr

folding() [2/2]

template<Position P, class X , IsTensorish R = RemoveReference<X>>
requires (P == Position::Right) && IsInvocable<Unfolding<0>, X>

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

inlinestaticconstexpr

forwardAsTuple()

template<class... Xs>

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

inlinestaticconstexpr

fromDiagonal() [1/2]

template<Size... Ds, class X , IsTensorish R = RemoveReference<X>>
requires (isEven(sizeof...(Ds))) && (sizeof...(Ds) / 2 == R::Dimension) && (cut<2, 0>(Sizes<Ds...>()) == typename R::Sizes() || cut<2, 1>(Sizes<Ds...>()) == typename R::Sizes())

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

inlinestaticconstexpr

fromDiagonal() [2/2]

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

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

inlinestaticconstexpr

generateCanonical()

template<IsFloat T, IsRandomEngine RNG>
requires (RNG::max() - RNG::min() < NumericLimits<Size>::max())

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

inlinestaticconstexpr

getPermutation() [1/3]

template<class T , T From, T... Froms, T To, T... Tos, T P, T... Ps>
requires (sizeof...(Froms) == sizeof...(Tos) && sizeof...(Froms) == sizeof...(Ps))

static constexpr auto pRC::getPermutation ( Sequence< T, From, Froms... > const , Sequence< T, To, Tos... > const , Sequence< T, P, Ps... > const  )

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>
requires (sizeof...(Froms) == sizeof...(Tos))

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 >
requires IsTensorish<RemoveReference<XA>> && IsTensorish<RemoveReference<XB>> && IsInvocable<Loop<Mul>, XA, XB>

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

inlinestaticconstexpr

hadamardProduct() [2/3]

template<class XA , class XB , TensorTrain::IsOperatorish RA = RemoveReference<XA>, TensorTrain::IsOperatorish RB = RemoveReference<XB>>
requires IsSame<typename RA::Sizes, typename RB::Sizes>

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

inlinestaticconstexpr

hadamardProduct() [3/3]

template<class XA , class XB , TensorTrain::IsTensorish RA = RemoveReference<XA>, TensorTrain::IsTensorish RB = RemoveReference<XB>>
requires IsSame<typename RA::Sizes, typename RB::Sizes>

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 >
requires IsDefined<Identity<T>> && IsConstructible<Identity<T>> && IsInvocable<Identity<T>>

static constexpr auto pRC::identity ( )

inlinestaticconstexpr

identity() [2/3]

static constexpr auto pRC::identity ( )

inlinestaticconstexpr

identity() [3/3]

template<class T , class X >
requires IsDefined<Identity<T>> && IsConstructible<Identity<T>> && IsInvocable<Identity<T>, X>

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

inlinestaticconstexpr

iLog()

template<Size B, IsUnsignedIntegral T>

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

inlinestaticconstexpr

imag() [1/3]

template<IsValue T>

static constexpr auto pRC::imag ( T const )

inlinestaticconstexpr

imag() [2/3]

template<class X >
requires IsComplex<RemoveReference<X>>

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

inlinestaticconstexpr

imag() [3/3]

template<class X >
requires IsTensorish<RemoveReference<X>> && IsInvocable<Loop<Imag>, X>

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

inlinestaticconstexpr

inflate()

template<Size... Is, class X , IsTensorish R = RemoveReference<X>>
requires (sizeof...(Is) == R::Dimension)

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

inlinestaticconstexpr

innerProduct() [1/4]

template<IsComplex TA, IsComplex TB>

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

inlinestaticconstexpr

innerProduct() [2/4]

template<IsValue TA, IsValue TB>

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

inlinestaticconstexpr

innerProduct() [3/4]

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

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

inlinestaticconstexpr

innerProduct() [4/4]

template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>>
requires ((TensorTrain::IsTensorish<RA> && TensorTrain::IsTensorish<RB>) || (TensorTrain::IsOperatorish<RA> && TensorTrain::IsOperatorish<RB>)) && IsInvocable<Conj, XA> && IsInvocable<ScalarProduct, ResultOf<Conj, XA>, XB>

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<IsIntegral B, IsUnsignedIntegral N>

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

inlinestaticconstexpr

isApprox()

template<class XE , class XA , IsValue TT = Value<RemoveReference<XE>>>
requires IsInvocable<RelativeError, XE, XA>

static constexpr auto pRC::isApprox ( XE && expected, XA && approx, TT const & tolerance = NumericLimits<TT>::tolerance() )

inlinestaticconstexpr

isDiagonal()

template<class X , IsTensorish R = RemoveReference<X>, IsValue TT = Value<R>>
requires IsInvocable<Diagonal, X>

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

inlinestaticconstexpr

isEven() [1/2]

template<IsIntegral T, T V>

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

inlinestaticconstexpr

isEven() [2/2]

template<IsIntegral T>

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

inlinestaticconstexpr

isFinite()

template<IsFloat T>

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

inlinestaticconstexpr

isIdentity() [1/3]

template<IsIntegral T, T V>

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

inlinestaticconstexpr

isIdentity() [2/3]

template<IsIntegral T>

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

inlinestaticconstexpr

isIdentity() [3/3]

template<class X , class R = RemoveReference<X>, IsValue TT = Value<R>>
requires IsDefined<Identity<R>> && IsConstructible<Identity<R>> && IsInvocable<RelativeError, decltype(identity<R>()), X>

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

inlinestaticconstexpr

isLowerTriangular()

template<class X , IsTensorish R = RemoveReference<X>, IsValue TT = Value<R>>
requires IsInvocable<LowerTriangular, X>

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

inlinestaticconstexpr

isNaN()

template<IsFloat T>

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

inlinestaticconstexpr

isnan()

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

inlinestaticconstexpr

isOdd() [1/2]

template<IsIntegral T, T V>

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

inlinestaticconstexpr

isOdd() [2/2]

template<IsIntegral T>

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

inlinestaticconstexpr

isOffDiagonal()

template<class X , IsTensorish R = RemoveReference<X>, IsValue TT = Value<R>>
requires IsInvocable<OffDiagonal, X>

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

inlinestaticconstexpr

isPowerOfTwo()

template<IsIntegral T>

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

inlinestaticconstexpr

isProperAlignment()

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

inlinestaticconstexpr

iSqrt()

template<IsUnsignedIntegral T>

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

inlinestaticconstexpr

isSame()

template<class X , class... Xs>

static constexpr auto pRC::isSame ( X && arg, Xs &&... args )

inlinestaticconstexpr

isSelfAdjoint()

template<class X , IsTensorish R = RemoveReference<X>, IsValue TT = Value<R>>
requires IsInvocable<Adjoint, X>

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

inlinestaticconstexpr

isStrictlyLowerTriangular()

template<class X , IsTensorish R = RemoveReference<X>, IsValue TT = Value<R>>
requires IsInvocable<StrictlyLowerTriangular, X>

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

inlinestaticconstexpr

isStrictlyUpperTriangular()

template<class X , IsTensorish R = RemoveReference<X>, IsValue TT = Value<R>>
requires IsInvocable<StrictlyUpperTriangular, X>

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

inlinestaticconstexpr

isSymmetric()

template<class X , IsTensorish R = RemoveReference<X>, IsValue TT = Value<R>>
requires IsInvocable<Transpose, X>

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

inlinestaticconstexpr

isUnit() [1/3]

template<IsIntegral T, T V>

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

inlinestaticconstexpr

isUnit() [2/3]

template<IsIntegral T>

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

inlinestaticconstexpr

isUnit() [3/3]

template<class X , class R = RemoveReference<X>, IsValue TT = Value<R>>
requires IsDefined<Unit<R>> && IsConstructible<Unit<R>> && IsInvocable<RelativeError, decltype(unit<R>()), X>

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

inlinestaticconstexpr

isUnitary()

template<class X , IsTensorish R = RemoveReference<X>, IsValue TT = Value<R>>
requires IsInvocable<Adjoint, X>

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

inlinestaticconstexpr

isUnitLowerTriangular()

template<class X , IsTensorish R = RemoveReference<X>, IsValue TT = Value<R>>
requires IsInvocable<UnitLowerTriangular, X>

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

inlinestaticconstexpr

isUnitUpperTriangular()

template<class X , IsTensorish R = RemoveReference<X>, IsValue TT = Value<R>>
requires IsInvocable<UnitUpperTriangular, X>

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

inlinestaticconstexpr

isUpperTriangular()

template<class X , IsTensorish R = RemoveReference<X>, IsValue TT = Value<R>>
requires IsInvocable<UpperTriangular, X>

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

inlinestaticconstexpr

isZero() [1/3]

template<IsIntegral T, T V>

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

inlinestaticconstexpr

isZero() [2/3]

template<IsIntegral T>

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

inlinestaticconstexpr

isZero() [3/3]

template<class X , class R = RemoveReference<X>, IsValue TT = Value<R>>
requires IsDefined<Zero<R>> && IsConstructible<Zero<R>> && IsInvocable<AbsoluteError, decltype(zero<R>()), X>

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

template<class XA , class XB , IsTensorish RA = RemoveReference<XA>, IsTensorish RB = RemoveReference<XB>>
requires (RA::Dimension == RB::Dimension) && IsInvocable<Mul, ResultOf<XA, typename RA::Subscripts>, ResultOf<XB, typename RB::Subscripts>>

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

inlinestaticconstexpr

linearize()

template<class X , IsTensorish R = RemoveReference<X>>
requires (R::Dimension > 0)

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

inlinestaticconstexpr

log() [1/3]

template<IsComplex T>

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

inlinestaticconstexpr

log() [2/3]

template<IsFloat T>

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

inlinestaticconstexpr

log() [3/3]

template<class X >
requires IsTensorish<RemoveReference<X>> && IsInvocable<Loop<Log>, X>

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

inlinestaticconstexpr

log10() [1/3]

template<IsComplex T>

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

inlinestaticconstexpr

log10() [2/3]

template<IsFloat T>

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

inlinestaticconstexpr

log10() [3/3]

template<class X >
requires IsTensorish<RemoveReference<X>> && IsInvocable<Loop<Log10>, X>

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

inlinestaticconstexpr

log2() [1/3]

template<IsComplex T>

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

inlinestaticconstexpr

log2() [2/3]

template<IsFloat T>

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

inlinestaticconstexpr

log2() [3/3]

template<class X >
requires IsTensorish<RemoveReference<X>> && IsInvocable<Loop<Log2>, X>

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

inlinestaticconstexpr

loop() [1/4]

template<class F , class... Xs>
requires (IsTensorish<RemoveReference<Xs>> && ...) && (sizeof...(Xs) > 0) && (IsSame<typename TupleElement<0, Tuple<RemoveReference<Xs>...>>::Sizes, typename RemoveReference<Xs>::Sizes> && ...) && IsInvocable<F, ResultOf<Xs, typename RemoveReference<Xs>::Subscripts>...>

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

inlinestaticconstexpr

loop() [2/4]

template<class F , class... Xs>
requires ((TensorTrain::IsTensorish<RemoveReference<Xs>> || TensorTrain::IsOperatorish<RemoveReference<Xs>>) && ...) && (sizeof...(Xs) > 0) && (isSame(RemoveReference<Xs>::Dimension...)) && requires { declval<F>()(declval<Xs>().template core<0>()...); }

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

inlinestaticconstexpr

loop() [3/4]

template<class F , class... Xs>
requires (IsTensorish<RemoveReference<Xs>> && ...) && requires { loop(declval<F>(), declval<Xs>()...); }

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

inlinestaticconstexpr

loop() [4/4]

template<class F , class... Xs>
requires ((TensorTrain::IsTensorish<RemoveReference<Xs>> || TensorTrain::IsOperatorish<RemoveReference<Xs>>) && ...) && requires { loop(declval<F>(), declval<Xs>()...); }

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

inlinestaticconstexpr

lowerTriangular()

template<class X , IsTensorish R = RemoveReference<X>>
requires (R::Dimension == 2)

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

inlinestaticconstexpr

lq()

template<Size B = 32, class X , IsTensorish R = RemoveReference<X>>
requires IsFloat<Value<R>> && (R::Dimension == 2)

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

inlinestaticconstexpr

lu()

template<Operator::Hint H = Operator::Hint::None, class X , IsTensorish R = RemoveReference<X>>
requires (R::Dimension == 2) && (R::size(0) == R::size(1))

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

inlinestaticconstexpr

LU decomposition of a square matrix.

Calculates the LU decomposition of a square matrix. The returned object R is of the same type as the input matrix. The decomposition matrices L and U are different parts of R:

Tensor U = upperTriangular(R);
Tensor L = strictlyLowerTriangular(R);
extractDiagonal(L) = unit();

Template Parameters

H	Operator::Hint, indicates if the matrix has a special format (e.g., lower triangular) (default is Operator::Hint::None)
X	pRC tensorish class (inferred)

Parameters

a	object of class X, matrix to be decomposed

makeConstantSequence()

template<class T , Size N, T V>

static constexpr auto pRC::makeConstantSequence ( )

inlinestaticconstexpr

makeRange() [1/2]

template<class T , T First, T Last, Direction D = Direction::Forwards, T Step = T(1)>
requires (D == Direction::Forwards)

static constexpr auto pRC::makeRange ( )

inlinestaticconstexpr

makeRange() [2/2]

template<class T , T First, T Last, Direction D = Direction::Forwards, T Step = T(1)>
requires (D == Direction::Backwards)

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>
requires (sizeof...(Ts) > 0)

static constexpr auto pRC::makeSeriesFor ( )

inlinestaticconstexpr

matricize()

template<class X , IsTensorish R = RemoveReference<X>>
requires (R::Dimension > 0 && isEven(R::Dimension))

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

inlinestaticconstexpr

max() [1/3]

template<class X >

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

inlinestaticconstexpr

max() [2/3]

template<class XA , class XB >
requires IsInvocable<Greater, XA, XB>

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

inlinestaticconstexpr

max() [3/3]

template<class XA , class XB , class... Xs>
requires IsInvocable<Greater, XA, XB> && (IsInvocable<Greater, ResultOf<Where, ResultOf<Greater, XA, XB>, XA, XB>, Xs> && ...)

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

inlinestaticconstexpr

mean()

template<class... Xs>
requires IsInvocable<Fold<Add>, Xs...>

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

inlinestaticconstexpr

min() [1/3]

template<class X >

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

inlinestaticconstexpr

min() [2/3]

template<class XA , class XB >
requires IsInvocable<Less, XA, XB>

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

inlinestaticconstexpr

min() [3/3]

template<class XA , class XB , class... Xs>
requires IsInvocable<Less, XA, XB> && (IsInvocable<Less, ResultOf<Where, ResultOf<Less, XA, XB>, XA, XB>, Xs> && ...)

static constexpr decltype(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()

template<Index... Ns, class F , class... Xs>
requires (IsTensorish<RemoveReference<Xs>> && ...) && (sizeof...(Xs) > 0) && ((chip<Ns...>(typename TupleElement<0, Tuple<RemoveReference<Xs>...>>::Sizes()) == chip<Ns...>(RemoveReference<Xs>::Sizes())) && ...)

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

inlinestaticconstexpr

norm() [1/9]

template<Index P, Index Q = P, IsComplex T>
requires (P == 1 && Q == 1)

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

inlinestaticconstexpr

norm() [2/9]

template<Index P, Index Q, IsComplex T>
requires (P == 2 && Q == 1)

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

inlinestaticconstexpr

norm() [3/9]

template<Index P = 2, Index Q = P, IsComplex T>
requires (P == 2 && Q == 2)

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

inlinestaticconstexpr

norm() [4/9]

template<Index P, Index Q, IsValue T>
requires (P == 2 && Q == 1)

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

inlinestaticconstexpr

norm() [5/9]

template<Index P = 2, Index Q = P, IsValue T>
requires (P == Q)

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

inlinestaticconstexpr

norm() [6/9]

template<Index P, Index Q = P, class X >
requires IsTensorish<RemoveReference<X>> && (Q == 1) && IsInvocable<Loop<Norm<P, 1>>, X>

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

inlinestaticconstexpr

norm() [7/9]

template<Index P = 2, Index Q = P, class X >
requires IsTensorish<RemoveReference<X>> && (Q == 2) && IsInvocable<Loop<Norm<P, 1>>, X>

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

inlinestaticconstexpr

norm() [8/9]

template<Index P, Index Q, class X >
requires IsTensorish<RemoveReference<X>> && (Q == 0 && P != 0) && IsInvocable<Loop<Norm<P, P>>, X>

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

inlinestaticconstexpr

norm() [9/9]

template<Index P = 2, Index Q = P, class X , class R = RemoveReference<X>>
requires (TensorTrain::IsTensorish<R> || TensorTrain::IsOperatorish<R>) && (P == 2 && Q == 2)

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

inlinestaticconstexpr

offDiagonal()

template<class X , IsTensorish R = RemoveReference<X>>
requires (isEven(R::Dimension))

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 >
requires IsTensorish<RemoveReference<X>> && IsInvocable<Loop<LogicalNot>, X>

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

inlinestaticconstexpr

operator!=() [1/15]

template<IsSequence A, IsSequence B>

static constexpr auto pRC::operator!= ( A const , B const  )

inlinestaticconstexpr

operator!=() [2/15]

template<Allocation A1, Allocation A2, class TA , class TB , Size... Ns>
requires IsPredicate<Equal, CommonArray<A1, TA, Ns...>, CommonArray<A2, TA, Ns...>>

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

inlinestaticconstexpr

operator!=() [3/15]

template<class T , T A, T... Bs>
requires IsInvocable<NotEqual, T, T>

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

inlinestaticconstexpr

operator!=() [4/15]

template<class T >

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

constexpr

operator!=() [5/15]

template<class TA , class TB >

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

inlinestaticconstexpr

operator!=() [6/15]

template<class T >

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

constexpr

operator!=() [7/15]

template<class T , T... As, T B>
requires IsInvocable<NotEqual, T, T>

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

inlinestaticconstexpr

operator!=() [8/15]

template<Size... Ns>

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

inlinestaticconstexpr

operator!=() [9/15]

template<class X , template< class > class T>
requires IsSame<T<Void>, Identity<>> || IsSame<T<Void>, Unit<>> || IsSame<T<Void>, Zero<>>

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

inlinestaticconstexpr

operator!=() [10/15]

template<IsComplex TA, IsComplex TB>

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

inlinestaticconstexpr

operator!=() [11/15]

template<IsValue TA, IsValue TB>

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

inlinestaticconstexpr

operator!=() [12/15]

template<template< class > class TA, template< class > class TB>
requires ((IsSame<TA<Void>, Identity<>> || IsSame<TA<Void>, Unit<>> || IsSame<TA<Void>, Zero<>>) && (IsSame<TB<Void>, Identity<>> || IsSame<TB<Void>, Unit<>> || IsSame<TB<Void>, Zero<>>))

static constexpr auto pRC::operator!= ( TA< Void > const , TB< Void > const  )

inlinestaticconstexpr

operator!=() [13/15]

template<class T >

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

constexpr

operator!=() [14/15]

template<class X , template< class > class T>
requires IsSame<T<Void>, Identity<>> || IsSame<T<Void>, Unit<>> || IsSame<T<Void>, Zero<>>

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

inlinestaticconstexpr

operator!=() [15/15]

template<class XA , class XB >
requires IsTensorish<RemoveReference<XA>> && IsTensorish<RemoveReference<XB>> && IsInvocable<Loop<NotEqual>, XA, XB>

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

inlinestaticconstexpr

operator%() [1/6]

template<class T , T A, T... Bs>
requires IsInvocable<Mod, T, T>

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

inlinestaticconstexpr

operator%() [2/6]

template<class T , T... As, T B>
requires IsInvocable<Mod, T, T>

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

inlinestaticconstexpr

operator%() [3/6]

template<class T , T... As, T... Bs>
requires IsInvocable<Mod, T, T> && (sizeof...(As) == sizeof...(Bs))

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

inlinestaticconstexpr

operator%() [4/6]

template<Size... Ns, Size... Ss>
requires (sizeof...(Ns) == sizeof...(Ss))

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

inlinestaticconstexpr

operator%() [5/6]

template<IsInteger TA, IsInteger TB>

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

inlinestaticconstexpr

operator%() [6/6]

template<class XA , class XB >
requires IsTensorish<RemoveReference<XA>> && IsTensorish<RemoveReference<XB>> && IsInvocable<Loop<Mod>, XA, XB>

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

inlinestaticconstexpr

operator&&()

template<class XA , class XB >
requires IsTensorish<RemoveReference<XA>> && IsTensorish<RemoveReference<XB>> && IsInvocable<Loop<LogicalAnd>, XA, XB>

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

inlinestaticconstexpr

operator*() [1/20]

template<class T , T A, T... Bs>
requires IsInvocable<Mul, T, T>

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

inlinestaticconstexpr

operator*() [2/20]

template<class TA , class TB >

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

inlinestaticconstexpr

operator*() [3/20]

template<class T , T... As, T B>
requires IsInvocable<Mul, T, T>

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

inlinestaticconstexpr

operator*() [4/20]

template<class T , T... As, T... Bs>
requires IsInvocable<Mul, T, T> && (sizeof...(As) == sizeof...(Bs))

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

inlinestaticconstexpr

operator*() [5/20]

template<Size... Ns, Size... Ss>
requires (sizeof...(Ns) == sizeof...(Ss))

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

inlinestaticconstexpr

operator*() [6/20]

template<Size... Ns, Size... Ss>
requires (sizeof...(Ns) == sizeof...(Ss))

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

inlinestaticconstexpr

operator*() [7/20]

template<IsComplex TA, IsComplex TB>

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

inlinestaticconstexpr

operator*() [8/20]

template<IsFloat TA, IsFloat TB>

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

inlinestaticconstexpr

operator*() [9/20]

template<class XA , class XB , IsTensorish RA = RemoveReference<XA>, IsTensorish RB = RemoveReference<XB>>
requires (RA::Dimension == 0 || RB::Dimension == 0) && IsInvocable<TensorProduct, XA, XB>

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

inlinestaticconstexpr

operator*() [10/20]

template<class XA , class XB , IsTensorish RA = RemoveReference<XA>, class RB = RemoveReference<XB>>
requires IsDefined<Tensor<RB>> && IsInvocable<Mul, XA, Tensor<RB>>

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

inlinestaticconstexpr

operator*() [11/20]

template<class XA , class XB , class RA = RemoveReference<XA>, IsTensorish RB = RemoveReference<XB>>
requires IsDefined<Tensor<RA>> && IsInvocable<Mul, Tensor<RA>, XB>

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

inlinestaticconstexpr

operator*() [12/20]

template<class XA , class XB , IsTensorish RA = RemoveReference<XA>, IsTensorish RB = RemoveReference<XB>>
requires (isEven(RA::Dimension)) && (RA::Dimension / 2 == RB::Dimension) && IsSame<decltype(cut<2, 1>(typename RA::Sizes())), typename RB::Sizes> && IsInvocable<Contract<RB::Dimension, 0>, XA, XB>

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

inlinestaticconstexpr

operator*() [13/20]

template<class XA , class XB , IsTensorish RA = RemoveReference<XA>, IsTensorish RB = RemoveReference<XB>>
requires (isEven(RB::Dimension)) && (RA::Dimension == RB::Dimension / 2) && IsSame<typename RA::Sizes, decltype(cut<2, 0>(typename RB::Sizes()))> && IsInvocable<Contract<0, 0>, XA, XB>

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

inlinestaticconstexpr

operator*() [14/20]

template<class XA , class XB , IsTensorish RA = RemoveReference<XA>, IsTensorish RB = RemoveReference<XB>>
requires (isEven(RA::Dimension)) && (isEven(RB::Dimension)) && (RA::Dimension == RB::Dimension) && IsSame<decltype(cut<2, 1>(typename RA::Sizes())), decltype(cut<2, 0>(typename RB::Sizes()))> && IsInvocable<Contract<RA::Dimension / 2, 0>, XA, XB>

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

inlinestaticconstexpr

operator*() [15/20]

template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>>
requires (TensorTrain::IsTensorish<RA> || TensorTrain::IsOperatorish<RA>) && (IsValue<RB> || IsComplex<RB>) && IsInvocable<Mul, typename RA::Type, RB const &>

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

inlinestaticconstexpr

operator*() [16/20]

template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>>
requires (IsValue<RA> || IsComplex<RA>) && (TensorTrain::IsTensorish<RB> || TensorTrain::IsOperatorish<RB>) && IsInvocable<Mul, RA const &, typename RB::Type>

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

inlinestaticconstexpr

operator*() [17/20]

template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>>
requires (TensorTrain::IsTensorish<RA> || TensorTrain::IsOperatorish<RA>) && IsTensorish<RB> && IsInvocable<Mul, XA, typename RB::Type>

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

inlinestaticconstexpr

operator*() [18/20]

template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>>
requires IsTensorish<RA> && (TensorTrain::IsTensorish<RB> || TensorTrain::IsOperatorish<RB>) && IsInvocable<Mul, typename RA::Type, XB>

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

inlinestaticconstexpr

operator*() [19/20]

template<class XA , class XB , TensorTrain::IsOperatorish RA = RemoveReference<XA>, TensorTrain::IsTensorish RB = RemoveReference<XB>>
requires IsSame<typename RA::N, typename RB::N>

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

inlinestaticconstexpr

operator*() [20/20]

template<class XA , class XB , TensorTrain::IsTensorish RA = RemoveReference<XA>, TensorTrain::IsOperatorish RB = RemoveReference<XB>>
requires IsSame<typename RA::N, typename RB::M>

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

inlinestaticconstexpr

operator+() [1/16]

template<Size M, Size N>

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

inlinestaticconstexpr

operator+() [2/16]

template<class T , T A, T... Bs>
requires IsInvocable<Add, T, T>

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

inlinestaticconstexpr

operator+() [3/16]

template<class T , T... As, T B>
requires IsInvocable<Add, T, T>

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

inlinestaticconstexpr

operator+() [4/16]

template<class T , T... As, T... Bs>
requires IsInvocable<Add, T, T> && (sizeof...(As) == sizeof...(Bs))

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

inlinestaticconstexpr

operator+() [5/16]

template<Size M, Size N>

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

inlinestaticconstexpr

operator+() [6/16]

template<Size M, Size N>

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

inlinestaticconstexpr

operator+() [7/16]

template<Size... Ns>

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

inlinestaticconstexpr

operator+() [8/16]

template<IsComplex T>

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

inlinestaticconstexpr

operator+() [9/16]

template<IsFloat T>

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

inlinestaticconstexpr

operator+() [10/16]

template<IsComplex TA, IsComplex TB>

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

inlinestaticconstexpr

operator+() [11/16]

template<IsFloat TA, IsFloat TB>

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

inlinestaticconstexpr

operator+() [12/16]

template<class X >
requires IsTensorish<RemoveReference<X>> && IsInvocable<Loop<Plus>, X>

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

inlinestaticconstexpr

operator+() [13/16]

template<class X , class R = RemoveReference<X>>
requires (TensorTrain::IsTensorish<R> || TensorTrain::IsOperatorish<R>) && IsInvocable<Loop<Plus>, X>

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

inlinestaticconstexpr

operator+() [14/16]

template<class XA , class XB >
requires IsTensorish<RemoveReference<XA>> && IsTensorish<RemoveReference<XB>> && IsInvocable<Loop<Add>, XA, XB>

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

inlinestaticconstexpr

operator+() [15/16]

template<class XA , class XB , TensorTrain::IsOperatorish RA = RemoveReference<XA>, TensorTrain::IsOperatorish RB = RemoveReference<XB>>
requires IsSame<typename RA::Sizes, typename RB::Sizes>

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

inlinestaticconstexpr

operator+() [16/16]

template<class XA , class XB , TensorTrain::IsTensorish RA = RemoveReference<XA>, TensorTrain::IsTensorish RB = RemoveReference<XB>>
requires IsSame<typename RA::Sizes, typename RB::Sizes>

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/13]

template<class T , T A, T... Bs>
requires IsInvocable<Sub, T, T>

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

inlinestaticconstexpr

operator-() [2/13]

template<class T , T... As, T B>
requires IsInvocable<Sub, T, T>

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

inlinestaticconstexpr

operator-() [3/13]

template<class T , T... As, T... Bs>
requires IsInvocable<Sub, T, T> && (sizeof...(As) == sizeof...(Bs))

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

inlinestaticconstexpr

operator-() [4/13]

template<class T , T... Is>
requires IsInvocable<Minus, T>

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

inlinestaticconstexpr

operator-() [5/13]

template<Size... Ns>

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

inlinestaticconstexpr

operator-() [6/13]

template<IsComplex T>

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

inlinestaticconstexpr

operator-() [7/13]

template<IsFloat T>

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

inlinestaticconstexpr

operator-() [8/13]

template<IsComplex TA, IsComplex TB>

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

inlinestaticconstexpr

operator-() [9/13]

template<IsFloat TA, IsFloat TB>

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

inlinestaticconstexpr

operator-() [10/13]

template<class X >
requires IsTensorish<RemoveReference<X>> && IsInvocable<Loop<Minus>, X>

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

inlinestaticconstexpr

operator-() [11/13]

template<class X , class R = RemoveReference<X>>
requires (TensorTrain::IsTensorish<R> || TensorTrain::IsOperatorish<R>)

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

inlinestaticconstexpr

operator-() [12/13]

template<class XA , class XB >
requires IsTensorish<RemoveReference<XA>> && IsTensorish<RemoveReference<XB>> && IsInvocable<Loop<Sub>, XA, XB>

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

inlinestaticconstexpr

operator-() [13/13]

template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>>
requires ((TensorTrain::IsTensorish<RA> && TensorTrain::IsTensorish<RB>) || (TensorTrain::IsOperatorish<RA> && TensorTrain::IsOperatorish<RB>)) && IsInvocable<Minus, XB> && IsInvocable<Add, XA, ResultOf<Minus, XB>>

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

inlinestaticconstexpr

operator/() [1/13]

template<class T , T A, T... Bs>
requires IsInvocable<Div, T, T>

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

inlinestaticconstexpr

operator/() [2/13]

template<class T , T... As, T B>
requires IsInvocable<Div, T, T>

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

inlinestaticconstexpr

operator/() [3/13]

template<class T , T... As, T... Bs>
requires IsInvocable<Div, T, T> && (sizeof...(As) == sizeof...(Bs))

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

inlinestaticconstexpr

operator/() [4/13]

template<Size... Ns, Size... Ss>
requires (sizeof...(Ns) == sizeof...(Ss))

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

inlinestaticconstexpr

operator/() [5/13]

template<IsComplex TA, IsComplex TB>

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

inlinestaticconstexpr

operator/() [6/13]

template<IsFloat TA, IsFloat TB>

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

inlinestaticconstexpr

operator/() [7/13]

template<class XA , class XB >
requires IsTensorish<RemoveReference<XA>> && IsTensorish<RemoveReference<XB>> && IsInvocable<Loop<Div>, XA, XB>

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

inlinestaticconstexpr

operator/() [8/13]

template<class XA , class XB , IsTensorish RA = RemoveReference<XA>, IsTensorish RB = RemoveReference<XB>>
requires (RA::Dimension == 0 && RB::Dimension != 0) && IsInvocable<Div, typename RB::template ChangeType<typename RA::Type>, XB>

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

inlinestaticconstexpr

operator/() [9/13]

template<class XA , class XB , IsTensorish RA = RemoveReference<XA>, IsTensorish RB = RemoveReference<XB>>
requires (RA::Dimension != 0 && RB::Dimension == 0) && IsInvocable<Div, XA, typename RA::template ChangeType<typename RB::Type>>

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

inlinestaticconstexpr

operator/() [10/13]

template<class XA , class XB , IsTensorish RA = RemoveReference<XA>, class RB = RemoveReference<XB>>
requires IsDefined<Tensor<RB>> && IsInvocable<Div, XA, Tensor<RB>>

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

inlinestaticconstexpr

operator/() [11/13]

template<class XA , class XB , class RA = RemoveReference<XA>, IsTensorish RB = RemoveReference<XB>>
requires IsDefined<Tensor<RA>> && IsInvocable<Div, Tensor<RA>, XB>

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

inlinestaticconstexpr

operator/() [12/13]

template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>>
requires (TensorTrain::IsTensorish<RA> || TensorTrain::IsOperatorish<RA>) && (IsValue<RB> || IsComplex<RB>) && IsInvocable<Div, typename RA::Type, RB const &>

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

inlinestaticconstexpr

operator/() [13/13]

template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>>
requires (TensorTrain::IsTensorish<RA> || TensorTrain::IsOperatorish<RA>) && IsTensorish<RB> && IsInvocable<Div, XA, typename RB::Type>

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

inlinestaticconstexpr

operator<() [1/8]

template<class T , T A, T... Bs>
requires IsInvocable<Less, T, T>

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

inlinestaticconstexpr

operator<() [2/8]

template<class T , T... As, T B>
requires IsInvocable<Less, T, T>

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

inlinestaticconstexpr

operator<() [3/8]

template<class T , T... As, T... Bs>
requires IsInvocable<Less, T, T> && (sizeof...(As) == sizeof...(Bs))

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

inlinestaticconstexpr

operator<() [4/8]

template<class X , template< class > class T>
requires IsSame<T<Void>, Identity<>> || IsSame<T<Void>, Unit<>> || IsSame<T<Void>, Zero<>>

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

inlinestaticconstexpr

operator<() [5/8]

template<IsValue TA, IsValue TB>

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

inlinestaticconstexpr

operator<() [6/8]

template<template< class > class TA, template< class > class TB>
requires ((IsSame<TA<Void>, Identity<>> || IsSame<TA<Void>, Unit<>> || IsSame<TA<Void>, Zero<>>) && (IsSame<TB<Void>, Identity<>> || IsSame<TB<Void>, Unit<>> || IsSame<TB<Void>, Zero<>>))

static constexpr auto pRC::operator< ( TA< Void > const , TB< Void > const  )

inlinestaticconstexpr

operator<() [7/8]

template<class X , template< class > class T>
requires IsSame<T<Void>, Identity<>> || IsSame<T<Void>, Unit<>> || IsSame<T<Void>, Zero<>>

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

inlinestaticconstexpr

operator<() [8/8]

template<class XA , class XB >
requires IsTensorish<RemoveReference<XA>> && IsTensorish<RemoveReference<XB>> && IsInvocable<Loop<Less>, XA, XB>

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

inlinestaticconstexpr

operator<=() [1/8]

template<class T , T A, T... Bs>
requires IsInvocable<LessEqual, T, T>

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

inlinestaticconstexpr

operator<=() [2/8]

template<class T , T... As, T B>
requires IsInvocable<LessEqual, T, T>

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

inlinestaticconstexpr

operator<=() [3/8]

template<class T , T... As, T... Bs>
requires IsInvocable<LessEqual, T, T> && (sizeof...(As) == sizeof...(Bs))

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

inlinestaticconstexpr

operator<=() [4/8]

template<class X , template< class > class T>
requires IsSame<T<Void>, Identity<>> || IsSame<T<Void>, Unit<>> || IsSame<T<Void>, Zero<>>

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

inlinestaticconstexpr

operator<=() [5/8]

template<IsValue TA, IsValue TB>

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

inlinestaticconstexpr

operator<=() [6/8]

template<template< class > class TA, template< class > class TB>
requires ((IsSame<TA<Void>, Identity<>> || IsSame<TA<Void>, Unit<>> || IsSame<TA<Void>, Zero<>>) && (IsSame<TB<Void>, Identity<>> || IsSame<TB<Void>, Unit<>> || IsSame<TB<Void>, Zero<>>))

static constexpr auto pRC::operator<= ( TA< Void > const , TB< Void > const  )

inlinestaticconstexpr

operator<=() [7/8]

template<class X , template< class > class T>
requires IsSame<T<Void>, Identity<>> || IsSame<T<Void>, Unit<>> || IsSame<T<Void>, Zero<>>

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

inlinestaticconstexpr

operator<=() [8/8]

template<class XA , class XB >
requires IsTensorish<RemoveReference<XA>> && IsTensorish<RemoveReference<XB>> && IsInvocable<Loop<LessEqual>, XA, XB>

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

inlinestaticconstexpr

operator==() [1/15]

template<IsSequence A, IsSequence B>

static constexpr auto pRC::operator== ( A const , B const  )

inlinestaticconstexpr

operator==() [2/15]

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

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

inlinestaticconstexpr

operator==() [3/15]

template<class T , T A, T... Bs>
requires IsInvocable<Equal, T, T>

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

inlinestaticconstexpr

operator==() [4/15]

template<class T >

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

constexpr

operator==() [5/15]

template<class TA , class TB >

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

inlinestaticconstexpr

operator==() [6/15]

template<class T >

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

constexpr

operator==() [7/15]

template<class T , T... As, T B>
requires IsInvocable<Equal, T, T>

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

inlinestaticconstexpr

operator==() [8/15]

template<Size... Ns>

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

inlinestaticconstexpr

operator==() [9/15]

template<class X , template< class > class T>
requires IsSame<T<Void>, Identity<>> || IsSame<T<Void>, Unit<>> || IsSame<T<Void>, Zero<>>

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

inlinestaticconstexpr

operator==() [10/15]

template<IsComplex TA, IsComplex TB>

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

inlinestaticconstexpr

operator==() [11/15]

template<IsValue TA, IsValue TB>

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

inlinestaticconstexpr

operator==() [12/15]

template<template< class > class TA, template< class > class TB>
requires ((IsSame<TA<Void>, Identity<>> || IsSame<TA<Void>, Unit<>> || IsSame<TA<Void>, Zero<>>) && (IsSame<TB<Void>, Identity<>> || IsSame<TB<Void>, Unit<>> || IsSame<TB<Void>, Zero<>>))

static constexpr auto pRC::operator== ( TA< Void > const , TB< Void > const  )

inlinestaticconstexpr

operator==() [13/15]

template<class T >

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

constexpr

operator==() [14/15]

template<class X , template< class > class T>
requires IsSame<T<Void>, Identity<>> || IsSame<T<Void>, Unit<>> || IsSame<T<Void>, Zero<>>

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

inlinestaticconstexpr

operator==() [15/15]

template<class XA , class XB >
requires IsTensorish<RemoveReference<XA>> && IsTensorish<RemoveReference<XB>> && IsInvocable<Loop<Equal>, XA, XB>

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

inlinestaticconstexpr

operator>() [1/8]

template<class T , T A, T... Bs>
requires IsInvocable<Greater, T, T>

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

inlinestaticconstexpr

operator>() [2/8]

template<class T , T... As, T B>
requires IsInvocable<Greater, T, T>

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

inlinestaticconstexpr

operator>() [3/8]

template<class T , T... As, T... Bs>
requires IsInvocable<Greater, T, T> && (sizeof...(As) == sizeof...(Bs))

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

inlinestaticconstexpr

operator>() [4/8]

template<class X , template< class > class T>
requires IsSame<T<Void>, Identity<>> || IsSame<T<Void>, Unit<>> || IsSame<T<Void>, Zero<>>

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

inlinestaticconstexpr

operator>() [5/8]

template<IsValue TA, IsValue TB>

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

inlinestaticconstexpr

operator>() [6/8]

template<template< class > class TA, template< class > class TB>
requires ((IsSame<TA<Void>, Identity<>> || IsSame<TA<Void>, Unit<>> || IsSame<TA<Void>, Zero<>>) && (IsSame<TB<Void>, Identity<>> || IsSame<TB<Void>, Unit<>> || IsSame<TB<Void>, Zero<>>))

static constexpr auto pRC::operator> ( TA< Void > const , TB< Void > const  )

inlinestaticconstexpr

operator>() [7/8]

template<class X , template< class > class T>
requires IsSame<T<Void>, Identity<>> || IsSame<T<Void>, Unit<>> || IsSame<T<Void>, Zero<>>

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

inlinestaticconstexpr

operator>() [8/8]

template<class XA , class XB >
requires IsTensorish<RemoveReference<XA>> && IsTensorish<RemoveReference<XB>> && IsInvocable<Loop<Greater>, XA, XB>

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

inlinestaticconstexpr

operator>=() [1/8]

template<class T , T A, T... Bs>
requires IsInvocable<GreaterEqual, T, T>

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

inlinestaticconstexpr

operator>=() [2/8]

template<class T , T... As, T B>
requires IsInvocable<GreaterEqual, T, T>

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

inlinestaticconstexpr

operator>=() [3/8]

template<class T , T... As, T... Bs>
requires IsInvocable<GreaterEqual, T, T> && (sizeof...(As) == sizeof...(Bs))

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

inlinestaticconstexpr

operator>=() [4/8]

template<class X , template< class > class T>
requires IsSame<T<Void>, Identity<>> || IsSame<T<Void>, Unit<>> || IsSame<T<Void>, Zero<>>

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

inlinestaticconstexpr

operator>=() [5/8]

template<IsValue TA, IsValue TB>

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

inlinestaticconstexpr

operator>=() [6/8]

template<template< class > class TA, template< class > class TB>
requires ((IsSame<TA<Void>, Identity<>> || IsSame<TA<Void>, Unit<>> || IsSame<TA<Void>, Zero<>>) && (IsSame<TB<Void>, Identity<>> || IsSame<TB<Void>, Unit<>> || IsSame<TB<Void>, Zero<>>))

static constexpr auto pRC::operator>= ( TA< Void > const , TB< Void > const  )

inlinestaticconstexpr

operator>=() [7/8]

template<class X , template< class > class T>
requires IsSame<T<Void>, Identity<>> || IsSame<T<Void>, Unit<>> || IsSame<T<Void>, Zero<>>

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

inlinestaticconstexpr

operator>=() [8/8]

template<class XA , class XB >
requires IsTensorish<RemoveReference<XA>> && IsTensorish<RemoveReference<XB>> && IsInvocable<Loop<GreaterEqual>, XA, XB>

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

inlinestaticconstexpr

operator||()

template<class XA , class XB >
requires IsTensorish<RemoveReference<XA>> && IsTensorish<RemoveReference<XB>> && IsInvocable<Loop<LogicalOr>, XA, XB>

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 FF , class FC , class VT >
requires IsInvocable<Optimizer, XX, FF, FC, VT>

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

inlinestaticconstexpr

optimize() [2/4]

template<class Optimizer , class XX , class FF , class VT >
requires IsInvocable<Optimizer, XX, FF, void(RemoveConstReference<ResultOf<Eval, XX>> const), VT>

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

inlinestaticconstexpr

optimize() [3/4]

template<class Optimizer , class XX , class FF , class FC , class VT >
requires IsInvocable<Optimizer, XX, FF, FC, VT>

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

inlinestaticconstexpr

optimize() [4/4]

template<class Optimizer , class XX , class FF , class VT >
requires IsInvocable<Optimizer, XX, FF, void(RemoveConstReference<ResultOf<Eval, XX>> const), VT>

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

inlinestaticconstexpr

orthogonalize() [1/2]

template<Position P, class X , IsTensorish R = RemoveReference<X>>
requires (P == Position::Left)

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

inlinestaticconstexpr

orthogonalize() [2/2]

template<Position P, class X , IsTensorish R = RemoveReference<X>>
requires (P == Position::Right)

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

inlinestaticconstexpr

outerProduct()

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

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

inlinestaticconstexpr

parameter() [1/4]

template<Context C, class T , class A , class N , class D >
requires (C == Context::CompileTime || C == Context::RunTime) && requires { String(declval<A>()); String(declval<N>()); String(declval<D>()); }

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 >
requires (C == Context::CompileTime || C == Context::RunTime) && requires { String(declval<A>()); String(declval<N>()); String(declval<D>()); }

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 >
requires (C == Context::RunTime) && requires { String(declval<A>()); String(declval<N>()); String(declval<D>()); }

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

inlinestaticconstexpr

parameter() [4/4]

template<Context C, class T , class A , class N , class D >
requires (C == Context::RunTime) && requires { String(declval<A>()); String(declval<N>()); String(declval<D>()); }

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

inlinestaticconstexpr

parse()

template<class N , class D , class... Ps>
requires requires { Logging::log(declval<N>()); Logging::log(declval<D>()); }

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

inlinestaticconstexpr

permute() [1/3]

template<Index... Ps, class T , T... Is>
requires ((sizeof...(Is) == sizeof...(Ps))) && (((Ps < sizeof...(Is)) && ...))

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

inlinestaticconstexpr

permute() [2/3]

template<Index... Ps, Size... Ns>
requires requires { permute<Ps...>(makeSeriesFor<Index, Ns...>()); }

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

inlinestaticconstexpr

permute() [3/3]

template<Index... Ps, class X , IsTensorish R = RemoveReference<X>>
requires requires { permute<Ps...>(typename R::Sizes()); }

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

inlinestaticconstexpr

pi() [1/2]

template<IsFloat T>

static constexpr T pRC::pi ( )

inlinestaticconstexpr

pi() [2/2]

static constexpr auto pRC::pi ( )

inlinestaticconstexpr

pick()

template<class F , class T , T... As, T... Bs, class... Seqs>
requires IsInvocable<F, T, T> && (sizeof...(As) == sizeof...(Bs)) && ((sizeof...(As) == Seqs::Dimension) && ...)

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

inlinestaticconstexpr

polar()

template<IsValue TA, IsValue TB>

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

inlinestaticconstexpr

pow() [1/3]

template<IsFloat B, IsFloat N>

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

inlinestaticconstexpr

pow() [2/3]

template<IsComplex X, IsComplex Y>

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

inlinestaticconstexpr

pow() [3/3]

template<class XA , class XB >
requires IsTensorish<RemoveReference<XA>> && IsTensorish<RemoveReference<XB>> && IsInvocable<Loop<Pow>, XA, XB>

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 ( Bool const value, std::FILE * stream )

inlinestatic

print() [3/18]

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

inlinestatic

print() [4/18]

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

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

inlinestatic

print() [5/18]

template<class T , T V, class S >

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

inlinestatic

print() [6/18]

template<class S >

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

inlinestatic

print() [7/18]

template<class S >

static auto pRC::print ( Direction const direction, 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]

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

inlinestatic

print() [11/18]

template<Size N>

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

inlinestatic

print() [12/18]

template<Size... Ns, class S >

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

inlinestatic

print() [13/18]

template<IsComplex T, class S >

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

inlinestatic

print() [14/18]

template<IsFloat T>

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

inlinestatic

print() [15/18]

template<IsIntegral T>

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

inlinestatic

print() [16/18]

template<class X , class S , IsTensorish R = RemoveReference<X>>
requires (R::Dimension == 0)

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

inlinestatic

print() [17/18]

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

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

inlinestatic

print() [18/18]

template<class X , class S , class R = RemoveReference<X>>
requires TensorTrain::IsTensorish<R> || TensorTrain::IsOperatorish<R>

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

inlinestatic

qr()

template<Size B = 32, class X , IsTensorish R = RemoveReference<X>>
requires IsFloat<Value<R>> && (R::Dimension == 2)

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

inlinestaticconstexpr

random()

template<class T , IsRandomEngine URNG, IsRandomDistribution D>
requires IsDefined<Random<T, URNG, D>> && IsConstructible<Random<T, URNG, D>, URNG &, D &>

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

inlinestaticconstexpr

range() [1/9]

template<Context C, Size I, Size L, Direction D = Direction::Forwards, Size S = 1, class F , class... Xs>
requires (D == Direction::Forwards || D == Direction::Backwards) && (C == Context::CompileTime)

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

inlinestaticconstexpr

range() [2/9]

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

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

inlinestaticconstexpr

range() [3/9]

template<Context C, Size I, Size L, Direction D = Direction::Forwards, Size S = 1, class F , class... Xs>
requires (D == Direction::Backwards) && (C == Context::RunTime)

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

inlinestaticconstexpr

range() [4/9]

template<Size I, Size L, Direction D = Direction::Forwards, Size S = 1, class F , class... Xs>
requires (D == Direction::Forwards || D == Direction::Backwards)

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

inlinestaticconstexpr

range() [5/9]

template<Size L, Direction D = Direction::Forwards, Size S = 1, class F , class... Xs>
requires (D == Direction::Forwards || D == Direction::Backwards)

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

inlinestaticconstexpr

range() [6/9]

template<Context C, IsSizes I, IsSizes L, Direction O = Direction::LeftToRight, IsSequence D = decltype(makeConstantSequence<Direction, L::Dimension, Direction::Forwards>()), IsSizes S = decltype(makeConstantSequence<Size, L::Dimension, 1>()), class F , class... Xs>
requires IsSame<Direction, typename D::Type> && (L::Dimension == I::Dimension) && (L::Dimension == D::Dimension) && (L::Dimension == S::Dimension) && (O == Direction::LeftToRight || O == Direction::RightToLeft)

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

inlinestaticconstexpr

range() [7/9]

template<IsSizes I, IsSizes L, Direction O = Direction::LeftToRight, IsSequence D = decltype(makeConstantSequence<Direction, L::Dimension, Direction::Forwards>()), IsSizes S = decltype(makeConstantSequence<Size, L::Dimension, 1>()), class F , class... Xs>
requires IsSame<Direction, typename D::Type> && (L::Dimension == I::Dimension) && (L::Dimension == D::Dimension) && (L::Dimension == S::Dimension) && (O == Direction::LeftToRight || O == Direction::RightToLeft)

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

inlinestaticconstexpr

range() [8/9]

template<Context C, IsSizes L, Direction O = Direction::LeftToRight, IsSequence D = decltype(makeConstantSequence<Direction, L::Dimension, Direction::Forwards>()), IsSizes S = decltype(makeConstantSequence<Size, L::Dimension, 1>()), class F , class... Xs>
requires IsSame<Direction, typename D::Type> && (L::Dimension == D::Dimension) && (L::Dimension == S::Dimension) && (O == Direction::LeftToRight || O == Direction::RightToLeft)

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

inlinestaticconstexpr

range() [9/9]

template<IsSizes L, Direction O = Direction::LeftToRight, IsSequence D = decltype(makeConstantSequence<Direction, L::Dimension, Direction::Forwards>()), IsSizes S = decltype(makeConstantSequence<Size, L::Dimension, 1>()), class F , class... Xs>
requires IsSame<Direction, typename D::Type> && (L::Dimension == D::Dimension) && (L::Dimension == S::Dimension) && (O == Direction::LeftToRight || O == Direction::RightToLeft)

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

inlinestaticconstexpr

rcp() [1/3]

template<IsValue T>

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

inlinestaticconstexpr

rcp() [2/3]

template<IsComplex T>

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

inlinestaticconstexpr

rcp() [3/3]

template<class X >
requires IsTensorish<RemoveReference<X>> && IsInvocable<Loop<Rcp>, X>

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

inlinestaticconstexpr

real() [1/3]

template<class X >
requires IsComplex<RemoveReference<X>>

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

inlinestaticconstexpr

real() [2/3]

template<class X >
requires IsTensorish<RemoveReference<X>> && IsInvocable<Loop<Real>, X>

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

inlinestaticconstexpr

real() [3/3]

template<class X >
requires IsValue<RemoveReference<X>>

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

inlinestaticconstexpr

RecursiveLambda()

template<class X >

pRC::RecursiveLambda

(

X &&

)

-> RecursiveLambda< RemoveReference< X > >

reduce() [1/5]

template<class F , class T >

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

inlinestaticconstexpr

reduce() [2/5]

template<class F , class T , T I>

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

inlinestaticconstexpr

reduce() [3/5]

template<class F , class T , T I1, T I2, T... Is>
requires IsInvocable<F, T, T>

static constexpr auto pRC::reduce ( Sequence< T, I1, I2, Is... > const )

inlinestaticconstexpr

reduce() [4/5]

template<class F , Index... Is, class X , IsTensorish R = RemoveReference<X>, class E = ResultOf<X, typename R::Subscripts>>
requires (sizeof...(Is) <= R::Dimension && max(Is...) < R::Dimension) && IsInvocable<F, E, E> && IsInvocable<F, decltype(F::template Identity<typename R::Type>()), E> && requires { chip<Is...>(typename R::Sizes()); }

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

inlinestaticconstexpr

reduce() [5/5]

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

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

inlinestaticconstexpr

relativeError()

template<class XE , class XA >
requires IsInvocable<AbsoluteError, XE, XA> && IsInvocable<Norm<>, XE>

static constexpr auto pRC::relativeError ( XE && expected, XA && approx )

inlinestaticconstexpr

report()

template<class... Ps>

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

inlinestaticconstexpr

reshape()

template<Size... Ns, class X , IsTensorish R = RemoveReference<X>>
requires (Sizes<Ns...>::size() == R::size())

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

inlinestaticconstexpr

restrict() [1/8]

template<Operator::Restrict OR = Operator::Restrict::None, class X >
requires IsTensorish<RemoveReference<X>> && (OR == Operator::Restrict::Diagonal)

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

inlinestaticconstexpr

restrict() [2/8]

template<Operator::Restrict OR = Operator::Restrict::None, class X >
requires IsTensorish<RemoveReference<X>> && (OR == Operator::Restrict::LowerTriangular)

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

inlinestaticconstexpr

restrict() [3/8]

template<Operator::Restrict OR = Operator::Restrict::None, class X >
requires IsTensorish<RemoveReference<X>> && (OR == Operator::Restrict::StrictlyLowerTriangular)

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

inlinestaticconstexpr

restrict() [4/8]

template<Operator::Restrict OR = Operator::Restrict::None, class X >
requires IsTensorish<RemoveReference<X>> && (OR == Operator::Restrict::UpperTriangular)

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

inlinestaticconstexpr

restrict() [5/8]

template<Operator::Restrict OR = Operator::Restrict::None, class X >
requires IsTensorish<RemoveReference<X>> && (OR == Operator::Restrict::StrictlyUpperTriangular)

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

inlinestaticconstexpr

restrict() [6/8]

template<Operator::Restrict OR = Operator::Restrict::None, class X >
requires IsTensorish<RemoveReference<X>> && (OR == Operator::Restrict::OffDiagonal)

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

inlinestaticconstexpr

restrict() [7/8]

template<Operator::Restrict OR = Operator::Restrict::None, class X >
requires IsTensorish<RemoveReference<X>> && (OR == Operator::Restrict::None)

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

inlinestaticconstexpr

restrict() [8/8]

template<Operator::Restrict OR = Operator::Restrict::None, class X >
requires TensorTrain::IsOperatorish<RemoveReference<X>> && (OR == Operator::Restrict::None)

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 , IsTensorish R = RemoveReference<X>>
requires (sizeof...(Rs) == R::Dimension)

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

inlinestaticconstexpr

rotate() [1/3]

template<Direction D, Size Step, class T , T... Is>
requires (D == Direction::Leftwards || D == Direction::Rightwards)

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

inlinestaticconstexpr

rotate() [2/3]

template<Direction D, Size Step, Size... Ns>
requires requires { rotate<D, Step>(makeSeriesFor<Index, Ns...>()); }

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

inlinestaticconstexpr

rotate() [3/3]

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

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

inlinestaticconstexpr

round() [1/7]

template<Size D = 0, IsComplex T>

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

inlinestaticconstexpr

round() [2/7]

template<Size D = 0, Position P = Position::Right, IsFloat T>
requires (P == Position::Right) || (P == Position::Left)

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

inlinestaticconstexpr

round() [3/7]

template<Size D = 0, class X >
requires IsTensorish<RemoveReference<X>> && IsInvocable<Loop<Round<D>>, X>

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

inlinestaticconstexpr

round() [4/7]

template<IsSizes Ranks, class X , class R = RemoveReference<X>, IsFloat VT = Value<R>>
requires (TensorTrain::IsTensorish<R> || TensorTrain::IsOperatorish<R>) && IsFloat<Value<R>> && (Ranks::Dimension == R::Dimension - 1)

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

inlinestaticconstexpr

round() [5/7]

template<class X , class R = RemoveReference<X>, IsFloat VT = Value<R>>
requires (TensorTrain::IsTensorish<R> || TensorTrain::IsOperatorish<R>) && IsFloat<Value<R>>

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

inlinestaticconstexpr

round() [6/7]

template<Size C, class X , class R = RemoveReference<X>, IsFloat VT = Value<R>>
requires (TensorTrain::IsTensorish<R> || TensorTrain::IsOperatorish<R>) && IsFloat<Value<R>>

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

inlinestaticconstexpr

round() [7/7]

template<Size... Cs, class X , class R = RemoveReference<X>, IsFloat VT = Value<R>>
requires (TensorTrain::IsTensorish<R> || TensorTrain::IsOperatorish<R>) && IsFloat<Value<R>> && (sizeof...(Cs) > 1) && (sizeof...(Cs) == R::Dimension - 1)

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

inlinestaticconstexpr

scalar()

template<class X , IsTensorish R = RemoveReference<X>>
requires IsInvocable<Reshape<>, X>

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

inlinestaticconstexpr

scalarProduct() [1/5]

template<IsComplex TA, IsComplex TB>

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

inlinestaticconstexpr

scalarProduct() [2/5]

template<IsValue TA, IsValue TB>

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

inlinestaticconstexpr

scalarProduct() [3/5]

template<class XA , class XB , IsTensorish RA = RemoveReference<XA>, IsTensorish RB = RemoveReference<XB>>
requires IsInvocable<HadamardProduct, XA, XB>

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

inlinestaticconstexpr

scalarProduct() [4/5]

template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>>
requires TensorTrain::IsOperatorish<RA> && TensorTrain::IsOperatorish<RB> && IsInvocable<HadamardProduct, XA, XB>

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

inlinestaticconstexpr

scalarProduct() [5/5]

template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>>
requires TensorTrain::IsTensorish<RA> && TensorTrain::IsTensorish<RB> && IsInvocable<HadamardProduct, XA, XB>

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>
requires (sizeof...(Ss) < sizeof...(Is) && max(S, Ss...) < sizeof...(Is))

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

sign() [1/4]

template<IsComplex T>

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

inlinestaticconstexpr

sign() [2/4]

template<IsValue T>

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

inlinestaticconstexpr

sign() [3/4]

template<IsValue T>
requires IsUnsignedInteger<T>

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

inlinestaticconstexpr

sign() [4/4]

template<class X >
requires IsTensorish<RemoveReference<X>> && IsInvocable<Loop<Sign>, X>

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

inlinestaticconstexpr

sin() [1/3]

template<IsComplex T>

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

inlinestaticconstexpr

sin() [2/3]

template<IsFloat T>

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

inlinestaticconstexpr

sin() [3/3]

template<class X >
requires IsTensorish<RemoveReference<X>> && IsInvocable<Loop<Sin>, X>

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

inlinestaticconstexpr

sinh() [1/3]

template<IsComplex T>

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

inlinestaticconstexpr

sinh() [2/3]

template<IsFloat T>

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

inlinestaticconstexpr

sinh() [3/3]

template<class X >
requires IsTensorish<RemoveReference<X>> && IsInvocable<Loop<Sinh>, X>

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

inlinestaticconstexpr

slice()

template<Size... Es, class X , IsConvertible< Index >... Os, IsTensorish R = RemoveReference<X>>
requires (sizeof...(Es) == R::Dimension && sizeof...(Os) == R::Dimension && Sizes<Es...>() <= typename R::Sizes())

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 >
requires IsInvocable<Solver, XA, XB>

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 >
requires IsInvocable<Solver, XA, XB, VT>

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 >
requires IsInvocable<Solver, XA, XB, XX>

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 >
requires IsInvocable<Solver, XA, XB, XX, VT>

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 >
requires IsInvocable<Solver, XA, XB>

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 >
requires IsInvocable<Solver, XA, XB, VT>

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 >
requires IsInvocable<Solver, XA, XB, XX>

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 >
requires IsInvocable<Solver, XA, XB, XX, VT>

static constexpr decltype(auto) pRC::solve ( XA && A, XB && b, XX && x0, VT const & tolerance )

inlinestaticconstexpr

sort() [1/3]

template<class C , IsSubscriptable T, class S = ResultOf<Subscript, T &, Index>>
requires IsInvocable<C, S, S> && IsAssignable<S>

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>
requires IsPredicate<F, T, T>

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

inlinestaticconstexpr

sort() [3/3]

template<class C = Less, IsSubscriptable T, class S = ResultOf<Subscript, T &, Index>>
requires IsInvocable<C, S, S> && IsAssignable<S>

static constexpr void pRC::sort ( T & a, Size const k = T::size(), Size const d = 0 )

inlinestaticconstexpr

sqrt() [1/3]

template<IsComplex T>

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

inlinestaticconstexpr

sqrt() [2/3]

template<IsFloat T>

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

inlinestaticconstexpr

sqrt() [3/3]

template<class X >
requires IsTensorish<RemoveReference<X>> && IsInvocable<Loop<Sqrt>, X>

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

inlinestaticconstexpr

square() [1/3]

template<IsComplex T>

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

inlinestaticconstexpr

square() [2/3]

template<IsValue T>

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

inlinestaticconstexpr

square() [3/3]

template<class X >
requires IsTensorish<RemoveReference<X>> && IsInvocable<Loop<Square>, X>

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

inlinestaticconstexpr

squeeze()

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

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

inlinestaticconstexpr

strictlyLowerTriangular()

template<class X , IsTensorish R = RemoveReference<X>>
requires (R::Dimension == 2)

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

inlinestaticconstexpr

strictlyUpperTriangular()

template<class X , IsTensorish R = RemoveReference<X>>
requires (R::Dimension == 2)

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

inlinestaticconstexpr

stride()

template<Size... Ss, class X , IsConvertible< Index >... Os, IsTensorish R = RemoveReference<X>>
requires (sizeof...(Ss) == R::Dimension && sizeof...(Os) == R::Dimension && typename R::Sizes() % Sizes<Ss...>() == Constant<Size, 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/3]

template<class X , IsTensorish R = RemoveReference<X>>
requires IsFloat<Value<R>> && (R::Dimension == 2)

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

inlinestaticconstexpr

svd() [2/3]

template<Size C, class X , IsTensorish R = RemoveReference<X>, IsFloat V = Value<R>, IsFloat VT = V>
requires (R::Dimension == 2) && (C < reduce<Min>(typename R::Sizes()))

static constexpr auto pRC::svd ( X && input, VT const & tolerance = NumericLimits<VT>::tolerance() )

inlinestaticconstexpr

svd() [3/3]

template<Size C, class X , IsTensorish R = RemoveReference<X>, IsFloat V = Value<R>, IsFloat VT = V>
requires (R::Dimension == 2) && (C == reduce<Min>(typename R::Sizes()))

static constexpr auto pRC::svd ( X && input, VT const & tolerance = NumericLimits<VT>::tolerance() )

inlinestaticconstexpr

swap()

template<class XA , class XB , IsTensorish RA = RemoveReference<XA>, IsTensorish RB = RemoveReference<XB>, class EA = ResultOf<XA, typename RA::Subscripts>, class EB = ResultOf<XB, typename RB::Subscripts>>
requires IsSame<typename RA::Sizes, typename RB::Sizes> && IsInvocable<Swap, EA, EB> && IsInvocable<View, XA> && IsInvocable<View, XB>

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

inlinestaticconstexpr

tan() [1/3]

template<IsComplex T>

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

inlinestaticconstexpr

tan() [2/3]

template<IsFloat T>

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

inlinestaticconstexpr

tan() [3/3]

template<class X >
requires IsTensorish<RemoveReference<X>> && IsInvocable<Loop<Tan>, X>

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

inlinestaticconstexpr

tanh() [1/3]

template<IsComplex T>

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

inlinestaticconstexpr

tanh() [2/3]

template<IsFloat T>

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

inlinestaticconstexpr

tanh() [3/3]

template<class X >
requires IsTensorish<RemoveReference<X>> && IsInvocable<Loop<Tanh>, X>

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

template<class XA , class XB , IsTensorish RA = RemoveReference<XA>, IsTensorish RB = RemoveReference<XB>, class EA = ResultOf<XA, typename RA::Subscripts>, class EB = ResultOf<XB, typename RB::Subscripts>>
requires IsInvocable<Mul, EA, EB>

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

inlinestaticconstexpr

trace()

template<class X , IsTensorish R = RemoveReference<X>>
requires IsInvocable<ExtractDiagonal, X>

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

inlinestaticconstexpr

transform() [1/6]

template<Operator::Transform OT = Operator::Transform::None, class X >
requires IsTensorish<RemoveReference<X>> && (OT == Operator::Transform::Transpose)

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

inlinestaticconstexpr

transform() [2/6]

template<Operator::Transform OT = Operator::Transform::None, class X >
requires IsTensorish<RemoveReference<X>> && (OT == Operator::Transform::Adjoint)

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

inlinestaticconstexpr

transform() [3/6]

template<Operator::Transform OT = Operator::Transform::None, class X >
requires IsTensorish<RemoveReference<X>> && (OT == Operator::Transform::None)

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

inlinestaticconstexpr

transform() [4/6]

template<Operator::Transform OT = Operator::Transform::None, class X >
requires TensorTrain::IsOperatorish<RemoveReference<X>> && (OT == Operator::Transform::Transpose)

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

inlinestaticconstexpr

transform() [5/6]

template<Operator::Transform OT = Operator::Transform::None, class X >
requires TensorTrain::IsOperatorish<RemoveReference<X>> && (OT == Operator::Transform::Adjoint)

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

inlinestaticconstexpr

transform() [6/6]

template<Operator::Transform OT = Operator::Transform::None, class X >
requires TensorTrain::IsOperatorish<RemoveReference<X>> && (OT == Operator::Transform::None)

static constexpr 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 , IsTensorish R = RemoveReference<X>>
requires (isEven(R::Dimension))

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

inlinestaticconstexpr

transpose() [3/3]

template<class X >
requires TensorTrain::IsOperatorish<RemoveReference<X>> && IsInvocable<Loop<Permute<0, 2, 1, 3>>, X>

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

inlinestaticconstexpr

trim()

template<Index I, Index L, class T , T... Is>
requires (L <= sizeof...(Is) && I < L)

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

inlinestaticconstexpr

trunc() [1/3]

template<IsComplex T>

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

inlinestaticconstexpr

trunc() [2/3]

template<IsFloat T>

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

inlinestaticconstexpr

trunc() [3/3]

template<class X >
requires IsTensorish<RemoveReference<X>> && IsInvocable<Loop<Trunc>, X>

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

inlinestaticconstexpr

truncate() [1/3]

template<Size C, Position P, class X , IsTensorish R = RemoveReference<X>, IsFloat VT = Value<R>>
requires (C < reduce<Min>(RemoveReference<decltype(folding<!P>( declval<X>()))>::Sizes())) && (P == Position::Right)

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

inlinestaticconstexpr

truncate() [2/3]

template<Size C, Position P, class X , IsTensorish R = RemoveReference<X>, IsFloat VT = Value<R>>
requires (C < reduce<Min>(RemoveReference<decltype(folding<!P>( declval<X>()))>::Sizes())) && (P == Position::Left)

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

inlinestaticconstexpr

truncate() [3/3]

template<Size C, Position P, class X , IsTensorish R = RemoveReference<X>, IsFloat VT = Value<R>>

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

inlinestaticconstexpr

unfolding()

template<Index K, class X , IsTensorish R = RemoveReference<X>>
requires (K + 1 < R::Dimension)

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

inlinestaticconstexpr

unit() [1/3]

template<class T >
requires IsDefined<Unit<T>> && IsConstructible<Unit<T>> && IsInvocable<Unit<T>>

static constexpr auto pRC::unit ( )

inlinestaticconstexpr

unit() [2/3]

static constexpr auto pRC::unit ( )

inlinestaticconstexpr

unit() [3/3]

template<class T , class X >
requires IsDefined<Unit<T>> && IsConstructible<Unit<T>> && IsInvocable<Unit<T>, X>

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

inlinestaticconstexpr

unitLowerTriangular()

template<class X , IsTensorish R = RemoveReference<X>>
requires (R::Dimension == 2)

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

inlinestaticconstexpr

unitUpperTriangular()

template<class X , IsTensorish R = RemoveReference<X>>
requires (R::Dimension == 2)

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

inlinestaticconstexpr

upperTriangular()

template<class X , IsTensorish R = RemoveReference<X>>
requires (R::Dimension == 2)

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 >
requires IsTensorView<RemoveReference<X>>

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

inlinestaticconstexpr

view() [11/12]

template<class X >
requires TensorTrain::IsOperatorView<RemoveReference<X>>

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

inlinestaticconstexpr

view() [12/12]

template<class X >
requires TensorTrain::IsTensorView<RemoveReference<X>>

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

inlinestaticconstexpr

where() [1/2]

template<IsBool TE, class XA , class XB >

static constexpr decltype(auto) pRC::where ( TE const e, XA && a, XB && b )

inlinestaticconstexpr

where() [2/2]

template<class XE , class XA , class XB >
requires IsTensorish<RemoveReference<XE>> && IsTensorish<RemoveReference<XA>> && IsTensorish<RemoveReference<XB>> && IsInvocable<Loop<Where>, XE, XA, XB>

static constexpr auto pRC::where ( XE && e, XA && a, XB && b )

inlinestaticconstexpr

zero() [1/2]

template<class T >
requires IsDefined<Zero<T>> && IsConstructible<Zero<T>>

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>
requires ((Sequence<T, Is...>::size() == Seqs::size()) && ...)

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

inlinestaticconstexpr

Variable Documentation

cCacheLineSizeByte

Size pRC::cCacheLineSizeByte = 64

constexpr

cDebugLevel

auto pRC::cDebugLevel = DebugLevel::Low

constexpr

cHugepageSizeByte

Size pRC::cHugepageSizeByte = 2 * 1024 * 1024

constexpr

cLogLevel

auto pRC::cLogLevel = LogLevel::Info

constexpr

cMaxDefaultAlignment

Size pRC::cMaxDefaultAlignment = alignof(std::max_align_t)

constexpr

cPageSizeByte

Size pRC::cPageSizeByte = 4 * 1024

constexpr

cSimdSizeByte

Size pRC::cSimdSizeByte

constexpr

Initial value:

=
 
 
 
 
 
        16