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
	Custom Type representing a half-precision floating point number. More...
struct	Block
struct	Broadcast
struct	Cast
struct	Ceil
struct	Chip
class	CommonArray
class	CommonArray< A, T >
class	CommonArray< A, T, N, Ns... >
class	CommonArray< Allocation::Heap, T, N >
class	CommonArray< Allocation::Stack, T, N >
struct	CommonType
struct	CommonType< Complex< T >, Complex< U >, If< HasCommon< T, U > > >
struct	CommonType< Complex< T >, U, If< All< IsValue< U >, HasCommon< T, U > > > >
struct	CommonType< T, Complex< U >, If< All< IsValue< T >, HasCommon< T, U > > > >
struct	CommonType< TA, TB, If< All< IsFloat< TA >, IsFloat< TB > > > >
struct	CommonType< TA, TB, If< All< IsFloat< TA >, IsInteger< TB > > > >
struct	CommonType< TA, TB, If< All< IsInteger< TA >, IsFloat< TB > > > >
struct	CommonType< TA, TB, If< All< IsSignedInteger< TA >, IsSignedInteger< TB > > > >
struct	CommonType< TA, TB, If< All< IsSignedInteger< TA >, IsUnsignedInteger< TB > > > >
struct	CommonType< TA, TB, If< All< IsUnsignedInteger< TA >, IsSignedInteger< TB > > > >
struct	CommonType< TA, TB, If< All< IsUnsignedInteger< TA >, IsUnsignedInteger< TB > > > >
struct	CommonType< TA, VB, If< All< IsTensor< TA >, IsTensorView< VB >, HasCommon< TA, ResultOf< Eval, VB > > > > >
struct	CommonType< Tensor< TA, Ns... >, Tensor< TB, Ns... >, If< HasCommon< TA, TB > > >
struct	CommonType< VA, TB, If< All< IsTensorView< VA >, IsTensor< TB >, HasCommon< ResultOf< Eval, VA >, TB > > > >
struct	CommonType< VA, VB, If< All< IsTensorView< VA >, IsTensorView< VB >, HasCommon< ResultOf< Eval, VA >, ResultOf< Eval, VB > > > > >
struct	CommonTypes
struct	CommonTypes< T >
struct	CommonTypes< TA, TB >
class	Complex
struct	Complexify
struct	Conj
struct	Contract
struct	Cos
struct	Cosh
class	CRTP
struct	Delta
class	Deque
struct	DetectCommonType
struct	Detector
struct	Detector< Void< Op< Args... > >, Op, Args... >
struct	Diagonal
struct	DirectSum
struct	Div
struct	Enumerate
struct	Equal
struct	Eval
struct	Exclude
struct	Exp
struct	ExtractDiagonal
struct	False
struct	Flatten
class	Float
	Top-level class storing a floating point number. More...
struct	Floor
struct	FMod
struct	Fold
struct	Folding
struct	FromDiagonal
class	GaussianDistribution
class	GaussianDistribution< T, If< IsFloat< T > > >
struct	Greater
struct	GreaterEqual
struct	HadamardProduct
struct	Identity
struct	Identity< Float< 16 > >
	Class replresenting an identity (1) of pRC::Float<16> class. More...
struct	Identity< T, If< IsBool< T > > >
struct	Identity< T, If< IsComplex< T > > >
struct	Identity< T, If< IsIntegral< T > > >
struct	Identity< T, If< IsTensor< T > > >
	Class representing an identity of a Tensor class. More...
struct	Identity< T, If< IsTensorView< T > > >
	Class representing an identity of a Tensor class corresponding to a TensorView. More...
struct	Identity< T, If< IsValue< T > > >
	Class representing an identity (1) of a pRC value class. More...
struct	Identity< T, If< TensorTrain::IsOperator< T > > >
struct	Identity< T, If< TensorTrain::IsOperatorView< T > > >
struct	Identity< Void<> >
struct	Imag
class	Indices
struct	Inflate
struct	InnerProduct
class	Integer
	Top-level class storing a floating point number. More...
struct	IsApprox
struct	IsArray
struct	IsArray< CommonArray< A, T, Ns... > >
struct	IsArray< T const >
struct	IsComplex
struct	IsComplex< Complex< T > >
struct	IsComplex< T const >
struct	IsDeque
struct	IsDeque< Deque< T, N > >
struct	IsDeque< T const >
struct	IsDiagonal
struct	IsDistribution
struct	IsDistribution< GaussianDistribution< T, V > >
struct	IsDistribution< LaplaceDistribution< T > >
struct	IsDistribution< T const >
struct	IsDistribution< UniformDistribution< T, V > >
struct	IsFloat
struct	IsFloat< Float< W > >
struct	IsFloat< T const >
struct	IsIdentity
struct	IsIndices
struct	IsIndices< Indices< N > >
struct	IsIndices< T const >
struct	IsLowerTriangular
struct	IsNaN
struct	IsOffDiagonal
struct	IsRandomEngine
struct	IsRandomEngine< T const >
struct	IsRandomEngine< Threefry< R, U > >
struct	IsSame
struct	IsSame< T >
struct	IsSame< T, T >
struct	IsSame< T, U >
struct	IsSame< T, U, Ts... >
struct	IsSelfAdjoint
struct	IsSequence
struct	IsSequence< Sequence< T, Seq... > >
struct	IsSequence< T const >
struct	IsSignedInteger
struct	IsSignedInteger< SignedInteger< W > >
struct	IsSignedInteger< T const >
struct	IsStrictlyLowerTriangular
struct	IsStrictlyUpperTriangular
struct	IsString
struct	IsString< String< N > >
struct	IsString< T const >
struct	IsSubscripts
struct	IsSubscripts< Subscripts< Ns... > >
struct	IsSubscripts< T const >
struct	IsSymmetric
struct	IsTensor
struct	IsTensor< T const >
struct	IsTensor< Tensor< T, Ns... > >
struct	IsTensorView
struct	IsUnique
struct	IsUnique< T >
struct	IsUnit
struct	IsUnitary
struct	IsUnitLowerTriangular
struct	IsUnitUpperTriangular
struct	IsUnsignedInteger
struct	IsUnsignedInteger< T const >
struct	IsUnsignedInteger< UnsignedInteger< W > >
struct	IsUpperTriangular
struct	IsZero
class	JacobiRotation
struct	KroneckerProduct
class	LaplaceDistribution
class	LaplaceDistribution< T, If< IsFloat< T > > >
struct	Less
struct	LessEqual
struct	Linearize
class	Lock
struct	Log
struct	Log10
struct	Log2
struct	LogicalAnd
struct	LogicalNot
struct	LogicalOr
struct	Loop
struct	LowerTriangular
struct	Matricize
struct	Max
struct	Mean
struct	Min
struct	Minus
struct	Mod
struct	Mul
struct	Narrow
struct	Norm
struct	NotEqual
struct	NotFn
struct	NumericLimits
struct	NumericLimits< Float< 16 > >
	Class storing numeric limits of pRC Float<16> objects. More...
struct	NumericLimits< T const >
struct	NumericLimits< T, If< IsIntegral< T > > >
struct	NumericLimits< T, If< IsValue< T > > >
	Class storing numeric limits of pRC value types. More...
struct	OffDiagonal
struct	OuterProduct
class	Parameter
class	Parameter< Context::CompileTime, T, SA, SN, SD >
class	Parameter< Context::RunTime, T, SA, SN, SD >
struct	Permute
struct	Plus
struct	Pow
struct	Random
struct	Random< Complex< T >, D< T >, If< All< IsValue< T >, IsDistribution< D< T > > > > >
struct	Random< T, D< T >, If< All< IsValue< T >, IsDistribution< D< T > > > > >
	Class representing random numbers of pRC value type. More...
struct	Random< Tensor< T, Ns... >, D< typename T::Value >, If< IsDistribution< D< typename T::Value > > > >
	Class representing Tensors with random numbers. More...
struct	Random< TensorTrain::Operator< T, M, N, Ranks >, D< typename T::Value >, If< IsDistribution< D< typename T::Value > > > >
struct	Random< TensorTrain::Tensor< T, N, Ranks >, D< typename T::Value >, If< IsDistribution< D< typename T::Value > > > >
struct	Rcp
struct	Real
class	RecursiveLambda
struct	Reduce
struct	RelativeError
struct	Reshape
struct	Restrict
struct	Reverse
struct	Rotate
struct	Round
struct	Scalar
struct	ScalarProduct
class	SeedSequence
class	Sequence
class	Sequence< Size, Ns... >
struct	Sign
struct	Sin
struct	Sinh
struct	Slice
struct	Sqrt
struct	Square
struct	Squeeze
class	Stopwatch
struct	StrictlyLowerTriangular
struct	StrictlyUpperTriangular
struct	Stride
class	String
struct	Sub
struct	Subscript
class	Subscripts
struct	Swap
struct	Tan
struct	Tanh
class	Tensor
	Class storing tensors. More...
class	Tensor< Bool, Ns... >
	Class storing tensors with boolean entries. More...
struct	TensorProduct
class	Threefry
struct	Trace
struct	Transform
struct	Transpose
struct	True
struct	Trunc
struct	Unfolding
class	UniformDistribution
class	UniformDistribution< T, If< Any< IsFloat< T >, IsInteger< T > > > >
struct	Unit
struct	Unit< T, If< Any< IsBool< T >, IsIntegral< T > > > >
struct	Unit< T, If< IsComplex< T > > >
struct	Unit< T, If< IsTensor< T > > >
	Class representing a unit of a Tensor class. More...
struct	Unit< T, If< IsTensorView< T > > >
	Class representing a unit of a Tensor class corresponding to a TensorView. More...
struct	Unit< T, If< IsValue< T > > >
	Class representing a unit (1) of a pRC value class. More...
struct	Unit< T, If< TensorTrain::IsOperator< T > > >
struct	Unit< T, If< TensorTrain::IsOperatorView< T > > >
struct	Unit< T, If< TensorTrain::IsTensor< T > > >
struct	Unit< T, If< TensorTrain::IsTensorView< T > > >
struct	Unit< Void<> >
struct	UnitLowerTriangular
struct	UnitUpperTriangular
struct	UpperTriangular
struct	View
struct	Where
struct	Zero
struct	Zero< Float< 16 > >
	Class representing a zero (0) of pRC::Float<16> class. More...
struct	Zero< T, If< IsBool< T > > >
struct	Zero< T, If< IsComplex< T > > >
struct	Zero< T, If< IsIntegral< T > > >
struct	Zero< T, If< IsTensor< T > > >
	Class representing a zero of a Tensor class. More...
struct	Zero< T, If< IsTensorView< T > > >
	Class representing a zero of a Tensor class corresponding to a TensorView. More...
struct	Zero< T, If< IsValue< T > > >
	Class representing a zero (0) of a pRC value class. More...
struct	Zero< T, If< TensorTrain::IsOperator< T > > >
struct	Zero< T, If< TensorTrain::IsOperatorView< T > > >
struct	Zero< T, If< TensorTrain::IsTensor< T > > >
struct	Zero< T, If< TensorTrain::IsTensorView< T > > >
struct	Zero< Void<> >

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

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

Functions
template<Operator::Hint H = Operator::Hint::None, class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsFloat< typename R::Value > > = 0, If< IsSatisfied<(typename R::Dimension()==2)> > = 0, If< IsSatisfied<(R::size(0)==R::size(1))> > = 0>
static constexpr auto	cholesky (X &&a)
template<class T , Size M, Size N>
	JacobiRotation (Tensor< T, M, N > const &a, Index const p, Index const q) -> JacobiRotation< T >
template<class V , class T , Size M, Size N>
	JacobiRotation (TensorViews::View< T, Sizes< M, N >, V > const &a, Index const p, Index const q) -> JacobiRotation< T >
template<class T , Size N>
	JacobiRotation (Tensor< T, N > const &a, Index const p, Index const q) -> JacobiRotation< T >
template<class V , class T , Size N>
	JacobiRotation (TensorViews::View< T, Sizes< N >, V > const &a, Index const p, Index const q) -> JacobiRotation< T >
template<class TA , class TB >
static constexpr auto	operator== (JacobiRotation< TA > const &a, JacobiRotation< TB > const &b)
template<class TA , class TB >
static constexpr auto	operator!= (JacobiRotation< TA > const &a, JacobiRotation< TB > const &b)
template<class TA , class TB >
static constexpr auto	operator* (JacobiRotation< TA > const &a, JacobiRotation< TB > const &b)
template<class T >
static constexpr auto	transpose (JacobiRotation< T > const &a)
template<class T >
static constexpr auto	adjoint (JacobiRotation< T > const &a)
template<class T , class X , class R = RemoveReference<X>, If< Any< All< IsTensor< R >, Not< IsReference< X > > >, All< IsTensorish< R >, IsAssignable< X > > > > = 0, If< IsSatisfied<(typename R::Dimension()==2)> > = 0>
static constexpr decltype(auto)	apply (JacobiRotation< T > const &r, X &&m, Index const p, Index const q)
template<class T , class X , class R = RemoveReference<X>, If< Any< All< IsTensor< R >, Not< IsReference< X > > >, All< IsTensorish< R >, IsAssignable< X > > > > = 0, If< IsSatisfied<(typename R::Dimension()==2)> > = 0>
static constexpr decltype(auto)	apply (X &&m, JacobiRotation< T > const &r, Index const p, Index const q)
template<Size B = 32, class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsFloat< typename R::Value > > = 0, If< IsSatisfied<(typename R::Dimension()==2)> > = 0>
static constexpr auto	lq (X &&input)
template<class Optimizer , class XX , class RX = RemoveReference<XX>, class TX = typename RX::Type, class VX = typename TX::Value, If< IsTensorish< RX > > = 0, class RXE = RemoveConstReference<ResultOf<Eval, XX>>, class FF , If< IsInvocable< FF, RXE const &, RXE & > > = 0, If< IsFloat< ResultOf< FF, RXE const &, RXE & > > > = 0, class FC , If< IsInvocable< FC, RXE & > > = 0, class VT = VX, If< All< IsFloat< VX >, IsFloat< VT > > > = 0, If< IsInvocable< Optimizer, XX, FF, FC, VT > > = 0>
static constexpr auto	optimize (Optimizer &&optimizer, XX &&x, FF &&function, FC &&callback, VT const &tolerance=NumericLimits< VT >::tolerance())
	This function is used to optimize over a tensorish object.
template<class Optimizer , class XX , class RX = RemoveReference<XX>, class TX = typename RX::Type, class VX = typename TX::Value, If< IsTensorish< RX > > = 0, class RXE = RemoveConstReference<ResultOf<Eval, XX>>, class FF , If< IsInvocable< FF, RXE const &, RXE & > > = 0, If< IsFloat< ResultOf< FF, RXE const &, RXE & > > > = 0, class VT = VX, If< All< IsFloat< VX >, IsFloat< VT > > > = 0, If< IsInvocable< Optimizer, XX, FF, void(RXE const), VT > > = 0>
static constexpr auto	optimize (Optimizer &&optimizer, XX &&x, FF &&function, VT const &tolerance=NumericLimits< VT >::tolerance())
	This function is used to optimize over a tensorish object.
template<class Optimizer , class XX , class RX = RemoveReference<XX>, class TX = typename RX::Type, class VX = typename TX::Value, If< IsTensorish< RX > > = 0, class RXE = RemoveConstReference<ResultOf<Eval, XX>>, class FF , If< IsInvocable< FF, RXE const &, RXE & > > = 0, If< IsFloat< ResultOf< FF, RXE const &, RXE & > > > = 0, class FC , If< IsInvocable< FC, RXE & > > = 0, class VT = VX, If< All< IsFloat< VX >, IsFloat< VT > > > = 0, If< IsInvocable< Optimizer, XX, FF, FC, VT > > = 0>
static constexpr auto	optimize (XX &&x, FF &&function, FC &&callback, VT const &tolerance=NumericLimits< VT >::tolerance())
	This function is used to optimize over a tensorish object.
template<class Optimizer , class XX , class RX = RemoveReference<XX>, class TX = typename RX::Type, class VX = typename TX::Value, If< IsTensorish< RX > > = 0, class RXE = RemoveConstReference<ResultOf<Eval, XX>>, class FF , If< IsInvocable< FF, RXE const &, RXE & > > = 0, If< IsFloat< ResultOf< FF, RXE const &, RXE & > > > = 0, class VT = VX, If< All< IsFloat< VX >, IsFloat< VT > > > = 0, If< IsInvocable< Optimizer, XX, FF, void(RXE const), VT > > = 0>
static constexpr auto	optimize (XX &&x, FF &&function, VT const &tolerance=NumericLimits< VT >::tolerance())
	This function is used to optimize over a tensorish object.
template<Size B = 32, class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsFloat< typename R::Value > > = 0, If< IsSatisfied<(typename R::Dimension()==2)> > = 0>
static constexpr auto	qr (X &&input)
template<Operator::Transform T = Operator::Transform::None, Operator::Restrict R = Operator::Restrict::None, Operator::Hint H = Operator::Hint::None, class Solver , class XA , class XB , If< IsInvocable< Solver, XA, XB > > = 0>
static constexpr decltype(auto)	solve (Solver &&solver, XA &&A, XB &&b)
template<Operator::Transform T = Operator::Transform::None, Operator::Restrict R = Operator::Restrict::None, Operator::Hint H = Operator::Hint::None, class Solver , class XA , class XB , class XX , If< IsInvocable< Solver, XA, XB, XX > > = 0>
static constexpr decltype(auto)	solve (Solver &&solver, XA &&A, XB &&b, XX &&x0)
template<Operator::Transform T = Operator::Transform::None, Operator::Restrict R = Operator::Restrict::None, Operator::Hint H = Operator::Hint::None, class Solver , class XA , class XB , class VT , If< IsInvocable< Solver, XA, XB, VT > > = 0>
static constexpr decltype(auto)	solve (Solver &&solver, XA &&A, XB &&b, VT const &tolerance)
template<Operator::Transform T = Operator::Transform::None, Operator::Restrict R = Operator::Restrict::None, Operator::Hint H = Operator::Hint::None, class Solver , class XA , class XB , class XX , class VT , If< IsInvocable< Solver, XA, XB, XX, VT > > = 0>
static constexpr decltype(auto)	solve (Solver &&solver, XA &&A, XB &&b, XX &&x0, VT const &tolerance)
template<class Solver , Operator::Transform T = Operator::Transform::None, Operator::Restrict R = Operator::Restrict::None, Operator::Hint H = Operator::Hint::None, class XA , class XB , If< IsInvocable< Solver, XA, XB > > = 0>
static constexpr decltype(auto)	solve (XA &&A, XB &&b)
template<class Solver , Operator::Transform T = Operator::Transform::None, Operator::Restrict R = Operator::Restrict::None, Operator::Hint H = Operator::Hint::None, class XA , class XB , class XX , If< IsInvocable< Solver, XA, XB, XX > > = 0>
static constexpr decltype(auto)	solve (XA &&A, XB &&b, XX &&x0)
template<class Solver , Operator::Transform T = Operator::Transform::None, Operator::Restrict R = Operator::Restrict::None, Operator::Hint H = Operator::Hint::None, class XA , class XB , class VT , If< IsInvocable< Solver, XA, XB, VT > > = 0>
static constexpr decltype(auto)	solve (XA &&A, XB &&b, VT const &tolerance)
template<class Solver , Operator::Transform T = Operator::Transform::None, Operator::Restrict R = Operator::Restrict::None, Operator::Hint H = Operator::Hint::None, class XA , class XB , class XX , class VT , If< IsInvocable< Solver, XA, XB, XX, VT > > = 0>
static constexpr decltype(auto)	solve (XA &&A, XB &&b, XX &&x0, VT const &tolerance)
template<class C , class T , If< IsSubscriptable< T > > = 0, class S = ResultOf<Subscript, T &, Index>, If< IsInvocable< C, S, S > > = 0, If< IsAssignable< S > > = 0>
static constexpr void	sort (C const &compare, T &a, Size const k=T::size(), Size const d=0)
template<class C = Less, class T , If< IsSubscriptable< T > > = 0, class S = ResultOf<Subscript, T &, Index>, If< IsInvocable< C, S, S > > = 0, If< IsAssignable< S > > = 0>
static constexpr void	sort (T &a, Size const k=T::size(), Size const d=0)
template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsFloat< typename R::Value > > = 0, If< IsSatisfied<(typename R::Dimension()==2)> > = 0>
static constexpr auto	svd (X &&input)
template<Size C, class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, class V = typename R::Value, class VT = V, If< All< IsFloat< V >, IsFloat< VT > > > = 0, If< IsSatisfied<(typename R::Dimension()==2)> > = 0, If< IsSatisfied<(C< min(R::size(0), R::size(1)))> > = 0>
static constexpr auto	svd (X &&input, VT const &tolerance=NumericLimits< VT >::tolerance())
static constexpr auto	reverse (Direction const D)
template<class TA , class TB , If< IsUnsignedIntegral< TA > > = 0, If< IsUnsignedIntegral< TB > > = 0>
static constexpr auto	bitRotateLeft (TA const value, TB count)
template<class TA , class TB , If< IsUnsignedIntegral< TA > > = 0, If< IsUnsignedIntegral< TB > > = 0>
static constexpr auto	bitRotateRight (TA const value, TB count)
template<class TA , class TB , If< IsUnsignedIntegral< TA > > = 0, If< IsUnsignedIntegral< TB > > = 0>
static constexpr auto	ceilDiv (TA const a, TB const b)
template<Bool C = true, class X >
static constexpr Conditional< IsSatisfied< C >, RemoveConstReference< X >, X >	copy (X &&a)
template<class X >
static constexpr auto	operator== (X &&a, Zero<> const)
template<class X >
static constexpr auto	operator== (Zero<> const, X &&b)
static constexpr auto	operator== (Zero<> const, Zero<> const)
template<class X >
static constexpr auto	operator> (X &&a, Zero<> const)
template<class X >
static constexpr auto	operator> (Zero<> const, X &&b)
static constexpr auto	operator> (Zero<> const, Zero<> const)
template<class X >
static constexpr auto	operator>= (X &&a, Zero<> const)
template<class X >
static constexpr auto	operator>= (Zero<> const, X &&b)
static constexpr auto	operator>= (Zero<> const, Zero<> const)
template<class T , If< IsDefined< Identity< T > > > = 0, If< IsConstructible< Identity< T > > > = 0>
static constexpr auto	identity ()
static constexpr auto	identity ()
template<class T , class X , If< IsDefined< Identity< T > > > = 0, If< IsConstructible< Identity< T > > > = 0, If< IsInvocable< Identity< T >, X > > = 0>
static constexpr auto	identity (X &&value)
template<Size B, class T , If< IsUnsignedIntegral< T > > = 0>
static constexpr T	iLog (T const a)
template<class B , class N , If< IsIntegral< B > > = 0, If< IsUnsignedIntegral< N > > = 0>
static constexpr B	iPow (B const base, N const exp)
template<class T , If< IsIntegral< T > > = 0>
static constexpr auto	isEven (T const a)
template<class T , T V, If< IsIntegral< T > > = 0>
static constexpr auto	isEven (Constant< T, V > const)
template<class T , If< IsIntegral< T > > = 0>
static constexpr auto	isIdentity (T const a)
template<class T , T V, If< IsIntegral< T > > = 0>
static constexpr auto	isIdentity (Constant< T, V > const)
template<class T , If< IsIntegral< T > > = 0>
static constexpr auto	isOdd (T const a)
template<class T , T V, If< IsIntegral< T > > = 0>
static constexpr auto	isOdd (Constant< T, V > const)
template<class T , If< IsIntegral< T > > = 0>
static constexpr auto	isPowerOfTwo (T const v)
template<class T , If< IsIntegral< T > > = 0>
static constexpr auto	isUnit (T const a)
template<class T , T V, If< IsIntegral< T > > = 0>
static constexpr auto	isUnit (Constant< T, V > const)
template<class T , If< IsIntegral< T > > = 0>
static constexpr auto	isZero (T const a)
template<class T , T V, If< IsIntegral< T > > = 0>
static constexpr auto	isZero (Constant< T, V > const)
template<class T , If< IsUnsignedIntegral< T > > = 0>
static constexpr T	iSqrt (T const a)
template<class X >
static constexpr auto	operator< (X &&a, Zero<> const)
template<class X >
static constexpr auto	operator< (Zero<> const, X &&b)
static constexpr auto	operator< (Zero<> const, Zero<> const)
template<class X >
static constexpr auto	operator<= (X &&a, Zero<> const)
template<class X >
static constexpr auto	operator<= (Zero<> const, X &&b)
static constexpr auto	operator<= (Zero<> const, Zero<> const)
template<class X >
static constexpr X	max (X &&a)
template<class XA , class XB , If< IsInvocable< Greater, XA, XB > > = 0>
static constexpr auto	max (XA &&a, XB &&b)
template<class XA , class XB , class... Xs, If< IsInvocable< Greater, XA, XB > > = 0, If< All< IsInvocable< Greater, ResultOf< Where, ResultOf< Greater, XA, XB >, XA, XB >, Xs >... > > = 0>
static constexpr auto	max (XA &&a, XB &&b, Xs &&...args)
template<class X >
static constexpr X	min (X &&a)
template<class XA , class XB , If< IsInvocable< Less, XA, XB > > = 0>
static constexpr auto	min (XA &&a, XB &&b)
template<class XA , class XB , class... Xs, If< IsInvocable< Less, XA, XB > > = 0, If< All< IsInvocable< Less, ResultOf< Where, ResultOf< Less, XA, XB >, XA, XB >, Xs >... > > = 0>
static constexpr auto	min (XA &&a, XB &&b, Xs &&...args)
template<class X >
static constexpr auto	operator!= (X &&a, Zero<> const)
template<class X >
static constexpr auto	operator!= (Zero<> const, X &&b)
static constexpr auto	operator!= (Zero<> const, Zero<> const)
template<Size N>
static auto	print (String< N > const &string, std::FILE *stream)
template<class T , T... Is, class S >
static auto	print (Sequence< T, Is... > const, S &&stream)
template<Size... Ns, class S >
static auto	print (Sizes< Ns... > const, S &&stream)
template<class S >
static auto	print (Direction const direction, S &&stream)
template<class S >
static auto	print (Context const context, S &&stream)
template<class T , class D , If< IsConstructible< Random< T, D >, RandomEngine &, D & > > = 0>
static constexpr auto	random (RandomEngine &rng, D &distribution)
template<class T , If< IsDefined< Unit< T > > > = 0, If< IsConstructible< Unit< T > > > = 0, If< IsInvocable< Unit< T > > > = 0>
static constexpr auto	unit ()
static constexpr auto	unit ()
template<class T , class X , If< IsDefined< Unit< T > > > = 0, If< IsConstructible< Unit< T > > > = 0, If< IsInvocable< Unit< T >, X > > = 0>
static constexpr auto	unit (X &&value)
template<class TE , class T , If< IsBool< TE > > = 0>
static constexpr T	where (TE const e, T &&a, T &&b)
template<class TE , class T , If< IsBool< TE > > = 0>
static constexpr T const &	where (TE const e, T const &a, T &b)
template<class TE , class T , If< IsBool< TE > > = 0>
static constexpr T const &	where (TE const e, T &a, T const &b)
template<class TE , class XA , class XB , If< IsBool< TE > > = 0>
static constexpr auto	where (TE const e, XA &&a, XB &&b)
template<class T , If< IsDefined< Zero< T > > > = 0, If< IsConstructible< Zero< T > > > = 0, If< IsInvocable< Zero< T > > > = 0>
static constexpr auto	zero ()
static constexpr auto	zero ()
static constexpr auto	operator! (Position const P)
template<Context C, Size I, Size L, Direction D = Direction::Forwards, Size S = 1, class F , class... Xs>
static constexpr auto	range (F &&f, Xs &&...args)
template<Size I, Size L, Direction D = Direction::Forwards, Size S = 1, class F , class... Xs>
static constexpr auto	range (F &&f, Xs &&...args)
template<Size L, Direction D = Direction::Forwards, Size S = 1, class F , class... Xs>
static constexpr auto	range (F &&f, Xs &&...args)
template<Context C, class I , class L , Direction O, class D , class S = decltype(makeConstantSequence<Size, typename I::Dimension{}, 1>()), class F , class... Xs, If< IsSizes< I > > = 0, If< IsSizes< L > > = 0, If< IsSequence< D > > = 0, If< IsSizes< S > > = 0, If< IsSame< Direction, typename D::Type > > = 0, If< IsSame< typename I::Dimension, typename L::Dimension, typename D::Dimension, typename S::Dimension > > = 0, If< IsSatisfied<((L() - I()) % S()==Constant< Size, 0 >())> , If< IsSatisfied<(O==Direction::LeftToRight||O==Direction::RightToLeft)> > = 0>
static constexpr auto	range (F &&f, Xs &&...args)
template<Context C, class L , Direction O, class D , class S = decltype(makeConstantSequence<Size, typename L::Dimension{}, 1>()), class F , class... Xs, If< IsSizes< L > > = 0, If< IsSequence< D > > = 0, If< IsSizes< S > > = 0, If< IsSame< Direction, typename D::Type > > = 0, If< IsSame< typename L::Dimension, typename D::Dimension, typename S::Dimension > > = 0, If< IsSatisfied<(L() % S()==Constant< Size, 0 >())> , If< IsSatisfied<(O==Direction::LeftToRight||O==Direction::RightToLeft)> > = 0>
static constexpr auto	range (F &&f, Xs &&...args)
template<class I , class L , Direction O, class D , class S = decltype(makeConstantSequence<Size, typename I::Dimension{}, 1>()), class F , class... Xs, If< IsSizes< I > > = 0, If< IsSizes< L > > = 0, If< IsSequence< D > > = 0, If< IsSizes< S > > = 0, If< IsSame< Direction, typename D::Type > > = 0, If< IsSame< typename I::Dimension, typename L::Dimension, typename D::Dimension, typename S::Dimension > > = 0, If< IsSatisfied<((L() - I()) % S()==Constant< Size, 0 >())> , If< IsSatisfied<(O==Direction::LeftToRight||O==Direction::RightToLeft)> > = 0>
static constexpr auto	range (F &&f, Xs &&...args)
template<class L , Direction O, class D , class S = decltype(makeConstantSequence<Size, typename L::Dimension{}, 1>()), class F , class... Xs, If< IsSizes< L > > = 0, If< IsSequence< D > > = 0, If< IsSizes< S > > = 0, If< IsSame< Direction, typename D::Type > > = 0, If< IsSame< typename L::Dimension, typename D::Dimension, typename S::Dimension > > = 0, If< IsSatisfied<(L() % S()==Constant< Size, 0 >())> , If< IsSatisfied<(O==Direction::LeftToRight||O==Direction::RightToLeft)> > = 0>
static constexpr auto	range (F &&f, Xs &&...args)
template<class X >
	RecursiveLambda (X &&) -> RecursiveLambda< RemoveReference< X > >
template<class T , T... Seq>
	Sequence (std::integer_sequence< T, Seq... > const) -> Sequence< T, Seq... >
template<Size... Ns>
	Sequence (Sizes< Ns... > const) -> Sequence< Size, Ns... >
template<class T , T... As, T... Bs, If< IsInvocable< Add, T, T > > = 0, If< IsSatisfied<(sizeof...(As)==sizeof...(Bs))> > = 0>
static constexpr auto	operator+ (Sequence< T, As... > const, Sequence< T, Bs... > const)
template<class T , T... As, T B, If< IsInvocable< Add, T, T > > = 0>
static constexpr auto	operator+ (Sequence< T, As... > const, Constant< T, B > const)
template<class T , T A, T... Bs, If< IsInvocable< Add, T, T > > = 0>
static constexpr auto	operator+ (Constant< T, A > const, Sequence< T, Bs... > const)
template<class T , T... As, T... Bs, If< IsInvocable< Sub, T, T > > = 0, If< IsSatisfied<(sizeof...(As)==sizeof...(Bs))> > = 0>
static constexpr auto	operator- (Sequence< T, As... > const, Sequence< T, Bs... > const)
template<class T , T... As, T B, If< IsInvocable< Sub, T, T > > = 0>
static constexpr auto	operator- (Sequence< T, As... > const, Constant< T, B > const)
template<class T , T... As, T... Bs, If< IsInvocable< Mul, T, T > > = 0, If< IsSatisfied<(sizeof...(As)==sizeof...(Bs))> > = 0>
static constexpr auto	operator* (Sequence< T, As... > const, Sequence< T, Bs... > const)
template<class T , T... As, T B, If< IsInvocable< Mul, T, T > > = 0>
static constexpr auto	operator* (Sequence< T, As... > const, Constant< T, B > const)
template<class T , T A, T... Bs, If< IsInvocable< Mul, T, T > > = 0>
static constexpr auto	operator* (Constant< T, A > const, Sequence< T, Bs... > const)
template<class T , T... As, T... Bs, If< IsInvocable< Div, T, T > > = 0, If< IsSatisfied<(sizeof...(As)==sizeof...(Bs))> > = 0>
static constexpr auto	operator/ (Sequence< T, As... > const, Sequence< T, Bs... > const)
template<class T , T... As, T B, If< IsInvocable< Div, T, T > > = 0>
static constexpr auto	operator/ (Sequence< T, As... > const, Constant< T, B > const)
template<class T , T... As, T... Bs, If< IsInvocable< Mod, T, T > > = 0, If< IsSatisfied<(sizeof...(As)==sizeof...(Bs))> > = 0>
static constexpr auto	operator% (Sequence< T, As... > const, Sequence< T, Bs... > const)
template<class T , T... As, T B, If< IsInvocable< Mod, T, T > > = 0>
static constexpr auto	operator% (Sequence< T, As... > const, Constant< T, B > const)
template<class T , T... Is, If< IsInvocable< Minus, T > > = 0>
static constexpr auto	operator- (Sequence< T, Is... > const)
template<class T , T... As, T... Bs>
static constexpr auto	operator, (Sequence< T, As... > const, Sequence< T, Bs... > const)
template<class T , T... As, T... Bs, If< IsSatisfied<(sizeof...(As)==sizeof...(Bs))> > = 0>
static constexpr auto	operator== (Sequence< T, As... > const, Sequence< T, Bs... > const)
template<class T , T... As, T B>
static constexpr auto	operator== (Sequence< T, As... > const, Constant< T, B > const)
template<class T , T A, T... Bs>
static constexpr auto	operator== (Constant< T, A > const, Sequence< T, Bs... > const)
template<class T , T... As, T... Bs, If< IsSatisfied<(sizeof...(As)==sizeof...(Bs))> > = 0>
static constexpr auto	operator!= (Sequence< T, As... > const, Sequence< T, Bs... > const)
template<class T , T... As, T B>
static constexpr auto	operator!= (Sequence< T, As... > const, Constant< T, B > const)
template<class T , T A, T... Bs>
static constexpr auto	operator!= (Constant< T, A > const, Sequence< T, Bs... > const)
template<class T , T... As, T... Bs, If< IsInvocable< LessEqual, T, T > > = 0, If< IsSatisfied<(sizeof...(As)==sizeof...(Bs))> > = 0>
static constexpr auto	operator<= (Sequence< T, As... > const, Sequence< T, Bs... > const)
template<class T , T... As, T B, If< IsInvocable< LessEqual, T, T > > = 0>
static constexpr auto	operator<= (Sequence< T, As... > const, Constant< T, B > const)
template<class T , T A, T... Bs, If< IsInvocable< LessEqual, T, T > > = 0>
static constexpr auto	operator<= (Constant< T, A > const, Sequence< T, Bs... > const)
template<class T , T... As, T... Bs, If< IsInvocable< GreaterEqual, T, T > > = 0, If< IsSatisfied<(sizeof...(As)==sizeof...(Bs))> > = 0>
static constexpr auto	operator>= (Sequence< T, As... > const, Sequence< T, Bs... > const)
template<class T , T... As, T B, If< IsInvocable< GreaterEqual, T, T > > = 0>
static constexpr auto	operator>= (Sequence< T, As... > const, Constant< T, B > const)
template<class T , T A, T... Bs, If< IsInvocable< GreaterEqual, T, T > > = 0>
static constexpr auto	operator>= (Constant< T, A > const, Sequence< T, Bs... > const)
template<class T , T... As, T... Bs, If< IsInvocable< Equal, T, T > > = 0, If< IsSatisfied<(sizeof...(As)==sizeof...(Bs))> > = 0>
static constexpr auto	operator< (Sequence< T, As... > const, Sequence< T, Bs... > const)
template<class T , T... As, T B, If< IsInvocable< Equal, T, T > > = 0>
static constexpr auto	operator< (Sequence< T, As... > const, Constant< T, B > const)
template<class T , T A, T... Bs, If< IsInvocable< Equal, T, T > > = 0>
static constexpr auto	operator< (Constant< T, A > const, Sequence< T, Bs... > const)
template<class T , T... As, T... Bs, If< IsInvocable< Equal, T, T > > = 0, If< IsSatisfied<(sizeof...(As)==sizeof...(Bs))> > = 0>
static constexpr auto	operator> (Sequence< T, As... > const, Sequence< T, Bs... > const)
template<class T , T... As, T B, If< IsInvocable< Equal, T, T > > = 0>
static constexpr auto	operator> (Sequence< T, As... > const, Constant< T, B > const)
template<class T , T A, T... Bs, If< IsInvocable< Equal, T, T > > = 0>
static constexpr auto	operator> (Constant< T, A > const, Sequence< T, Bs... > const)
template<class T , T... Seq, class F , class... Xs, If< IsInvocable< F, Xs..., Constant< T, Seq >... > > = 0>
static constexpr decltype(auto)	expand (Sequence< T, Seq... > const, F &&f, Xs &&...args)
	forwards the values in a pRC::Sequence to a function as parameters
template<class T , T N>
static constexpr auto	makeSeries ()
template<class T >
static constexpr auto	makeSeriesFor ()
template<class T , class... Ts, If< IsSatisfied<(sizeof...(Ts) > 0)> >
static constexpr auto	makeSeriesFor ()
template<class T , T First, T Last, Direction D = Direction::Forwards, T Step = T(1), If< IsSatisfied<(D==Direction::Forwards||D==Direction::Backwards)> > = 0, If< IsSatisfied<((Last - First) % Step==0)> > = 0>
static constexpr auto	makeRange ()
template<class T , Size N, T V>
static constexpr auto	makeConstantSequence ()
template<class F , class T , T I1, T I2, T... Is, If< IsInvocable< F, T, T > > = 0>
static constexpr auto	reduce (Sequence< T, I1, I2, Is... > const)
template<class F , class T , T I>
static constexpr auto	reduce (Sequence< T, I > const)
template<Index... Ps, class T , T... Is, If< IsSatisfied<(sizeof...(Is)==sizeof...(Ps))> > = 0, If< IsSatisfied<((Ps< sizeof...(Is)) &&...)> > = 0, If< IsUnique< Constant< Index, Ps >... > > = 0>
static constexpr auto	permute (Sequence< T, Is... > const)
template<class T , T... Is>
static constexpr auto	reverse (Sequence< T, Is... > const)
template<Direction D, Size Step, class T , T First, T... Is, If< IsSatisfied<(D==Direction::Leftwards||D==Direction::Rightwards)> > = 0>
static constexpr auto	rotate (Sequence< T, First, Is... > const)
template<Direction D, Size Step, class T , If< IsSatisfied<(D==Direction::Leftwards||D==Direction::Rightwards)> > = 0>
static constexpr auto	rotate (Sequence< T > const)
template<Index O = 0, class T , T... Is, class... Seqs, If< IsSatisfied<((Sequence< T, Is... >::size()==Seqs::size()) &&...)> >
static constexpr auto	zip (Sequence< T, Is... > const, Seqs const ...)
template<class F , class T , T... Is>
static constexpr auto	filter (Sequence< T, Is... > const)
template<class F , class T , T... As, T... Bs, class... Seqs, If< IsInvocable< F, T, T > > = 0, If< IsSatisfied<((Sequence< T, As... >::size()==Seqs::size()) &&... &&(Sequence< T, As... >::size()==Sequence< T, Bs... >::size()))> >
static constexpr auto	pick (Sequence< T, As... > const, Sequence< T, Bs... > const, Seqs const ...)
template<Index D, Index... Ds, class T , T... Is, If< IsSatisfied<(sizeof...(Ds)< sizeof...(Is))> > = 0, If< IsSatisfied<(max(D, Ds...)< sizeof...(Is))> > = 0, If< IsUnique< Constant< Index, D >, Constant< Index, Ds >... > > = 0>
static constexpr auto	chip (Sequence< T, Is... > const)
template<class T , T... Is>
static constexpr auto	chip (Sequence< T, Is... > const)
template<Index S, Index... Ss, class T , T... Is, If< IsSatisfied<(sizeof...(Ss)< sizeof...(Is))> > = 0, If< IsSatisfied<(max(S, Ss...)< sizeof...(Is))> > = 0, If< IsUnique< Constant< Index, S >, Constant< Index, Ss >... > > = 0>
static constexpr auto	select (Sequence< T, Is... > const)
template<class T , T... Is>
static constexpr auto	select (Sequence< T, Is... > const)
template<Index B, Index P, class T , T... Is, If< IsSatisfied<(sizeof...(Is) % B==0)> > = 0, If< IsSatisfied<(P< B)> > = 0>
static constexpr auto	cut (Sequence< T, Is... > const)
template<Index I, Index L, class T , T... Is, If< IsSatisfied<(L<=sizeof...(Is))> > = 0, If< IsSatisfied<(I< L)> > = 0>
static constexpr auto	trim (Sequence< T, Is... > const)
template<class F = Less, class T , T I, T... Is, If< IsInvocableResult< Bool, F, T, T > > = 0>
static constexpr auto	sort (Sequence< T, I, Is... > const)
template<class T , T From, T... Froms, T To, T... Tos, T P, T... Ps, If< IsSatisfied<(sizeof...(Froms)==sizeof...(Tos) &&sizeof...(Froms)==sizeof...(Ps))> > = 0>
static constexpr auto	getPermutation (Sequence< T, From, Froms... > const, Sequence< T, To, Tos... > const, Sequence< T, P, Ps... > const)
template<class T , T... Froms, T... Tos, If< IsSatisfied<(sizeof...(Froms)==sizeof...(Tos))> > = 0>
static constexpr auto	getPermutation (Sequence< T, Froms... > const, Sequence< T, Tos... > const)
template<class T , T... Froms>
static constexpr auto	getPermutation (Sequence< T, Froms... > const)
template<class T , T N, T... Ps>
static constexpr auto	integerFactorization (Constant< T, N > const, Sequence< T, Ps... > const =Sequence< T >())
	String (char const &) -> String< 1 >
template<Size N>
	String (char const (&)[N]) -> String< N - 1 >
template<Size M, Size N>
static constexpr auto	operator+ (String< M > const &lhs, String< N > const &rhs)
template<Size M, Size N>
static constexpr auto	operator+ (String< M > const &lhs, char const (&rhs)[N])
template<Size M, Size N>
static constexpr auto	operator+ (char const (&lhs)[M], String< N > const &rhs)
template<class T >
static constexpr auto	name ()
template<class T , auto = sizeof(T)>
True	isDefined (T *)
template<class T , auto = sizeof(T), If< Not< IsPointer< T > > > = 0>
True	isDefined (T &&)
template<class... Xs>
static constexpr auto	forwardAsTuple (Xs &&...args)
template<class T >
AddConst< T > &	asConst (T &a)
template<class T >
AddConst< T >	asConst (T &&a)
template<class T , If< IsFloat< T > > = 0>
	Complex (T const &) -> Complex< T >
template<class TA , class TB , If< All< IsFloat< TA >, IsFloat< TB > > > = 0>
	Complex (TA const &, TB const &) -> Complex< Common< TA, TB > >
template<class T , If< IsInvocable< Norm<>, Complex< T > > > = 0>
static constexpr auto	abs (Complex< T > const &a)
template<class T >
static constexpr auto	acos (Complex< T > const &a)
template<class T >
static constexpr auto	acosh (Complex< T > const &a)
template<class TA , class TB , If< IsInvocable< Add, TA, TB > > = 0>
static constexpr auto	operator+ (Complex< TA > const &a, Complex< TB > const &b)
template<class TA , class TB , If< IsValue< TB > > = 0, If< IsInvocable< Add, TA, TB > > = 0>
static constexpr auto	operator+ (Complex< TA > const &a, TB const &b)
template<class TA , class TB , If< IsValue< TA > > = 0, If< IsInvocable< Add, TA, TB > > = 0>
static constexpr auto	operator+ (TA const &a, Complex< TB > const &b)
template<class T , If< IsInvocable< Atan2, T, T > > = 0>
static constexpr auto	arg (Complex< T > const &a)
template<class T , If< IsInvocable< Asinh, Complex< T > > > = 0>
static constexpr auto	asin (Complex< T > const &a)
template<class T >
static constexpr auto	asinh (Complex< T > const &a)
template<class T >
static constexpr auto	atan (Complex< T > const &a)
template<class T >
static constexpr auto	atanh (Complex< T > const &a)
template<class C , If< IsValue< C > > = 0, class T , If< IsInvocable< Cast< C >, T > > = 0>
static constexpr auto	cast (Complex< T > const &a)
template<class X , If< IsComplex< RemoveReference< X > > > = 0>
static constexpr X	complexify (X &&a)
template<class T >
static constexpr auto	conj (Complex< T > const &a)
template<class T >
static constexpr auto	cos (Complex< T > const &a)
template<class T >
static constexpr auto	cosh (Complex< T > const &a)
template<class TA , class TB , If< IsInvocable< Sub, TA, TB > > = 0>
static constexpr auto	delta (Complex< TA > const &a, Complex< TB > const &b)
template<class TA , class TB , If< IsValue< TB > > = 0, If< IsInvocable< Sub, TA, TB > > = 0>
static constexpr auto	delta (Complex< TA > const &a, TB const &b)
template<class TA , class TB , If< IsValue< TA > > = 0, If< IsInvocable< Sub, TA, TB > > = 0>
static constexpr auto	delta (TA const &a, Complex< TB > const &b)
template<class TA , class TB >
static constexpr auto	operator/ (Complex< TA > const &a, Complex< TB > const &b)
template<class TA , class TB , If< IsValue< TB > > = 0, If< IsInvocable< Div, TA, TB > > = 0>
static constexpr auto	operator/ (Complex< TA > const &a, TB const &b)
template<class TA , class TB , If< IsValue< TA > > = 0>
static constexpr auto	operator/ (TA const &a, Complex< TB > const &b)
template<class TA , class TB , If< IsInvocable< Equal, TA, TB > > = 0>
static constexpr auto	operator== (Complex< TA > const &a, Complex< TB > const &b)
template<class TA , class TB , If< IsValue< TB > > = 0, If< IsInvocable< Equal, TA, TB > > = 0>
static constexpr auto	operator== (Complex< TA > const &a, TB const &b)
template<class TA , class TB , If< IsValue< TA > > = 0, If< IsInvocable< Equal, TA, TB > > = 0>
static constexpr auto	operator== (TA const &a, Complex< TB > const &b)
template<class X , If< IsComplex< RemoveReference< X > > > = 0>
static constexpr X	eval (X &&a)
template<class T >
static constexpr auto	exp (Complex< T > const &a)
template<class X , If< IsComplex< RemoveReference< X > > > = 0>
static constexpr decltype(auto)	imag (X &&a)
template<class TA , class TB , If< IsInvocable< Conj, Complex< TA > > > = 0, If< IsInvocable< ScalarProduct, Complex< TA >, Complex< TB > > > = 0>
static constexpr auto	innerProduct (Complex< TA > const &a, Complex< TB > const &b)
template<class TA , class TB , If< IsValue< TB > > = 0, If< IsInvocable< Conj, Complex< TA > > > = 0, If< IsInvocable< ScalarProduct, Complex< TA >, TB > > = 0>
static constexpr auto	innerProduct (Complex< TA > const &a, TB const &b)
template<class TA , class TB , If< IsValue< TA > > = 0, If< IsInvocable< ScalarProduct, TA, Complex< TB > > > = 0>
static constexpr auto	innerProduct (TA const &a, Complex< TB > const &b)
template<class T >
static constexpr auto	log (Complex< T > const &a)
template<class T , If< IsInvocable< Log, Complex< T > > > = 0>
static constexpr auto	log10 (Complex< T > const &a)
template<class T , If< IsInvocable< Log, Complex< T > > > = 0>
static constexpr auto	log2 (Complex< T > const &a)
template<class T >
static constexpr auto	operator- (Complex< T > const &a)
template<class TA , class TB , If< IsInvocable< Mul, TA, TB > > = 0, If< IsInvocable< Add, TA, TB > > = 0, If< IsInvocable< Sub, TA, TB > > = 0>
static constexpr auto	operator* (Complex< TA > const &a, Complex< TB > const &b)
template<class TA , class TB , If< IsValue< TB > > = 0, If< IsInvocable< Mul, TA, TB > > = 0>
static constexpr auto	operator* (Complex< TA > const &a, TB const &b)
template<class TA , class TB , If< IsValue< TA > > = 0, If< IsInvocable< Mul, TA, TB > > = 0>
static constexpr auto	operator* (TA const &a, Complex< TB > const &b)
template<Index P = 2, Index Q = P, class T >
static constexpr auto	norm (Complex< T > const &a)
template<class TA , class TB , If< IsInvocable< NotEqual, TA, TB > > = 0>
static constexpr auto	operator!= (Complex< TA > const &a, Complex< TB > const &b)
template<class TA , class TB , If< IsValue< TB > > = 0, If< IsInvocable< NotEqual, TA, TB > > = 0>
static constexpr auto	operator!= (Complex< TA > const &a, TB const &b)
template<class TA , class TB , If< IsValue< TA > > = 0, If< IsInvocable< NotEqual, TA, TB > > = 0>
static constexpr auto	operator!= (TA const &a, Complex< TB > const &b)
template<class T >
static constexpr auto	operator+ (Complex< T > const &a)
template<class TA , class TB , If< All< IsValue< TA >, IsValue< TB > > > = 0, If< IsInvocable< Cos, TB > > = 0, If< IsInvocable< Sin, TB > > = 0, If< IsInvocable< Mul, TA, TB > > = 0>
static constexpr auto	polar (TA const &rho, TB const &theta)
template<class X , class Y >
static constexpr auto	pow (Complex< X > const &x, Complex< Y > const &y)
template<class X , class Y , If< IsValue< Y > > = 0>
static constexpr auto	pow (Complex< X > const &x, Y const &y)
template<class X , class Y , If< IsValue< X > > = 0>
static constexpr auto	pow (X const &x, Complex< Y > const &y)
template<class T , class S , If< IsComplex< T > > = 0>
static auto	print (T const &value, S &&stream)
template<class T >
static constexpr auto	rcp (Complex< T > const &b)
template<class X , If< IsComplex< RemoveReference< X > > > = 0>
static constexpr decltype(auto)	real (X &&a)
template<std::int64_t D = 0, class T , If< IsInvocable< Round< D >, T > > = 0>
static constexpr auto	round (Complex< T > const &a)
template<class TA , class TB , If< IsInvocable< Mul, Complex< TA >, Complex< TB > > > = 0>
static constexpr auto	scalarProduct (Complex< TA > const &a, Complex< TB > const &b)
template<class TA , class TB , If< IsValue< TB > > = 0, If< IsInvocable< Mul, Complex< TA >, TB > > = 0>
static constexpr auto	scalarProduct (Complex< TA > const &a, TB const &b)
template<class TA , class TB , If< IsValue< TA > > = 0, If< IsInvocable< Mul, TA, Complex< TB > > > = 0>
static constexpr auto	scalarProduct (TA const &a, Complex< TB > const &b)
template<class T , If< IsInvocable< Sign, T > > = 0>
static constexpr auto	sign (Complex< T > const &a)
template<class T >
static constexpr auto	sin (Complex< T > const &a)
template<class T >
static constexpr auto	sinh (Complex< T > const &a)
template<class T >
static constexpr auto	sqrt (Complex< T > const &a)
template<class T , If< IsInvocable< Mul, T, T > > = 0, If< IsInvocable< Sub, T, T > > = 0>
static constexpr auto	square (Complex< T > const &a)
template<class TA , class TB , If< IsInvocable< Sub, TA, TB > > = 0>
static constexpr auto	operator- (Complex< TA > const &a, Complex< TB > const &b)
template<class TA , class TB , If< IsValue< TB > > = 0, If< IsInvocable< Sub, TA, TB > > = 0>
static constexpr auto	operator- (Complex< TA > const &a, TB const &b)
template<class TA , class TB , If< IsValue< TA > > = 0, If< IsInvocable< Sub, TA, TB > > = 0>
static constexpr auto	operator- (TA const &a, Complex< TB > const &b)
template<class T >
static constexpr auto	tan (Complex< T > const &a)
template<class T >
static constexpr auto	tanh (Complex< T > const &a)
template<class T , If< IsInvocable< Trunc, T > > = 0>
static constexpr auto	trunc (Complex< T > const &a)
static constexpr auto	isProperAlignment (Size const alignment)
template<Size S, Size P = alignof(std::max_align_t)>
static constexpr auto	alignment ()
static auto	alloc (Size size, Size const alignment=alignof(std::max_align_t))
static auto	dealloc (void *ptr)
template<class T , Size N>
	CommonArray (T const (&)[N]) -> CommonArray< Allocation::Stack, T, N >
template<Allocation A1, Allocation A2, class TA , class TB , Size... Ns, If< IsInvocable< Equal, TA, TB > > = 0>
static constexpr auto	operator== (CommonArray< A1, TA, Ns... > const &lhs, CommonArray< A2, TB, Ns... > const &rhs)
template<Allocation A1, Allocation A2, class TA , class TB , Size... Ns>
static constexpr auto	operator!= (CommonArray< A1, TA, Ns... > const &lhs, CommonArray< A2, TB, Ns... > const &rhs)
template<class S >
static auto	print (Allocation const alloc, S &&stream)
template<Size... Ns, class S >
static auto	print (Subscripts< Ns... > const &a, S &&stream)
template<Size N, class S >
static auto	print (Indices< N > const &a, S &&stream)
template<Allocation A, class T , Size... Ns, class S >
static auto	print (CommonArray< A, T, Ns... > const &arg, S &&stream)
template<class... Is, If< All< IsConvertible< Is, Index >... > > = 0>
	Indices (Is const ...) -> Indices< sizeof...(Is)>
template<Size... Ns>
static constexpr auto	operator+ (Subscripts< Ns... > const &lhs, Subscripts< Ns... > const &rhs)
template<Size... Ns>
static constexpr auto	operator- (Subscripts< Ns... > const &lhs, Subscripts< Ns... > const &rhs)
template<Size... Ns, Size... Ss, If< IsSatisfied<(sizeof...(Ns)==sizeof...(Ss))> > = 0>
static constexpr auto	operator* (Subscripts< Ns... > const &lhs, Sizes< Ss... > const)
template<Size... Ns, Size... Ss, If< IsSatisfied<(sizeof...(Ns)==sizeof...(Ss))> > = 0>
static constexpr auto	operator* (Sizes< Ss... > const, Subscripts< Ns... > const &rhs)
template<Size... Ns, Size... Ss, If< IsSatisfied<(sizeof...(Ns)==sizeof...(Ss))> > = 0>
static constexpr auto	operator/ (Subscripts< Ns... > const &lhs, Sizes< Ss... > const)
template<Size... Ns, Size... Ss, If< IsSatisfied<(sizeof...(Ns)==sizeof...(Ss))> > = 0>
static constexpr auto	operator% (Subscripts< Ns... > const &lhs, Sizes< Ss... > const)
template<Size... Ns>
static constexpr auto	operator== (Subscripts< Ns... > const &lhs, Subscripts< Ns... > const &rhs)
template<Size... Ns>
static constexpr auto	operator!= (Subscripts< Ns... > const &lhs, Subscripts< Ns... > const &rhs)
template<Index... Ps, Size... Ns, If< IsSatisfied<(sizeof...(Ps)==sizeof...(Ns))> > = 0, If< IsSatisfied<(max(Ps...)< sizeof...(Ns))> > = 0, If< IsUnique< Constant< Index, Ps >... > > = 0>
static constexpr auto	permute (Subscripts< Ns... > const &arg)
template<Size... Ns>
static constexpr auto	reverse (Subscripts< Ns... > const &arg)
template<Direction D, Size Step, Size... Ns, If< True< decltype(rotate< D, Step >(makeSeriesFor< Index, Ns... >()))> >
static constexpr auto	rotate (Subscripts< Ns... > const &arg)
template<Index... Ds, Size... Ns, If< True< decltype(chip< Ds... >(Sequence< Index, Ns... >()))> >
static constexpr auto	chip (Subscripts< Ns... > const &arg)
template<class T >
static constexpr auto	name ()
template<class T , T V, class S >
static auto	print (Constant< T, V > const, S &&stream)
template<class T , If< IsSame< T, Bool > > = 0>
static auto	print (T const value, std::FILE *stream)
static auto	print (char const *const string, std::FILE *stream)
static auto	print (std::string const &string, std::FILE *stream)
template<class... Ps>
static constexpr auto	help (Ps &&...parameters)
template<Context C, class T , class A , class N , class D , If< True< decltype(String(declval< A >()))> , If< True< decltype(String(declval< N >()))> , If< True< decltype(String(declval< D >()))> , If< IsSatisfied<(C==Context::CompileTime||C==Context::RunTime)> > = 0>
static constexpr auto	parameter (A &&argument, N &&name, D &&description, T const &defaultValue)
template<Context C, class T , class A , class N , class D , If< True< decltype(String(declval< A >()))> , If< True< decltype(String(declval< N >()))> , If< True< decltype(String(declval< D >()))> , If< IsSatisfied<(C==Context::RunTime)> > = 0>
static constexpr auto	parameter (A &&argument, N &&name, D &&description)
template<Context C, class T , class A , class N , class D , If< True< decltype(String(declval< A >()))> , If< True< decltype(String(declval< N >()))> , If< True< decltype(String(declval< D >()))> , If< IsSatisfied<(C==Context::RunTime)> > = 0>
static constexpr auto	parameter (A &&argument, N &&name, D &&description, T(*convert)(char const *const))
template<Context C, class T , class A , class N , class D , If< True< decltype(String(declval< A >()))> , If< True< decltype(String(declval< N >()))> , If< True< decltype(String(declval< D >()))> , If< IsSatisfied<(C==Context::RunTime)> > = 0>
static constexpr auto	parameter (A &&argument, N &&name, D &&description, T(*convert)(char const *const), T const &defaultValue)
template<class N , class D , class... Ps, If< True< decltype(String(declval< N >()))> , If< True< decltype(String(declval< D >()))> >
static constexpr auto	parse (int const argc, char const *const *const argv, N &&appName, D &&appDescription, Ps &...parameters)
template<class... Ps>
static constexpr auto	report (Ps &&...parameters)
template<class T , class... Ts>
static auto	optimizationBarrier (const T &basic, Ts &...basics)
static Float< 64 >	getTimeInSeconds ()
template<class T , class RNG , If< IsRandomEngine< RNG > > = 0, If< IsFloat< T > > = 0>
static constexpr T	generateCanonical (RNG &rng)
template<class T >
constexpr auto	operator== (GaussianDistribution< T > const &lhs, GaussianDistribution< T > const &rhs)
template<class T >
constexpr auto	operator!= (GaussianDistribution< T > const &lhs, GaussianDistribution< T > const &rhs)
template<class T >
constexpr auto	operator== (LaplaceDistribution< T > const &lhs, LaplaceDistribution< T > const &rhs)
template<class T >
constexpr auto	operator!= (LaplaceDistribution< T > const &lhs, LaplaceDistribution< T > const &rhs)
template<Size N, class S >
static auto	print (SeedSequence< N > const &seq, S &&stream)
template<class... Ts>
	SeedSequence (Ts &&...) -> SeedSequence< sizeof...(Ts)>
template<class T >
constexpr auto	operator== (UniformDistribution< T > const &lhs, UniformDistribution< T > const &rhs)
template<class T >
constexpr auto	operator!= (UniformDistribution< T > const &lhs, UniformDistribution< T > const &rhs)
template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Abs >, X > > = 0>
static constexpr auto	abs (X &&a)
	Calculates the element-wise absolute value of a Tensor.
template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Acos >, X > > = 0>
static constexpr auto	acos (X &&a)
	Calculates element-wise arcus cosine of a Tensor.
template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Acosh >, X > > = 0>
static constexpr auto	acosh (X &&a)
	Calculates element-wise hyperbolic area cosine of a Tensor.
template<class XA , class XB , If< IsTensorish< RemoveReference< XA > > > = 0, If< IsTensorish< RemoveReference< XB > > > = 0, If< IsInvocable< Loop< Add >, XA, XB > > = 0>
static constexpr auto	operator+ (XA &&a, XB &&b)
	Calculates sum of two Tensors.
template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Arg >, X > > = 0>
static constexpr auto	arg (X &&a)
	Returns the element-wise argument of a Tensor.
template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Asin >, X > > = 0>
static constexpr auto	asin (X &&a)
	Calculates element-wise arcus sine of a Tensor.
template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Asinh >, X > > = 0>
static constexpr auto	asinh (X &&a)
	Calculates element-wise hyperbolic area sine of a Tensor.
template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Atan >, X > > = 0>
static constexpr auto	atan (X &&a)
	Calculates element-wise arcus tangent of a Tensor.
template<class XA , class XB , If< IsTensorish< RemoveReference< XA > > > = 0, If< IsTensorish< RemoveReference< XB > > > = 0, If< IsInvocable< Loop< Atan2 >, XA, XB > > = 0>
static constexpr auto	atan2 (XA &&a, XB &&b)
	Calculates element-wise atan2 of two Tensors containing x and y coordinates.
template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Atanh >, X > > = 0>
static constexpr auto	atanh (X &&a)
	Calculates element-wise hyperbolic area tangent of a Tensor.
template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< View, X > > = 0>
static constexpr auto	backwards (X &&a)
	Flips the order of the indices of a Tensor.
template<Size... Bs, class X , class... Os, class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< View, X > > = 0, If< All< IsConvertible< Os, Index >... > > = 0, If< IsSatisfied<(sizeof...(Bs)==typename R::Dimension())> > = 0, If< IsSatisfied<(sizeof...(Os)==typename R::Dimension())> > = 0, If< IsSatisfied<(typename R::Sizes() % Sizes< Bs... >()==Constant< Size, 0 >())> >
static constexpr auto	block (X &&a, Os const ... offsets)
	Splits a Tensor into equal-sized blocks and returns one block specified by indices.
template<Size... Bs, class X , class... Os, class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< Not< IsInvocable< View, X > > > = 0, If< IsInvocable< Block< Bs... >, X &, Os... > > = 0>
static constexpr auto	block (X &&a, Os const ... offsets)
	Splits a Tensor into equal-sized blocks and returns one block specified by indices.
template<Size... Bs, class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< View, X > > = 0, If< IsSatisfied<(sizeof...(Bs)==typename R::Dimension())> > = 0>
static constexpr auto	broadcast (X &&a)
	Broadcasts a Tensor into one whose mode sizes are a multiple of the mode sizes of the original Tensor.
template<class C , class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Cast< C > >, X > > = 0>
static constexpr auto	cast (X &&a)
	Casts the elements of a Tensor to a different value class.
template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Ceil >, X > > = 0>
static constexpr auto	ceil (X &&a)
	Calculates element-wise ceiling of Tensor.
template<Index... Ds, class X , class... Is, class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< View, X > > = 0, If< All< IsConvertible< Is, Index >... > > = 0, If< IsSatisfied<(sizeof...(Is)==sizeof...(Ds))> > = 0, If< True< decltype(chip< Ds... >(makeSeries< Index, typename R::Dimension{}>()))> >
static constexpr auto	chip (X &&a, Is const ... indices)
	Removes dimensions from a Tensor by specifying indices along them.
template<Index... Ds, class X , class... Is, class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< Not< IsInvocable< View, X > > > = 0, If< IsInvocable< Chip< Ds... >, X &, Is... > > = 0>
static constexpr auto	chip (X &&a, Is const ... indices)
	Removes dimensions from a Tensor by specifying indices along them.
template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Complexify >, X > > = 0>
static constexpr auto	complexify (X &&a)
	Casts a Tensors values element-wise to Complex.
template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Conj >, X > > = 0>
static constexpr auto	conj (X &&a)
	Calculates the element-wise complex conjugate of a Tensor.
template<Index... Is, class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< View, X > > = 0, If< IsSatisfied<(isEven(sizeof...(Is)))> > = 0, If< IsSatisfied<(sizeof...(Is)<=typename R::Dimension())> > = 0>
static constexpr auto	contract (X &&a)
	Contracts given indices of a Tensor.
template<Index... Is, class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< IsTensorish< RA > > = 0, If< IsInvocable< View, XA > > = 0, If< IsTensorish< RB > > = 0, If< IsInvocable< View, XB > > = 0, If< IsSatisfied<(isEven(sizeof...(Is)))> > = 0, If< IsSatisfied<(sizeof...(Is)/2<=min(typename RA::Dimension(), typename RB::Dimension()))> > = 0>
static constexpr auto	contract (XA &&a, XB &&b)
	Contracts given indices of two Tensors.
template<Index... Is, class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< Not< IsInvocable< View, X > > > = 0, If< IsInvocable< Contract< Is... >, X & > > = 0>
static constexpr auto	contract (X &&a)
	Contracts given indices of a Tensor.
template<Index... Is, class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< IsTensorish< RA > > = 0, If< IsTensorish< RB > > = 0, If< Not< All< IsInvocable< View, XA >, IsInvocable< View, XB > > > > = 0, If< IsInvocable< Contract< Is... >, XA &, XB & > > = 0>
static constexpr auto	contract (XA &&a, XB &&b)
	Contracts given indices of two Tensors.
template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Cos >, X > > = 0>
static constexpr auto	cos (X &&a)
	Calculates the element-wise cosine of Tensor.
template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Cosh >, X > > = 0>
static constexpr auto	cosh (X &&a)
	Calculates the element-wise hyperbolic cosine of a Tensor.
template<class XA , class XB , If< IsTensorish< RemoveReference< XA > > > = 0, If< IsTensorish< RemoveReference< XB > > > = 0, If< IsInvocable< Loop< Delta >, XA, XB > > = 0>
static constexpr auto	delta (XA &&a, XB &&b)
	Calculates element-wise difference of two Tensors.
template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< IsTensorish< RA > > = 0, If< IsInvocable< View, XA > > = 0, If< IsTensorish< RB > > = 0, If< IsInvocable< View, XB > > = 0, If< IsSame< typename RA::Dimension, typename RB::Dimension > > = 0, If< HasCommon< typename RA::Type, typename RB::Type > > = 0>
static constexpr auto	directSum (XA &&a, XB &&b)
	Calculates the direct sum of two Tensors.
template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< IsTensorish< RA > > = 0, If< IsTensorish< RB > > = 0, If< Not< All< IsInvocable< View, XA >, IsInvocable< View, XB > > > > = 0, If< IsInvocable< DirectSum, XA &, XB & > > = 0>
static constexpr auto	directSum (XA &&a, XB &&b)
	Calculates the direct sum of two Tensors.
template<class XA , class XB , If< IsTensorish< RemoveReference< XA > > > = 0, If< IsTensorish< RemoveReference< XB > > > = 0, If< IsInvocable< Loop< Div >, XA, XB > > = 0>
static constexpr auto	operator/ (XA &&a, XB &&b)
	Calculates element-wise division of two Tensors.
template<class XA , class XB , If< IsTensorish< RemoveReference< XA > > > = 0, If< IsTensorish< RemoveReference< XB > > > = 0, If< IsInvocable< Loop< Equal >, XA, XB > > = 0>
static constexpr auto	operator== (XA &&a, XB &&b)
	Checks equality of two Tensors.
template<class X , If< IsTensor< RemoveReference< X > > > = 0>
static constexpr X	eval (X &&a)
	Evaluates a Tensor.
template<class X , If< IsTensorView< RemoveReference< X > > > = 0>
static constexpr auto	eval (X &&a)
	Evaluates a TensorView.
template<Index... Es, class F , class... Xs, If< All< IsTensorish< RemoveReference< Xs > >... > > = 0, If< All< IsInvocable< View, Xs >... > > = 0, If< IsSame< decltype(select< Es... >(typename RemoveReference< Xs >::Sizes()))... > , If< IsInvocable< F, ResultOf< pRC::Chip< Es... >, Xs, decltype(Es)... >... > > = 0, If< True< decltype(select< Es... >(makeSeries< Index, typename RemoveReference< Xs >::Dimension{}>()))... > >
static constexpr auto	exclude (F &&f, Xs &&...args)
template<class F , Index... Es, class... Xs, If< All< IsTensorish< RemoveReference< Xs > >... > > = 0, If< All< IsInvocable< View, Xs >... > > = 0, If< IsSame< decltype(select< Es... >(typename RemoveReference< Xs >::Sizes()))... > , If< IsInvocable< F, ResultOf< pRC::Chip< Es... >, Xs, decltype(Es)... >... > > = 0, If< True< decltype(select< Es... >(makeSeries< Index, typename RemoveReference< Xs >::Dimension{}>()))... > >
static constexpr auto	exclude (Xs &&...args)
template<Index... Es, class F , class... Xs, If< All< IsTensorish< RemoveReference< Xs > >... > > = 0, If< Not< All< IsInvocable< View, Xs >... > > > = 0, If< IsInvocable< Exclude< F, Es... >, Xs &... > > = 0>
static constexpr auto	exclude (F &&f, Xs &&...args)
template<class F , Index... Es, class... Xs, If< All< IsTensorish< RemoveReference< Xs > >... > > = 0, If< Not< All< IsInvocable< View, Xs >... > > > = 0, If< IsInvocable< Exclude< F, Es... >, Xs &... > > = 0>
static constexpr auto	exclude (Xs &&...args)
template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Exp >, X > > = 0>
static constexpr auto	exp (X &&a)
	Calculates element-wise exponential of a Tensor.
template<Index K, class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< View, X > > = 0, If< IsSatisfied<(typename R::Dimension{} > 1)> , If< IsSatisfied<(K< typename R::Dimension{})> > = 0>
static constexpr auto	flatten (X &&a)
	Flatten every dimension of a Tensor except for one.
template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Floor >, X > > = 0>
static constexpr auto	floor (X &&a)
	Calculates element-wise floor of a Tensor.
template<class XA , class XB , If< IsTensorish< RemoveReference< XA > > > = 0, If< IsTensorish< RemoveReference< XB > > > = 0, If< IsInvocable< Loop< FMod >, XA, XB > > = 0>
static constexpr auto	fmod (XA &&a, XB &&b)
	Calculates the floating-point remainder of an element-wise integer division of two Tensors.
template<Position P, class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsSatisfied<(typename R::Dimension{} > 1)> , If< IsSatisfied<(P==Position::Left||P==Position::Right)> > = 0, If< All< IsInvocable< Unfolding< typename R::Dimension() - 2 >, X >, IsInvocable< Unfolding< 0 >, X > > > = 0>
static constexpr auto	folding (X &&a)
	Reshapes a Tensor into a matrix.
template<class XA , class XB , If< IsTensorish< RemoveReference< XA > > > = 0, If< IsTensorish< RemoveReference< XB > > > = 0, If< IsInvocable< Loop< Greater >, XA, XB > > = 0>
static constexpr auto	operator> (XA &&a, XB &&b)
	Checks element-wise whether a Tensor's elements are greater than another Tensor's elements.
template<class XA , class XB , If< IsTensorish< RemoveReference< XA > > > = 0, If< IsTensorish< RemoveReference< XB > > > = 0, If< IsInvocable< Loop< GreaterEqual >, XA, XB > > = 0>
static constexpr auto	operator>= (XA &&a, XB &&b)
	Checks element-wise whether a Tensor's elements are greater than or equal to another Tensor's elements.
template<class XA , class XB , If< IsTensorish< RemoveReference< XA > > > = 0, If< IsTensorish< RemoveReference< XB > > > = 0, If< IsInvocable< Loop< Mul >, XA, XB > > = 0>
static constexpr auto	hadamardProduct (XA &&a, XB &&b)
	Calculates the Hadamard product of two Tensors.
template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Imag >, X > > = 0>
static constexpr auto	imag (X &&a)
	Calculates element-wise the imaginary part of a Tensor.
template<Size... Is, class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< View, X > > = 0, If< IsSatisfied<(sizeof...(Is)==typename R::Dimension())> > = 0>
static constexpr auto	inflate (X &&a)
	Inflates the sizes of a Tensor by repeating its values.
template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< IsTensorish< RA > > = 0, If< IsInvocable< View, XA > > = 0, If< IsTensorish< RB > > = 0, If< IsInvocable< Conj, XA > > = 0, If< IsInvocable< ScalarProduct, ResultOf< Conj, XA >, XB > > = 0>
static constexpr auto	innerProduct (XA &&a, XB &&b)
	Calculates the inner product of two Tensors.
template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< IsTensorish< RA > > = 0, If< IsTensorish< RB > > = 0, If< Not< All< IsInvocable< View, XA >, IsInvocable< View, XB > > > > = 0, If< IsInvocable< InnerProduct, XA &, XB & > > = 0>
static constexpr auto	innerProduct (XA &&a, XB &&b)
	Calculates the inner product of two Tensors.
template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< IsTensorish< RA > > = 0, If< IsInvocable< View, XA > > = 0, If< IsTensorish< RB > > = 0, If< IsInvocable< View, XB > > = 0, If< IsSame< typename RA::Dimension, typename RB::Dimension > > = 0, class EA = ResultOf<XA, typename RA::Subscripts>, class EB = ResultOf<XB, typename RB::Subscripts>, If< IsInvocable< Mul, EA, EB > > = 0>
static constexpr auto	kroneckerProduct (XA &&a, XB &&b)
	Calculates the Kronecker product of two Tensors.
template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< IsTensorish< RA > > = 0, If< IsTensorish< RB > > = 0, If< Not< All< IsInvocable< View, XA >, IsInvocable< View, XB > > > > = 0, If< IsInvocable< KroneckerProduct, XA &, XB & > > = 0>
static constexpr auto	kroneckerProduct (XA &&a, XB &&b)
	Calculates the Kronecker product of two Tensors.
template<class XA , class XB , If< IsTensorish< RemoveReference< XA > > > = 0, If< IsTensorish< RemoveReference< XB > > > = 0, If< IsInvocable< Loop< Less >, XA, XB > > = 0>
static constexpr auto	operator< (XA &&a, XB &&b)
	Checks element-wise whether a Tensor's elements are less than another Tensor's elements.
template<class XA , class XB , If< IsTensorish< RemoveReference< XA > > > = 0, If< IsTensorish< RemoveReference< XB > > > = 0, If< IsInvocable< Loop< LessEqual >, XA, XB > > = 0>
static constexpr auto	operator<= (XA &&a, XB &&b)
	Checks element-wise whether a Tensor's elements are less than or equal to another Tensor's elements.
template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsSatisfied<(typename R::Dimension{} > 0)> , If< IsInvocable< Reshape< R::Sizes::size()>, X > > = 0>
static constexpr auto	linearize (X &&a)
	Linearizes a Tensor into a vector.
template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Log >, X > > = 0>
static constexpr auto	log (X &&a)
	Calculates the element-wise natural (base e) logarithm of a Tensor.
template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Log10 >, X > > = 0>
static constexpr auto	log10 (X &&a)
	Calculates the element-wise base 10 logarithm of a Tensor.
template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Log2 >, X > > = 0>
static constexpr auto	log2 (X &&a)
	Calculates the element-wise base 2 logarithm of a Tensor.
template<class XA , class XB , If< IsTensorish< RemoveReference< XA > > > = 0, If< IsTensorish< RemoveReference< XB > > > = 0, If< IsInvocable< Loop< LogicalAnd >, XA, XB > > = 0>
static constexpr auto	operator&& (XA &&a, XB &&b)
	Calculates the element-wise logical and of two Tensors.
template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< LogicalNot >, X > > = 0>
static constexpr auto	operator! (X &&a)
	Calculates the element-wise logical not of a Tensors.
template<class XA , class XB , If< IsTensorish< RemoveReference< XA > > > = 0, If< IsTensorish< RemoveReference< XB > > > = 0, If< IsInvocable< Loop< LogicalOr >, XA, XB > > = 0>
static constexpr auto	operator|| (XA &&a, XB &&b)
	Calculates the element-wise logical or of two Tensors.
template<class F , class... Xs, If< All< IsTensorish< RemoveReference< Xs > >... > > = 0, If< All< IsInvocable< View, Xs >... > > = 0, If< IsSame< typename RemoveReference< Xs >::Sizes... > > = 0, If< IsInvocable< F, ResultOf< Xs, typename RemoveReference< Xs >::Subscripts >... > > = 0>
static constexpr auto	loop (F &&f, Xs &&...args)
	Applies a function element-wise to Tensors.
template<class F , class... Xs, If< All< IsTensorish< RemoveReference< Xs > >... > > = 0, If< All< IsInvocable< View, Xs >... > > = 0, If< IsSame< typename RemoveReference< Xs >::Sizes... > > = 0, If< IsInvocable< F, ResultOf< Xs, typename RemoveReference< Xs >::Subscripts >... > > = 0>
static constexpr auto	loop (Xs &&...args)
	Applies a function element-wise to Tensors.
template<class F , class... Xs, If< All< IsTensorish< RemoveReference< Xs > >... > > = 0, If< Not< All< IsInvocable< View, Xs >... > > > = 0, If< IsInvocable< Loop< F >, F, Xs &... > > = 0>
static constexpr auto	loop (F &&f, Xs &&...args)
	Applies a function element-wise to Tensors.
template<class F , class... Xs, If< All< IsTensorish< RemoveReference< Xs > >... > > = 0, If< Not< All< IsInvocable< View, Xs >... > > > = 0, If< IsInvocable< Loop< F >, Xs &... > > = 0>
static constexpr auto	loop (Xs &&...args)
	Applies a function element-wise to Tensors.
template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Minus >, X > > = 0>
static constexpr auto	operator- (X &&a)
	Calculates the element-wise negative of a Tensor.
template<class XA , class XB , If< IsTensorish< RemoveReference< XA > > > = 0, If< IsTensorish< RemoveReference< XB > > > = 0, If< IsInvocable< Loop< Mod >, XA, XB > > = 0>
static constexpr auto	operator% (XA &&a, XB &&b)
	Calculates element-wise modulus of an integer division of two Tensors.
template<Index... Ns, class F , class... Xs, If< All< IsTensorish< RemoveReference< Xs > >... > > = 0, If< IsSame< decltype(chip< Ns... >(typename RemoveReference< Xs >::Sizes()))... > , If< True< decltype(chip< Ns... >(makeSeries< Index, Common< typename RemoveReference< Xs >::Dimension... >{}>()))> >
static constexpr auto	narrow (F &&f, Xs &&...args)
	Performs an operation only along given dimensions of Tensors.
template<class F , Index... Ns, class... Xs, If< All< IsTensorish< RemoveReference< Xs > >... > > = 0, If< IsSame< decltype(chip< Ns... >(typename RemoveReference< Xs >::Sizes()))... > , If< True< decltype(chip< Ns... >(makeSeries< Index, Common< typename RemoveReference< Xs >::Dimension... >{}>()))> >
static constexpr auto	narrow (Xs &&...args)
	Performs an operation only along given dimensions of Tensors.
template<Index P = 2, Index Q = P, class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< View, X > > = 0, If< Any< All< IsSatisfied<(P==1 &&Q==1)>, IsInvocable< Loop< Norm< 1, 1 > >, X >, IsInvocable< Reduce< Add >, ResultOf< Loop< Norm< 1, 1 > >, X > > >, All< IsSatisfied<(P==2 &&Q==1)>, IsInvocable< Loop< Norm< 2, 1 > >, X >, IsInvocable< Reduce< Add >, ResultOf< Loop< Norm< 2, 1 > >, X > > >, All< IsSatisfied<(P==2 &&Q==2)>, IsInvocable< Loop< Norm< 2, 1 > >, X >, IsInvocable< Reduce< Add >, ResultOf< Loop< Norm< 2, 1 > >, X > >, IsInvocable< Sqrt, ResultOf< Reduce< Add >, ResultOf< Loop< Norm< 2, 1 > >, X > > > >, All< IsSatisfied<(P !=Q &&Q==0)>, IsInvocable< Loop< Norm< P, P > >, X >, IsInvocable< Reduce< Max >, ResultOf< Loop< Norm< P, P > >, X > > > > > = 0>
static constexpr auto	norm (X &&a)
	Calculates p-norms of a Tensor.
template<class XA , class XB , If< IsTensorish< RemoveReference< XA > > > = 0, If< IsTensorish< RemoveReference< XB > > > = 0, If< IsInvocable< Loop< NotEqual >, XA, XB > > = 0>
static constexpr auto	operator!= (XA &&a, XB &&b)
	Checks non-equality of two Tensors.
template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< IsTensorish< RA > > = 0, If< IsInvocable< View, XA > > = 0, If< IsTensorish< RB > > = 0, If< IsInvocable< View, XB > > = 0, If< IsInvocable< Conj, XA > > = 0, If< IsInvocable< TensorProduct, XA, ResultOf< Conj, XB > > > = 0>
static constexpr auto	outerProduct (XA &&a, XB &&b)
	Calculates the outer product of two Tensors.
template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< IsTensorish< RA > > = 0, If< IsTensorish< RB > > = 0, If< Not< All< IsInvocable< View, XA >, IsInvocable< View, XB > > > > = 0, If< IsInvocable< OuterProduct, XA &, XB & > > = 0>
static constexpr auto	outerProduct (XA &&a, XB &&b)
	Calculates the outer product of two Tensors.
template<Index... Ps, class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< View, X > > = 0, If< IsSatisfied<(sizeof...(Ps)==typename R::Dimension())> > = 0, If< IsSatisfied<(max(Ps...)< typename R::Dimension())> > = 0, If< IsUnique< Constant< Index, Ps >... > > = 0>
static constexpr auto	permute (X &&a)
	Permutes the indices of a Tensor.
template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< View, X > > = 0, If< IsSatisfied<(0==typename R::Dimension())> > = 0>
static constexpr auto	permute (X &&a)
	Permutes the indices of a Tensor.
template<Index... Ps, class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< Not< IsInvocable< View, X > > > = 0, If< IsInvocable< Permute< Ps... >, X & > > = 0>
static constexpr auto	permute (X &&a)
	Permutes the indices of a Tensor.
template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Plus >, X > > = 0>
static constexpr auto	operator+ (X &&a)
	operator for a Tensor
template<class XA , class XB , If< IsTensorish< RemoveReference< XA > > > = 0, If< IsTensorish< RemoveReference< XB > > > = 0, If< IsInvocable< Loop< Pow >, XA, XB > > = 0>
static constexpr auto	pow (XA &&a, XB &&b)
	Takes a Tensor element-wise to the power of another Tensor.
template<class X , class S , class R = RemoveReference<X>, If< IsTensorish< R > > = 0>
static void	print (X &&arg, S &&stream)
	Prints a Tensor to a stream.
template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Rcp >, X > > = 0>
static constexpr auto	rcp (X &&a)
	Calculates the element-wise reciprocal of a Tensor.
template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Real >, X > > = 0>
static constexpr auto	real (X &&a)
	Calculates element-wise the real part of a Tensor.
template<class F , Index... Is, class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< View, X > > = 0, If< IsSatisfied<(sizeof...(Is)<=typename R::Dimension())> > = 0, If< IsUnique< Constant< Index, Is >... > > = 0, If< IsSatisfied<(max(Is...)< typename R::Dimension())> > = 0, class E = ResultOf<X, typename R::Subscripts>, If< IsInvocable< F, E, E > > = 0, If< IsInvocable< F, decltype(F::template Identity< typename R::Type >()), E > >
static constexpr auto	reduce (X &&a)
	Reduces a Tensor's dimensions by performing an operation along some of its axes.
template<class F , class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< View, X > > = 0, class E = ResultOf<X, typename R::Subscripts>, If< IsInvocable< F, E, E > > = 0, If< IsInvocable< F, decltype(F::template Identity< typename R::Type >()), E > >
static constexpr auto	reduce (X &&a)
	Reduces a Tensor's dimensions by performing an operation along all of its axes.
template<class F , Index... Is, class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< Not< IsInvocable< View, X > > > = 0, If< IsInvocable< Reduce< F, Is... >, X & > > = 0>
static constexpr auto	reduce (X &&a)
	Reduces a Tensor's dimensions by performing an operation along some of its axes.
template<Size... Ns, class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< View, X > > = 0, If< IsSatisfied<(Sizes< Ns... >::size()==R::size())> >
static constexpr auto	reshape (X &&a)
	Reshapes a Tensor.
template<Bool... Rs, class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< View, X > > = 0, If< IsSatisfied<(sizeof...(Rs)==typename R::Dimension())> > = 0>
static constexpr auto	reverse (X &&a)
	Reverses a Tensor along specified axes.
template<Direction D, Size S = 1, class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsSatisfied<(D==Direction::Leftwards||D==Direction::Rightwards)> > = 0>
static constexpr auto	rotate (X &&a)
	Rotates the indices of a Tensor.
template<std::int64_t D = 0, class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Round< D > >, X > > = 0>
static constexpr auto	round (X &&a)
	Rounds a Tensor element-wise to a given number of digits after the decimal point.
template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsSatisfied<(R::Sizes::size()==1)> > = 0, If< IsInvocable< Reshape<>, X > > = 0>
static constexpr auto	scalar (X &&a)
	Casts a Tensor with one element to its Value class.
template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< IsTensorish< RA > > = 0, If< IsInvocable< View, XA > > = 0, If< IsTensorish< RB > > = 0, If< IsInvocable< View, XB > > = 0, If< IsSame< typename RA::Sizes, typename RB::Sizes > > = 0, If< IsInvocable< HadamardProduct, XA, XB > > = 0, If< IsInvocable< Reduce< Add >, ResultOf< HadamardProduct, XA, XB > > > = 0>
static constexpr auto	scalarProduct (XA &&a, XB &&b)
	Calculates the scalar product of two Tensors.
template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< IsTensorish< RA > > = 0, If< IsTensorish< RB > > = 0, If< Not< All< IsInvocable< View, XA >, IsInvocable< View, XB > > > > = 0, If< IsInvocable< ScalarProduct, XA &, XB & > > = 0>
static constexpr auto	scalarProduct (XA &&a, XB &&b)
	Calculates the scalar product of two Tensors.
template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< IsTensorish< RA > > = 0, If< IsTensorish< RB > > = 0, class DA = typename RA::Dimension, class DB = typename RB::Dimension, If< IsSatisfied<(DA()==0||DB()==0)> > = 0, If< IsInvocable< TensorProduct, XA, XB > > = 0>
static constexpr auto	operator* (XA &&a, XB &&b)
	Mutliplies a Tensor by a Tensor with one element.
template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< IsTensorish< RA > > = 0, If< IsTensorish< RB > > = 0, class DA = typename RA::Dimension, class DB = typename RB::Dimension, If< IsSatisfied<(DA()==0 &&DB() !=0)> > = 0, If< IsInvocable< Div, decltype(unit< typename RB::template ChangeType< typename RA::Type > >(declval< XA >()())), XB > >
static constexpr auto	operator/ (XA &&a, XB &&b)
	Divides a Tensor with one element by a Tensor.
template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< IsTensorish< RA > > = 0, If< Any< IsValue< RB >, IsComplex< RB > > > = 0, If< IsInvocable< Mul, XA, decltype(unit< Tensor< RB > >(declval< XB >()))> >
static constexpr auto	operator* (XA &&a, XB &&b)
	Mutliplies a Tensor by a Value.
template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< IsTensorish< RA > > = 0, If< Any< IsValue< RB >, IsComplex< RB > > > = 0, If< IsInvocable< Div, XA, decltype(unit< Tensor< RB > >(declval< XB >()))> >
static constexpr auto	operator/ (XA &&a, XB &&b)
	Divides a Tensor by a Value.
template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Sign >, X > > = 0>
static constexpr auto	sign (X &&a)
	Calculates the element-wise sign of a Tensor.
template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Sin >, X > > = 0>
static constexpr auto	sin (X &&a)
	Calculates the element-wise sine of a Tensor.
template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Sinh >, X > > = 0>
static constexpr auto	sinh (X &&a)
	Calculates the element-wise hyperbolic sine of a Tensor.
template<Size... Es, class X , class... Os, class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< View, X > > = 0, If< All< IsConvertible< Os, Index >... > > = 0, If< IsSatisfied<(sizeof...(Es)==typename R::Dimension())> > = 0, If< IsSatisfied<(sizeof...(Os)==typename R::Dimension())> > = 0, If< IsSatisfied<(Sizes< Es... >()<=typename R::Sizes())> >
static constexpr auto	slice (X &&a, Os const ... offsets)
	Returns a specified slice of a Tensor.
template<Size... Es, class X , class... Os, class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< Not< IsInvocable< View, X > > > = 0, If< IsInvocable< Slice< Es... >, X &, Os... > > = 0>
static constexpr auto	slice (X &&a, Os const ... offsets)
	Returns a specified slice of a Tensor.
template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Sqrt >, X > > = 0>
static constexpr auto	sqrt (X &&a)
	Calculates the element-wise square root of a Tensor.
template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Square >, X > > = 0>
static constexpr auto	square (X &&a)
	Calculates the element-wise square of a Tensor.
template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0>
static constexpr auto	squeeze (X &&a)
	Remove axes with mode size 1 from a Tensor.
template<Size... Ss, class X , class... Os, class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< View, X > > = 0, If< All< IsConvertible< Os, Index >... > > = 0, If< IsSatisfied<(sizeof...(Ss)==typename R::Dimension())> > = 0, If< IsSatisfied<(sizeof...(Os)==typename R::Dimension())> > = 0, If< IsSatisfied<(typename R::Sizes() % Sizes< Ss... >()==Constant< Size, 0 >())> >
static constexpr auto	stride (X &&a, Os const ... offsets)
	Constructs a Tensor by taking equally-sized steps through the input Tensor.
template<Size... Ss, class X , class... Os, class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< Not< IsInvocable< View, X > > > = 0, If< IsInvocable< Stride< Ss... >, X &, Os... > > = 0>
static constexpr auto	stride (X &&a, Os const ... offsets)
	Splits a Tensor into equal sized blocks and returns one of them.
template<class XA , class XB , If< IsTensorish< RemoveReference< XA > > > = 0, If< IsTensorish< RemoveReference< XB > > > = 0, If< IsInvocable< Loop< Sub >, XA, XB > > = 0>
static constexpr auto	operator- (XA &&a, XB &&b)
	Subtraction of two Tensors.
template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< IsTensorish< RA > > = 0, If< IsInvocable< View, XA > > = 0, If< IsTensorish< RB > > = 0, If< IsInvocable< View, XB > > = 0, If< IsSame< typename RA::Sizes, typename RB::Sizes > > = 0, class EA = ResultOf<XA, typename RA::Subscripts>, class EB = ResultOf<XB, typename RB::Subscripts>, If< IsInvocable< Swap, EA, EB > > = 0>
static constexpr auto	swap (XA &&a, XB &&b)
	Swaps two Tensors.
template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Tan >, X > > = 0>
static constexpr auto	tan (X &&a)
	Calculates the element-wise tangent of a Tensor.
template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Tanh >, X > > = 0>
static constexpr auto	tanh (X &&a)
	Calculates the element-wise tangent hyperbolicus of a Tensor.
template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< IsTensorish< RA > > = 0, If< IsInvocable< View, XA > > = 0, If< IsTensorish< RB > > = 0, If< IsInvocable< View, XB > > = 0, class EA = ResultOf<XA, typename RA::Subscripts>, class EB = ResultOf<XB, typename RB::Subscripts>, If< IsInvocable< Mul, EA, EB > > = 0>
static constexpr auto	tensorProduct (XA &&a, XB &&b)
	Calculates the tensor product of two Tensors.
template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< IsTensorish< RA > > = 0, If< IsTensorish< RB > > = 0, If< Not< All< IsInvocable< View, XA >, IsInvocable< View, XB > > > > = 0, If< IsInvocable< TensorProduct, XA &, XB & > > = 0>
static constexpr auto	tensorProduct (XA &&a, XB &&b)
	Calculates the tensor product of two Tensors.
template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Trunc >, X > > = 0>
static constexpr auto	trunc (X &&a)
	Truncates element-wise the fractional part of a Tensor.
template<Index K, class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsSatisfied<(typename R::Dimension{} > 1)> , If< IsSatisfied<(K+1< typename R::Dimension{})> > = 0, If< IsInvocable< Reshape< R::size(K), R::Sizes::size()/R::size(K)>, X > > = 0>
static constexpr auto	unfolding (X &&a)
	Reshapes a Tensor into a matrix.
template<class X , If< IsTensorView< RemoveReference< X > > > = 0>
static constexpr X	view (X &&a)
	Returns a TensorView obtained from a TensorView.
template<class T , Size... Ns>
static constexpr auto	view (Tensor< T, Ns... > const &a)
	Returns a TensorView obtained from a const Tensor.
template<class T , Size... Ns>
static constexpr auto	view (Tensor< T, Ns... > &a)
	Returns a TensorView obtained from a Tensor.
template<class T , Size... Ns>
static constexpr auto	view (Tensor< T, Ns... > const &&)=delete
	A TensorView can not be created from an rvalue Tensor.
template<class XE , class XA , class XB , If< IsTensorish< RemoveReference< XE > > > = 0, If< IsTensorish< RemoveReference< XA > > > = 0, If< IsTensorish< RemoveReference< XB > > > = 0, If< IsInvocable< Loop< Where >, XE, XA, XB > > = 0>
static constexpr auto	where (XE &&e, XA &&a, XB &&b)
	Uses a mask to choose element-wise which of two Tensors' element to return.
template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< View, X > > = 0, If< IsInvocable< Transpose, X > > = 0, If< IsInvocable< Conj, ResultOf< Transpose, X > > > = 0>
static constexpr auto	adjoint (X &&a)
	Calculates the adjoint of a Tensor.
template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< Not< IsInvocable< View, X > > > = 0, If< IsInvocable< Adjoint, X & > > = 0>
static constexpr auto	adjoint (X &&a)
	Calculates the adjoint of a Tensor.
template<Operator::Transform OT = Operator::Transform::None, Operator::Restrict OR = Operator::Restrict::None, Operator::Hint OH = Operator::Hint::None, class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< IsTensorish< RA > > = 0, If< IsInvocable< View, XA > > = 0, If< IsTensorish< RB > > = 0, If< IsInvocable< View, XB > > = 0, class DA = typename RA::Dimension, class DB = typename RB::Dimension, If< IsSatisfied<(isEven(DA()) &&(DA()/2==DB()||DA()==DB()))> > = 0, If< IsInvocable< Transform< OT >, XA > > = 0, If< IsInvocable< Mul, ResultOf< Restrict< OR >, ResultOf< Transform< OT >, XA > >, XB > > = 0>
static constexpr auto	apply (XA &&a, XB &&b)
	Applies a (possibly transformed and restricted) Tensor to a Tensor.
template<Operator::Transform OT = Operator::Transform::None, Operator::Restrict OR = Operator::Restrict::None, Operator::Hint OH = Operator::Hint::None, class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< IsTensorish< RA > > = 0, If< IsTensorish< RB > > = 0, If< Not< All< IsInvocable< View, XA >, IsInvocable< View, XB > > > > = 0, If< IsInvocable< Apply< OT, OR, OH >, XA &, XB & > > = 0>
static constexpr auto	apply (XA &&a, XB &&b)
	Applies a (possibly transformed and restricted) Tensor to a Tensor.
template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< View, X > > = 0, If< IsSatisfied<(isEven(typename R::Dimension()))> > = 0>
static constexpr auto	diagonal (X &&a)
	Transforms a Tensor into diagonal form.
template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< View, X > > = 0, If< IsSatisfied<(isEven(typename R::Dimension()))> > = 0>
static constexpr auto	extractDiagonal (X &&a)
	Extracts the diagonal of a Tensor.
template<Size... Ds, class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< View, X > > = 0, If< IsSatisfied<(isEven(sizeof...(Ds)))> > = 0, If< IsSatisfied<(sizeof...(Ds)/2==typename R::Dimension())> > = 0, If< IsSatisfied<(cut< 2, 0 >(Sizes< Ds... >()) >=typename R::Sizes())> , If< IsSatisfied<(cut< 2, 1 >(Sizes< Ds... >()) >=typename R::Sizes())> >
static constexpr auto	fromDiagonal (X &&a)
	Constructs a diagonal Tensor with given Sizes from a Tensor containing the diagonal.
template<Size... Ds, class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< Not< IsInvocable< View, X > > > = 0, If< IsInvocable< FromDiagonal< Ds... >, X & > > = 0>
static constexpr auto	fromDiagonal (X &&a)
	Constructs a diagonal Tensor with given Sizes from a Tensor containing the diagonal.
template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0>
static constexpr auto	fromDiagonal (X &&a)
	Constructs a diagonal Tensor from a Tensor containing the diagonal.
template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< Diagonal, X > > = 0, If< IsInvocable< IsApprox, ResultOf< Diagonal, X >, X > > = 0, class TT = typename R::Value>
static constexpr auto	isDiagonal (X &&a, TT const &tolerance=NumericLimits< TT >::tolerance())
	Checks if a Tensor is diagonal.
template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< LowerTriangular, X > > = 0, If< IsInvocable< IsApprox, ResultOf< LowerTriangular, X >, X > > = 0, class TT = typename R::Value>
static constexpr auto	isLowerTriangular (X &&a, TT const &tolerance=NumericLimits< TT >::tolerance())
	Checks if a Tensor is lower triangular.
template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< OffDiagonal, X > > = 0, If< IsInvocable< IsApprox, ResultOf< OffDiagonal, X >, X > > = 0, class TT = typename R::Value>
static constexpr auto	isOffDiagonal (X &&a, TT const &tolerance=NumericLimits< TT >::tolerance())
	Checks if a Tensor is off-diagonal.
template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< Adjoint, X > > = 0, If< IsInvocable< IsApprox, ResultOf< Adjoint, X >, X > > = 0, class TT = typename R::Value>
static constexpr auto	isSelfAdjoint (X &&a, TT const &tolerance=NumericLimits< TT >::tolerance())
	Checks if a Tensor is self-adjoint.
template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< StrictlyLowerTriangular, X > > = 0, If< IsInvocable< IsApprox, ResultOf< StrictlyLowerTriangular, X >, X > > = 0, class TT = typename R::Value>
static constexpr auto	isStrictlyLowerTriangular (X &&a, TT const &tolerance=NumericLimits< TT >::tolerance())
	Checks if a Tensor is strictly lower triangular.
template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< StrictlyUpperTriangular, X > > = 0, If< IsInvocable< IsApprox, ResultOf< StrictlyUpperTriangular, X >, X > > = 0, class TT = typename R::Value>
static constexpr auto	isStrictlyUpperTriangular (X &&a, TT const &tolerance=NumericLimits< TT >::tolerance())
	Checks if a Tensor is strictly upper triangular.
template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< Transpose, X > > = 0, If< IsInvocable< IsApprox, ResultOf< Transpose, X >, X > > = 0, class TT = typename R::Value>
static constexpr auto	isSymmetric (X &&a, TT const &tolerance=NumericLimits< TT >::tolerance())
	Checks if a Tensor is symmetric.
template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< UnitLowerTriangular, X > > = 0, If< IsInvocable< IsApprox, ResultOf< UnitLowerTriangular, X >, X > > = 0, class TT = typename R::Value>
static constexpr auto	isUnitLowerTriangular (X &&a, TT const &tolerance=NumericLimits< TT >::tolerance())
	Checks if a Tensor is unit lower triangular.
template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< UnitUpperTriangular, X > > = 0, If< IsInvocable< IsApprox, ResultOf< UnitUpperTriangular, X >, X > > = 0, class TT = typename R::Value>
static constexpr auto	isUnitUpperTriangular (X &&a, TT const &tolerance=NumericLimits< TT >::tolerance())
	Checks if a Tensor is unit upper triangular.
template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< Adjoint, X > > = 0, If< IsInvocable< IsApprox, ResultOf< Mul, ResultOf< Adjoint, X >, X >, ResultOf< Mul, ResultOf< Adjoint, X >, X > > > = 0, class TT = typename R::Value>
static constexpr auto	isUnitary (X &&a, TT const &tolerance=NumericLimits< TT >::tolerance())
	Checks if a Tensor is unitary.
template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< UpperTriangular, X > > = 0, If< IsInvocable< IsApprox, ResultOf< UpperTriangular, X >, X > > = 0, class TT = typename R::Value>
static constexpr auto	isUpperTriangular (X &&a, TT const &tolerance=NumericLimits< TT >::tolerance())
	Checks if a Tensor is upper triangular.
template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< View, X > > = 0, If< IsSatisfied<(typename R::Dimension()==2)> > = 0>
static constexpr auto	lowerTriangular (X &&a)
	Transforms a Tensor into lower triangular form.
template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsSatisfied<(typename R::Dimension{} > 0)> , If< IsSatisfied<(isEven(typename R::Dimension()))> > = 0>
static constexpr auto	matricize (X &&a)
	Reshapes a Tensor into a matrix (a 2-dimensional Tensor)
template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< IsTensorish< RA > > = 0, If< IsTensorish< RB > > = 0, class DA = typename RA::Dimension, class DB = typename RB::Dimension, class SA = typename RA::Sizes, class SB = typename RB::Sizes, If< IsSatisfied<(isEven(DA()) &&DA()/2==DB())> > = 0, If< IsSame< decltype(cut< 2, 1 >(SA())), SB > , If< IsInvocable< Contract< DB{}, 0 >, XA, XB > > = 0>
static constexpr auto	operator* (XA &&a, XB &&b)
	Calculates an Operator-by-Tensor product.
template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< View, X > > = 0, If< IsSatisfied<(typename R::Dimension()==2)> > = 0>
static constexpr auto	offDiagonal (X &&a)
	Transforms a Tensor into off-diagonal form.
template<Operator::Restrict OR = Operator::Restrict::None, class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0>
static constexpr decltype(auto)	restrict (X &&a)
	Applies a restriction to a Tensor.
template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< View, X > > = 0, If< IsSatisfied<(typename R::Dimension()==2)> > = 0>
static constexpr auto	strictlyLowerTriangular (X &&a)
	Transforms a Tensor into strictly lower triangular form.
template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< View, X > > = 0, If< IsSatisfied<(typename R::Dimension()==2)> > = 0>
static constexpr auto	strictlyUpperTriangular (X &&a)
	Transforms a Tensor into strictly upper triangular form.
template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< View, X > > = 0, If< IsInvocable< ExtractDiagonal, X > > = 0, If< IsInvocable< Reduce< Add >, ResultOf< ExtractDiagonal, X > > > = 0>
static constexpr auto	trace (X &&a)
	Calculates the trace of a Tensor.
template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< Not< IsInvocable< View, X > > > = 0, If< IsInvocable< Trace, X & > > = 0>
static constexpr auto	trace (X &&a)
	Calculates the trace of a Tensor.
template<Operator::Transform OT = Operator::Transform::None, class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0>
static constexpr decltype(auto)	transform (X &&a)
	Applies a transformation to a Tensor.
template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsSatisfied<(isEven(typename R::Dimension()))> > = 0>
static constexpr auto	transpose (X &&a)
	Calculates the transposed of a Tensor.
template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< View, X > > = 0, If< IsSatisfied<(typename R::Dimension()==2)> > = 0>
static constexpr auto	unitLowerTriangular (X &&a)
	Transforms a Tensor into unit lower triangular form.
template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< View, X > > = 0, If< IsSatisfied<(typename R::Dimension()==2)> > = 0>
static constexpr auto	unitUpperTriangular (X &&a)
	Transforms a Tensor into unit upper triangular form.
template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< View, X > > = 0, If< IsSatisfied<(typename R::Dimension()==2)> > = 0>
static constexpr auto	upperTriangular (X &&a)
	Transforms a Tensor into upper triangular form.
template<class F , class T , Size... Ns>
	Tensor (TensorViews::View< T, Sizes< Ns... >, F > const &) -> Tensor< T, Ns... >
template<class X , class T , class N , class F >
static constexpr auto	isTensorView (TensorViews::View< T, N, F > const &&)
template<class >
static constexpr auto	isTensorView (...)
static constexpr auto	isnan (BFloat16 const a)
	Float (Float< 16 >::Fundamental const) -> Float< 16 >
	Float (Float< 32 >::Fundamental const) -> Float< 32 >
	Float (Float< 64 >::Fundamental const) -> Float< 64 >
template<class T , If< IsValue< T > > = 0, If< IsSatisfied<(typename T::Signed()==true)> > = 0>
static constexpr auto	abs (T const &a)
	Calculates the absolute value of a signed pRC value type.
template<class XA , class XB , If< IsInvocable< Sub, XA, XB > > = 0, If< IsInvocable< Norm<>, ResultOf< Sub, XA, XB > > > = 0, If< IsInvocable< Eval, ResultOf< Norm<>, ResultOf< Sub, XA, XB > > > > = 0>
static constexpr auto	absoluteError (XA &&a, XB &&b)
	Calculates the absolute error of two pRC objects.
template<class T , If< IsFloat< T > > = 0>
static constexpr auto	acos (T const &a)
	Calculates the arcus cosine of a Float.
template<class T , If< IsFloat< T > > = 0>
static constexpr auto	acosh (T const a)
	Calculates the hyperbolic area cosine of a Float.
template<class TA , class TB , If< IsFloat< TA > > = 0, If< IsFloat< TB > > = 0>
static constexpr auto	operator+ (TA const &a, TB const &b)
	Calculates the sum of two Floats.
template<class T , If< IsFloat< T > > = 0>
static constexpr auto	arg (T const &a)
	Calculates the argument of a Float.
template<class T , If< IsFloat< T > > = 0>
static constexpr auto	asin (T const &a)
	Calculates the arcus sine of a Float.
template<class T , If< IsFloat< T > > = 0>
static constexpr auto	asinh (T const &a)
	Calculates the hyperbolic area sine of a Float.
template<class T , If< IsFloat< T > > = 0>
static constexpr auto	atan (T const &a)
	Calculates the arcus tangent of a Float.
template<class Y , class X , If< IsFloat< Y > > = 0, If< IsFloat< X > > = 0>
static constexpr auto	atan2 (Y const &y, X const &x)
	Calculates the atan2 of two Float coordinates.
template<class T , If< IsFloat< T > > = 0>
static constexpr auto	atanh (T const &a)
	Calculates the hyperbolic area tangent of a Float.
template<class C , If< IsValue< C > > = 0, class T , If< IsValue< T > > = 0, If< IsConstructible< C, typename T::Fundamental > > = 0>
static constexpr auto	cast (T const &a)
	Casts a pRC value to a different pRC value.
template<class T , If< IsFloat< T > > = 0>
static constexpr auto	ceil (T const a)
	Calculates the ceiling of a Float.
template<class T , If< IsValue< T > > = 0, If< IsConstructible< Complex< T >, T > > = 0>
static constexpr auto	complexify (T const &a)
	Casts a Float to a Complex<Float>
template<class T , If< IsValue< T > > = 0>
static constexpr auto	conj (T const &a)
	Calculates the complex conjugate of a pRC value type.
template<class T , If< IsFloat< T > > = 0>
static constexpr auto	cos (T const a)
	Calculates the cosine of a Float.
template<class T , If< IsFloat< T > > = 0>
static constexpr auto	cosh (T const &a)
	Calculates the hyperbolic cosine of a Float.
template<class TA , class TB , If< IsValue< TA > > = 0, If< IsValue< TB > > = 0, If< None< IsUnsignedInteger< TA >, IsUnsignedInteger< TB > > > = 0>
static constexpr auto	delta (TA const &a, TB const &b)
	Calculates the absolute difference of two signed pRC value types.
template<class TA , class TB , If< IsFloat< TA > > = 0, If< IsFloat< TB > > = 0>
static constexpr auto	operator/ (TA const &a, TB const &b)
	Calculates the division of two Floats.
template<class TA , class TB , If< IsValue< TA > > = 0, If< IsValue< TB > > = 0, If< Any< IsFloat< TA >, IsFloat< TB > > > = 0>
static constexpr auto	operator== (TA const &a, TB const &b)
	Checks whether two Floats are equal.
template<class TA , class TB , If< IsInteger< TA > > = 0, If< IsInteger< TB > > = 0>
static constexpr auto	operator== (TA const &a, TB const &b)
	Checks whether two Integers are equal.
template<class X , If< IsBool< RemoveReference< X > > > = 0>
static constexpr X	eval (X &&a)
	Evaluates a Bool.
template<class T , If< IsFloat< T > > = 0>
static constexpr auto	exp (T const &a)
	Calculates the exponential of a Float.
template<class T , If< IsFloat< T > > = 0>
static constexpr auto	floor (T const &a)
	Calculates the floor of a Float.
template<class TA , class TB , If< IsFloat< TA > > = 0, If< IsFloat< TB > > = 0>
static constexpr auto	fmod (TA const &a, TB const &b)
	Calculates the floating-point remainder of an integer division for two Floats.
template<class F , Bool E = false, Direction D = Direction::Forwards, If< IsSatisfied<(D==Direction::Forwards||D==Direction::Backwards)> > = 0, class XA , If< IsInvocable< F, XA, XA > > = 0>
static constexpr Conditional< IsSatisfied< E >, decltype(eval(declval< XA >())), XA >	fold (XA &&a)
	Repeatedly applies an operation to generate one pRC object out of many.
template<class F , Bool E = false, Direction D = Direction::Forwards, If< IsSatisfied<(D==Direction::Forwards||D==Direction::Backwards)> > = 0, class XA , class XB , If< IsInvocable< F, XA, XB > > = 0>
static constexpr auto	fold (XA &&a, XB &&b)
	Repeatedly applies an operation to generate one pRC object out of many.
template<class F , Bool E = false, Direction D = Direction::Forwards, class XA , class XB , class... Xs, If< IsSatisfied<(sizeof...(Xs) > 0)> , If< IsSatisfied<(D==Direction::Forwards||D==Direction::Backwards)> > = 0, If< IsInvocable< F, XA, XB > > = 0, If< IsInvocable< Fold< F, E, D >, ResultOf< Fold< F, E, D >, XA, XB > const &, Xs... > > = 0>
static constexpr auto	fold (XA &&a, XB &&b, Xs &&...args)
	Repeatedly applies an operation to generate one pRC object out of many.
template<class TA , class TB , If< IsValue< TA > > = 0, If< IsValue< TB > > = 0>
static constexpr auto	operator> (TA const &a, TB const &b)
	Checks whether a pRC value is greater than another pRC value.
template<class TA , class TB , If< IsValue< TA > > = 0, If< IsValue< TB > > = 0>
static constexpr auto	operator>= (TA const &a, TB const &b)
	Checks whether a pRC value is greater than or equal to another pRC value.
template<class T , If< IsValue< T > > = 0>
static constexpr auto	imag (T const)
	Calculates the imaginary part of a pRC value.
template<class TA , class TB , If< IsValue< TA > > = 0, If< IsValue< TB > > = 0>
static constexpr auto	innerProduct (TA const &a, TB const &b)
	Calculates the inner product of two pRC values.
template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, class TT = Common<typename RA::Value, typename RB::Value>, class T = Common<typename RA::Value, typename RB::Value, TT>, If< IsValue< TT > > = 0, If< IsInvocable< AbsoluteError, XA, XB > > = 0, If< IsInvocable< Norm<>, XA > > = 0, If< IsInvocable< Norm<>, XB > > = 0, If< IsConstructible< T, ResultOf< AbsoluteError, XA, XB > > > = 0, If< IsConstructible< T, ResultOf< Norm<>, XA > > > = 0, If< IsConstructible< T, ResultOf< Norm<>, XB > > > = 0>
static constexpr auto	isApprox (XA &&a, XB &&b, TT const &tolerance=NumericLimits< TT >::tolerance())
	Checks if two pRC objects agree up to a given tolerance.
template<class X , class R = RemoveReference<X>, class TT = typename R::Value, If< IsValue< TT > > = 0, If< IsDefined< Identity< R > > > = 0, If< IsInvocable< Identity< R > > > = 0, If< IsInvocable< AbsoluteError, X, R > > = 0>
static constexpr auto	isIdentity (X &&a, TT const &tolerance=NumericLimits< TT >::tolerance())
	Checks if a pRC object agrees with identity up to a given absolute tolerance.
template<class T , If< IsFloat< T > > = 0>
static constexpr auto	isNaN (T const &a)
	Checks if a Float is NaN.
template<class X , class R = RemoveReference<X>, class TT = typename R::Value, If< IsValue< TT > > = 0, If< IsDefined< Unit< R > > > = 0, If< IsInvocable< Unit< R > > > = 0, If< IsInvocable< AbsoluteError, X, R > > = 0>
static constexpr auto	isUnit (X &&a, TT const &tolerance=NumericLimits< TT >::tolerance())
	Checks if a pRC object agrees with unit up to a given absolute tolerance.
template<class X , class R = RemoveReference<X>, class TT = typename R::Value, If< IsValue< TT > > = 0, If< IsDefined< Zero< R > > > = 0, If< IsInvocable< Zero< R > > > = 0, If< IsInvocable< AbsoluteError, X, R > > = 0>
static constexpr auto	isZero (X &&a, TT const &tolerance=NumericLimits< TT >::tolerance())
	Checks if a pRC object agrees with zero up to a given absolute tolerance.
template<class TA , class TB , If< IsValue< TA > > = 0, If< IsValue< TB > > = 0, If< Any< IsFloat< TA >, IsFloat< TB > > > = 0>
static constexpr auto	operator< (TA const &a, TB const &b)
	Checks whether a pRC value is less than another pRC value.
template<class TA , class TB , If< IsInteger< TA > > = 0, If< IsInteger< TB > > = 0>
static constexpr auto	operator< (TA const &a, TB const &b)
	Checks whether an Integer is less than another Integer.
template<class TA , class TB , If< IsValue< TA > > = 0, If< IsValue< TB > > = 0>
static constexpr auto	operator<= (TA const &a, TB const &b)
	Checks whether a pRC value is less than or equal to another pRC value.
template<class T , If< IsFloat< T > > = 0>
static constexpr auto	log (T const &a)
	Calculates the natural (base e) logarithm of a Float.
template<class T , If< IsFloat< T > > = 0>
static constexpr auto	log10 (T const &a)
	Calculates the base 10 logarithm of a Float.
template<class T , If< IsFloat< T > > = 0>
static constexpr auto	log2 (T const &a)
	Calculates the base 2 logarithm of a Float.
template<class... Xs, If< IsInvocable< Fold< Add >, Xs... > > = 0>
static constexpr auto	mean (Xs &&...args)
	Calculates the mean of a variable ammount of pRC objects.
template<class T , If< IsValue< T > > = 0>
static constexpr auto	operator- (T const &a)
	Calculates the negative of a pRC value.
template<class TA , class TB , If< IsInteger< TA > > = 0, If< IsInteger< TB > > = 0>
static constexpr auto	operator% (TA const &a, TB const &b)
	Calculates the modulus of an integer division of two Integers.
template<class TA , class TB , If< IsFloat< TA > > = 0, If< IsFloat< TB > > = 0>
static constexpr auto	operator* (TA const &a, TB const &b)
	Calculates the product of two Floats.
template<Index P = 2, Index Q = P, class T , If< IsValue< T > > = 0>
static constexpr auto	norm (T const &a)
	Calculates p-norms of a pRC value.
template<class TA , class TB , If< IsValue< TA > > = 0, If< IsValue< TB > > = 0>
static constexpr auto	operator!= (TA const &a, TB const &b)
	Checks whether two pRC values are not equal.
template<class T , If< IsFloat< T > > = 0>
static constexpr T	pi ()
	Returns pi as a Float.
template<class T , If< IsInteger< T > > = 0>
static constexpr auto	pi ()
	Returns pi as a Float.
template<class T , If< IsValue< T > > = 0>
static constexpr auto	operator+ (T const &a)
	operator for a pRC value
template<class B , class N , If< IsFloat< B > > = 0, If< IsFloat< N > > = 0>
static constexpr auto	pow (B const &base, N const &exp)
	Calculates a Float to the power of another Float.
template<class T , If< IsFloat< T > > = 0>
static auto	print (T const &value, std::FILE *stream)
	Prints a Float to a C stream.
template<class T , If< IsValue< T > > = 0>
static constexpr auto	rcp (T const &a)
	Calculates the reciprocal of a pRC value.
template<class X , If< IsValue< RemoveReference< X > > > = 0>
static constexpr X	real (X &&a)
	Calculates the real part of a pRC value.
template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< IsFloat< typename RA::Value > > = 0, If< IsFloat< typename RB::Value > > = 0, If< IsInvocable< AbsoluteError, XA, XB > > = 0, If< IsInvocable< Norm<>, XA > > = 0, If< IsInvocable< Div, ResultOf< AbsoluteError, XA, XB >, ResultOf< Norm<>, XA > > > = 0>
static constexpr auto	relativeError (XA &&a, XB &&b)
	Calculates the relative error of a pRC object from another pRC object.
template<std::int64_t D = 0, class T , If< IsFloat< T > > = 0>
static constexpr auto	round (T const &a)
	Rounds a Float to a given number of digits after the decimal point.
template<class TA , class TB , If< IsValue< TA > > = 0, If< IsValue< TB > > = 0>
static constexpr auto	scalarProduct (TA const &a, TB const &b)
	Calculates the scalar product of two pRC values.
template<class T , If< IsValue< T > > = 0, If< IsSatisfied<(typename T::Signed()==true)> > = 0>
static constexpr auto	sign (T const &a)
	Calculates the sign of a signed pRC value type.
template<class T , If< IsFloat< T > > = 0>
static constexpr auto	sin (T const a)
	Calculates the sine of a Float.
template<class T , If< IsFloat< T > > = 0>
static constexpr auto	sinh (T const a)
	Calculates the hyperbolic sine of a Float.
template<class T , If< IsFloat< T > > = 0>
static constexpr auto	sqrt (T const &a)
	Calculates the square root of a Float.
template<class T , If< IsValue< T > > = 0>
static constexpr auto	square (T const &a)
	Calculates the square of a pRC value.
template<class TA , class TB , If< IsFloat< TA > > = 0, If< IsFloat< TB > > = 0>
static constexpr auto	operator- (TA const &a, TB const &b)
	Subtraction of two Floats.
template<class T , If< IsFloat< T > > = 0>
static constexpr auto	tan (T const a)
	Calculates the tangent of a Float.
template<class T , If< IsFloat< T > > = 0>
static constexpr auto	tanh (T const a)
	Calculates the hyperbolic tangent of a Float.
template<class T , If< IsFloat< T > > = 0>
static constexpr auto	trunc (T const &a)
	Truncates the fractional part of a Float.
	Integer (Integer< true, 8 >::Fundamental const) -> Integer< true, 8 >
	Integer (Integer< true, 16 >::Fundamental const) -> Integer< true, 16 >
	Integer (Integer< true, 32 >::Fundamental const) -> Integer< true, 32 >
	Integer (Integer< true, 64 >::Fundamental const) -> Integer< true, 64 >
	Integer (Integer< false, 8 >::Fundamental const) -> Integer< false, 8 >
	Integer (Integer< false, 16 >::Fundamental const) -> Integer< false, 16 >
	Integer (Integer< false, 32 >::Fundamental const) -> Integer< false, 32 >
	Integer (Integer< false, 64 >::Fundamental const) -> Integer< false, 64 >
template<Position P, class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsFloat< typename R::Value > > = 0, If< IsSatisfied<(P==Position::Left||P==Position::Right)> > = 0>
static constexpr auto	orthogonalize (X &&a)
template<Size C, Position P, class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, class V = typename R::Value, class VT = V, If< All< IsFloat< V >, IsFloat< VT > > > = 0, If< IsSatisfied<(P==Position::Left||P==Position::Right)> > = 0>
static constexpr auto	truncate (X &&a, VT const &tolerance=NumericLimits< VT >::epsilon())
template<class X , class R = RemoveReference<X>, If< Any< TensorTrain::IsTensorish< R >, TensorTrain::IsOperatorish< R > > > = 0, If< IsInvocable< Loop< Conj >, X > > = 0>
static constexpr auto	conj (X &&a)
template<class F , class... Xs, If< All< Any< TensorTrain::IsTensorish< RemoveReference< Xs > >, TensorTrain::IsOperatorish< RemoveReference< Xs > > >... > > = 0, If< All< IsInvocable< View, Xs >... > > = 0, If< IsSame< typename RemoveReference< Xs >::Dimension... > > = 0, If< True< decltype(declval< F >().template operator()<0 >(declval< Xs >().template core< 0 >()...))> >
static constexpr auto	enumerate (F &&f, Xs &&...args)
template<class F , class... Xs, If< All< Any< TensorTrain::IsTensorish< RemoveReference< Xs > >, TensorTrain::IsOperatorish< RemoveReference< Xs > > >... > > = 0, If< All< IsInvocable< View, Xs >... > > = 0, If< IsSame< typename RemoveReference< Xs >::Dimension... > > = 0, If< True< decltype(declval< F >().template operator()<0 >(declval< Xs >().template core< 0 >()...))> >
static constexpr auto	enumerate (Xs &&...args)
template<class F , class... Xs, If< All< Any< TensorTrain::IsTensorish< RemoveReference< Xs > >, TensorTrain::IsOperatorish< RemoveReference< Xs > > >... > > = 0, If< Not< All< IsInvocable< View, Xs >... > > > = 0, If< IsInvocable< Enumerate< F >, F, Xs &... > > = 0>
static constexpr auto	enumerate (F &&f, Xs &&...args)
template<class F , class... Xs, If< All< Any< TensorTrain::IsTensorish< RemoveReference< Xs > >, TensorTrain::IsOperatorish< RemoveReference< Xs > > >... > > = 0, If< Not< All< IsInvocable< View, Xs >... > > > = 0, If< IsInvocable< Enumerate< F >, Xs &... > > = 0>
static constexpr auto	enumerate (Xs &&...args)
template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< Any< All< TensorTrain::IsTensorish< RA >, TensorTrain::IsTensorish< RB > >, All< TensorTrain::IsOperatorish< RA >, TensorTrain::IsOperatorish< RB > > > > = 0, If< IsInvocable< Conj, XA > > = 0, If< IsInvocable< ScalarProduct, ResultOf< Conj, XA >, XB > > = 0>
static constexpr auto	innerProduct (XA &&a, XB &&b)
template<class F , class... Xs, If< All< Any< TensorTrain::IsTensorish< RemoveReference< Xs > >, TensorTrain::IsOperatorish< RemoveReference< Xs > > >... > > = 0, If< All< IsInvocable< View, Xs >... > > = 0, If< IsSame< typename RemoveReference< Xs >::Dimension... > > = 0, If< IsInvocable< F, decltype(declval< Xs >().template core< 0 >())... > >
static constexpr auto	loop (F &&f, Xs &&...args)
template<class F , class... Xs, If< All< Any< TensorTrain::IsTensorish< RemoveReference< Xs > >, TensorTrain::IsOperatorish< RemoveReference< Xs > > >... > > = 0, If< All< IsInvocable< View, Xs >... > > = 0, If< IsSame< typename RemoveReference< Xs >::Dimension... > > = 0, If< IsInvocable< F, decltype(declval< Xs >().template core< 0 >())... > >
static constexpr auto	loop (Xs &&...args)
template<class F , class... Xs, If< All< Any< TensorTrain::IsTensorish< RemoveReference< Xs > >, TensorTrain::IsOperatorish< RemoveReference< Xs > > >... > > = 0, If< Not< All< IsInvocable< View, Xs >... > > > = 0, If< IsInvocable< Loop< F >, F, Xs &... > > = 0>
static constexpr auto	loop (F &&f, Xs &&...args)
template<class F , class... Xs, If< All< Any< TensorTrain::IsTensorish< RemoveReference< Xs > >, TensorTrain::IsOperatorish< RemoveReference< Xs > > >... > > = 0, If< Not< All< IsInvocable< View, Xs >... > > > = 0, If< IsInvocable< Loop< F >, Xs &... > > = 0>
static constexpr auto	loop (Xs &&...args)
template<class X , class R = RemoveReference<X>, If< Any< TensorTrain::IsTensorish< R >, TensorTrain::IsOperatorish< R > > > = 0>
static constexpr auto	operator- (X &&a)
template<Index P = 2, Index Q = P, class X , class R = RemoveReference<X>, If< Any< TensorTrain::IsTensorish< R >, TensorTrain::IsOperatorish< R > > > = 0, If< IsSatisfied<(P==2 &&Q==2)> > = 0>
static constexpr auto	norm (X &&a)
template<class X , class R = RemoveReference<X>, If< Any< TensorTrain::IsTensorish< R >, TensorTrain::IsOperatorish< R > > > = 0, If< IsInvocable< Loop< Plus >, X > > = 0>
static constexpr auto	operator+ (X &&a)
template<class X , class S , class R = RemoveReference<X>, If< Any< TensorTrain::IsTensorish< R >, TensorTrain::IsOperatorish< R > > > = 0>
static void	print (X &&arg, S &&stream)
template<class Ranks , class X , class R = RemoveReference<X>, class V = typename R::Value, class VT = V, If< All< IsFloat< V >, IsFloat< VT > > > = 0, If< Any< TensorTrain::IsTensorish< R >, TensorTrain::IsOperatorish< R > > > = 0, If< IsSizes< Ranks > > = 0, If< IsSatisfied<(typename Ranks::Dimension()==typename R::Dimension() - 1)> > = 0>
static constexpr auto	round (X &&a, VT const &tolerance=NumericLimits< VT >::epsilon())
template<class X , class R = RemoveReference<X>, class V = typename R::Value, class VT = V, If< All< IsFloat< V >, IsFloat< VT > > > = 0, If< Any< TensorTrain::IsTensorish< R >, TensorTrain::IsOperatorish< R > > > = 0>
static constexpr auto	round (X &&a, VT const &tolerance=NumericLimits< VT >::epsilon())
template<Size C, class X , class R = RemoveReference<X>, class V = typename R::Value, class VT = V, If< All< IsFloat< V >, IsFloat< VT > > > = 0, If< Any< TensorTrain::IsTensorish< R >, TensorTrain::IsOperatorish< R > > > = 0>
static constexpr auto	round (X &&a, VT const &tolerance=NumericLimits< VT >::epsilon())
template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< Any< TensorTrain::IsTensorish< RA >, TensorTrain::IsOperatorish< RA > > > = 0, If< IsInvocable< View, XA > > = 0, If< Any< IsValue< RB >, IsComplex< RB > > > = 0, If< IsInvocable< Mul, typename RA::Type, RB const & > > = 0>
static constexpr auto	operator* (XA &&a, XB &&b)
template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< Any< TensorTrain::IsTensorish< RA >, TensorTrain::IsOperatorish< RA > > > = 0, If< IsInvocable< View, XA > > = 0, If< Any< IsValue< RB >, IsComplex< RB > > > = 0, If< IsInvocable< Div, typename RA::Type, RB const & > > = 0>
static constexpr auto	operator/ (XA &&a, XB &&b)
template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< Any< TensorTrain::IsTensorish< RA >, TensorTrain::IsOperatorish< RA > > > = 0, If< IsTensorish< RB > > = 0, If< IsInvocable< Mul, XA, typename RB::Type > > = 0>
static constexpr auto	operator* (XA &&a, XB &&b)
template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< Any< TensorTrain::IsTensorish< RA >, TensorTrain::IsOperatorish< RA > > > = 0, If< IsTensorish< RB > > = 0, If< IsInvocable< Div, XA, typename RB::Type > > = 0>
static constexpr auto	operator/ (XA &&a, XB &&b)
template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< Any< All< TensorTrain::IsTensorish< RA >, TensorTrain::IsTensorish< RB > >, All< TensorTrain::IsOperatorish< RA >, TensorTrain::IsOperatorish< RB > > > > = 0, If< IsInvocable< Minus, XB > > = 0, If< IsInvocable< Add, XA, ResultOf< Minus, XB > > > = 0>
static constexpr auto	operator- (XA &&a, XB &&b)
template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< TensorTrain::IsOperatorish< RA > > = 0, If< TensorTrain::IsOperatorish< RB > > = 0, If< IsSame< typename RA::Sizes, typename RB::Sizes > > = 0, If< HasCommon< typename RA::Type, typename RB::Type > > = 0>
static constexpr auto	operator+ (XA &&a, XB &&b)
template<class X , If< TensorTrain::IsOperatorish< RemoveReference< X > > > = 0, If< IsInvocable< View, X > > = 0, If< IsInvocable< Transpose, X > > = 0, If< IsInvocable< Conj, ResultOf< Transpose, X > > > = 0>
static constexpr auto	adjoint (X &&a)
template<class X , If< TensorTrain::IsOperatorish< RemoveReference< X > > > = 0, If< Not< IsInvocable< View, X > > > = 0, If< IsInvocable< Adjoint, X & > > = 0>
static constexpr auto	adjoint (X &&a)
template<Operator::Transform OT = Operator::Transform::None, Operator::Restrict OR = Operator::Restrict::None, Operator::Hint OH = Operator::Hint::None, class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< TensorTrain::IsOperatorish< RA > > = 0, If< IsInvocable< View, XA > > = 0, If< Any< TensorTrain::IsOperatorish< RB >, TensorTrain::IsTensorish< RB > > > = 0, If< IsInvocable< View, XB > > = 0, If< IsInvocable< Transform< OT >, XA > > = 0, If< IsInvocable< Mul, ResultOf< Restrict< OR >, ResultOf< Transform< OT >, XA > >, XB > > = 0>
static constexpr auto	apply (XA &&a, XB &&b)
template<Operator::Transform OT = Operator::Transform::None, Operator::Restrict OR = Operator::Restrict::None, Operator::Hint OH = Operator::Hint::None, class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< TensorTrain::IsOperatorish< RA > > = 0, If< Any< TensorTrain::IsOperatorish< RB >, TensorTrain::IsTensorish< RB > > > = 0, If< Not< All< IsInvocable< View, XA >, IsInvocable< View, XB > > > > = 0, If< IsInvocable< Apply< OT, OR, OH >, XA &, XB & > > = 0>
static constexpr auto	apply (XA &&a, XB &&b)
template<class X , class R = RemoveReference<X>, If< TensorTrain::IsOperatorish< R > > = 0, If< IsInvocable< View, X > > = 0>
static constexpr auto	backwards (X &&a)
template<class X , If< TensorTrain::IsOperator< RemoveReference< X > > > = 0>
static constexpr X	eval (X &&a)
template<class X , If< TensorTrain::IsOperatorView< RemoveReference< X > > > = 0>
static constexpr auto	eval (X &&a)
template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< TensorTrain::IsOperatorish< RA > > = 0, If< TensorTrain::IsOperatorish< RB > > = 0, If< IsSame< typename RA::Sizes, typename RB::Sizes > > = 0, If< IsInvocable< Mul, typename RA::Type, typename RB::Type > > = 0>
static constexpr auto	hadamardProduct (XA &&a, XB &&b)
template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< TensorTrain::IsOperatorish< RA > > = 0, If< IsInvocable< View, XA > > = 0, If< TensorTrain::IsTensorish< RB > > = 0, If< IsInvocable< View, XB > > = 0, If< IsSame< typename RA::N, typename RB::N > > = 0>
static constexpr auto	operator* (XA &&a, XB &&b)
template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< Any< TensorTrain::IsOperatorish< RA >, TensorTrain::IsTensorish< RA > > > = 0, If< Any< TensorTrain::IsOperatorish< RB >, TensorTrain::IsTensorish< RB > > > = 0, If< Not< All< IsInvocable< View, XA >, IsInvocable< View, XB > > > > = 0, If< IsInvocable< Mul, XA &, XB & > > = 0>
static constexpr auto	operator* (XA &&a, XB &&b)
template<Operator::Restrict OR = Operator::Restrict::None, class X , class R = RemoveReference<X>, If< TensorTrain::IsOperatorish< R > > = 0>
static constexpr decltype(auto)	restrict (X &&a)
template<class XA , class XB , If< TensorTrain::IsOperatorish< RemoveReference< XA > > > = 0, If< TensorTrain::IsOperatorish< RemoveReference< XB > > > = 0, If< IsInvocable< HadamardProduct, XA, XB > > = 0>
static constexpr auto	scalarProduct (XA &&a, XB &&b)
template<Operator::Transform OT = Operator::Transform::None, class X , class R = RemoveReference<X>, If< TensorTrain::IsOperatorish< R > > = 0>
static constexpr decltype(auto)	transform (X &&a)
template<class X , class R = RemoveReference<X>, If< TensorTrain::IsOperatorish< R > > = 0, If< IsInvocable< Loop< Permute< 0, 2, 1, 3 > >, X > > = 0>
static constexpr auto	transpose (X &&a)
template<class X , If< TensorTrain::IsOperatorView< RemoveReference< X > > > = 0>
static constexpr X	view (X &&a)
template<class T , class M , class N , class R >
static constexpr auto	view (TensorTrain::Operator< T, M, N, R > const &a)
template<class T , class M , class N , class R >
static constexpr auto	view (TensorTrain::Operator< T, M, N, R > &a)
template<class T , class M , class N , class R >
static constexpr auto	view (TensorTrain::Operator< T, M, N, R > const &&)=delete
template<class T , Size... Ms, Size... Ns, class R >
	Tensor (TensorTrain::Operator< T, Sizes< Ms... >, Sizes< Ns... >, R > const &) -> Tensor< T, Ms..., Ns... >
template<class T , Size... Ms, Size... Ns, class R , class F >
	Tensor (TensorTrain::OperatorViews::View< T, Sizes< Ms... >, Sizes< Ns... >, R, F > const &) -> Tensor< T, Ms..., Ns... >
template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< TensorTrain::IsTensorish< RA > > = 0, If< TensorTrain::IsTensorish< RB > > = 0, If< IsSame< typename RA::Sizes, typename RB::Sizes > > = 0, If< HasCommon< typename RA::Type, typename RB::Type > > = 0>
static constexpr auto	operator+ (XA &&a, XB &&b)
template<class X , class R = RemoveReference<X>, If< TensorTrain::IsTensorish< R > > = 0, If< IsInvocable< View, X > > = 0>
static constexpr auto	backwards (X &&a)
template<class X , If< TensorTrain::IsTensor< RemoveReference< X > > > = 0>
static constexpr X	eval (X &&a)
template<class X , If< TensorTrain::IsTensorView< RemoveReference< X > > > = 0>
static constexpr auto	eval (X &&a)
template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< TensorTrain::IsTensorish< RA > > = 0, If< TensorTrain::IsTensorish< RB > > = 0, If< IsSame< typename RA::Sizes, typename RB::Sizes > > = 0, If< IsInvocable< Mul, typename RA::Type, typename RB::Type > > = 0>
static constexpr auto	hadamardProduct (XA &&a, XB &&b)
template<class XA , class XB , If< TensorTrain::IsTensorish< RemoveReference< XA > > > = 0, If< TensorTrain::IsTensorish< RemoveReference< XB > > > = 0, If< IsInvocable< HadamardProduct, XA, XB > > = 0>
static constexpr auto	scalarProduct (XA &&a, XB &&b)
template<class X , If< TensorTrain::IsTensorView< RemoveReference< X > > > = 0>
static constexpr X	view (X &&a)
template<class T , class N , class R >
static constexpr auto	view (TensorTrain::Tensor< T, N, R > const &a)
template<class T , class N , class R >
static constexpr auto	view (TensorTrain::Tensor< T, N, R > &a)
template<class T , class N , class R >
static constexpr auto	view (TensorTrain::Tensor< T, N, R > const &&)=delete
template<class T , Size... Ns, class R >
	Tensor (TensorTrain::Tensor< T, Sizes< Ns... >, R > const &) -> Tensor< T, Ns... >
template<class T , Size... Ns, class R , class F >
	Tensor (TensorTrain::TensorViews::View< T, Sizes< Ns... >, R, F > const &) -> Tensor< T, Ns... >

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

Typedef Documentation

AddConst

template<class T >

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

All

template<class... Bs>

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

Any

template<class... Bs>

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

Array

template<class T , Size... Ns>

using pRC::Array = typedef Conditional< IsSatisfied<((Ns * ... * 1) * sizeof(T) > cHugepageSizeByte)>, HeapArray<T, Ns...>, StackArray<T, Ns...> >

Bool

using pRC::Bool = typedef bool

Common

template<class... Ts>

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

Conditional

template<class B , class T , class F >

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

Constant

template<class T , T V>

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

HasCommon

template<class... Ts>

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

HeapArray

template<class T , Size... Ns>

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

If

template<class B = True<>>

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

Index

using pRC::Index = typedef Size

IsAssignable

template<class T , class U = T>

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

IsBaseOf

template<class B , class D >

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

IsBool

template<class T >

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

IsConst

template<class T >

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

IsConstructible

template<class T , class... Args>

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

IsConvertible

template<class F , class T >

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

IsDefined

template<class T >

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

IsDetected

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

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

IsEnum

template<class T >

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

IsIndex

template<class T >

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

IsInteger

template<class T >

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

IsIntegral

template<class T >

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

IsInvocable

template<class F , class... Args>

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

IsInvocableResult

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

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

IsPointer

template<class T >

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

IsReference

template<class T >

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

IsSatisfied

template<Bool B>

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

IsSeed

template<class T >

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

IsSignedIntegral

template<class T >

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

IsSize

template<class T >

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

IsSizes

template<class T >

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

IsStandardLayout

template<class T >

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

IsSubscriptable

template<class T >

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

IsTensorish

template<class T >

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

IsUnsignedIntegral

template<class T >

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

IsValue

template<class T >

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

Mutex

using pRC::Mutex = typedef std::mutex

None

template<class... Bs>

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

Not

template<class B >

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

RandomEngine

using pRC::RandomEngine = typedef Threefry<20>

RemoveConst

template<class T >

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

RemoveConstReference

template<class T >

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

RemoveReference

template<class T >

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

ResultOf

template<class F , class... Args>

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

Seed

using pRC::Seed = typedef std::uint32_t

SignedInteger

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

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

Size

using pRC::Size = typedef std::size_t

Sizes

template<Size... Ns>

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

StackArray

template<class T , Size... Ns>

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

UnderlyingType

template<class T >

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

UnsignedInteger

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

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

Void

template<class... Ts>

using pRC::Void = typedef void

Enumeration Type Documentation

Allocation

enum class pRC::Allocation

strong

Enumerator
Stack
Heap

Context

enum class pRC::Context

strong

Enumerator
CompileTime
RunTime

DebugLevel

enum class pRC::DebugLevel

strong

Enumerator
None
Low
Mid
High

Direction

enum class pRC::Direction

strong

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

LogLevel

enum class pRC::LogLevel

strong

Enumerator
Error
Warning
Info
Debug
Trace

Position

enum class pRC::Position

strong

Enumerator
Left
Right
Front
Back

Function Documentation

abs() [1/3]

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

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

inlinestaticconstexpr

abs() [2/3]

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

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

inlinestaticconstexpr

Calculates the absolute value of a signed pRC value type.

Calculates the absolute value of an unsigned pRC value type.

Template Parameters

T	signed pRC value class (inferred)

Parameters

a	object of class T

This function just returns the input and is only implemented for consistency reasons.

Template Parameters

T	unsigned pRC value class (inferred)

Parameters

a	object of class T

abs() [3/3]

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

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

inlinestaticconstexpr

Calculates the element-wise absolute value of a Tensor.

Template Parameters

X	pRC tensorish class (inferred)

Parameters

a	object of class T

absoluteError()

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

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

inlinestaticconstexpr

Calculates the absolute error of two pRC objects.

The result is calculated through absoluteError(a, b)=|a-b|.

Template Parameters

XA	pRC object class (inferred)
XB	pRC object class (inferred)

Parameters

a	object of class XA
b	object of class XB

acos() [1/3]

template<class T >

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

inlinestaticconstexpr

acos() [2/3]

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

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

inlinestaticconstexpr

Calculates the arcus cosine of a Float.

Calculates the arcus cosine of an Integer.

Template Parameters

T	Float class (inferred)

Parameters

a	object of class T

Template Parameters

T	Integer class (inferred)

Parameters

a	object of class T

acos() [3/3]

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

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

inlinestaticconstexpr

Calculates element-wise arcus cosine of a Tensor.

Template Parameters

X	pRC tensorish class (inferred)

Parameters

a	object of class X

acosh() [1/3]

template<class T >

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

inlinestaticconstexpr

acosh() [2/3]

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

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

inlinestaticconstexpr

Calculates the hyperbolic area cosine of a Float.

Calculates the hyperbolic area cosine of an Integer.

Template Parameters

T	Float class (inferred)

Parameters

a	object of class T

Template Parameters

T	Integer class (inferred)

Parameters

a	object of class T

acosh() [3/3]

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

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

inlinestaticconstexpr

Calculates element-wise hyperbolic area cosine of a Tensor.

Template Parameters

X	pRC tensorish class (inferred)

Parameters

a	object of class X

adjoint() [1/5]

template<class T >

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

inlinestaticconstexpr

adjoint() [2/5]

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

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

inlinestaticconstexpr

Calculates the adjoint of a Tensor.

The adjoint is defined as the complex conjugate of the transposed Tensor. This means that the adjoint can only be calculated if the Tensor can be transposed.

Template Parameters

X	pRC tensorish class (inferred)

Parameters

a	object of class X

adjoint() [3/5]

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

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

inlinestaticconstexpr

Calculates the adjoint of a Tensor.

The adjoint is defined as the complex conjugate of the transposed Tensor. This means that the adjoint can only be calculated if the Tensor can be transposed.

This function is used if the argument can not be represented as a TensorView.

Template Parameters

X	pRC tensorish class (inferred)

Parameters

a	object of class X

adjoint() [4/5]

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

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

inlinestaticconstexpr

adjoint() [5/5]

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

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

inlinestaticconstexpr

alignment()

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

static constexpr auto pRC::alignment ( )

inlinestaticconstexpr

alloc()

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

inlinestatic

apply() [1/6]

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

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

inlinestaticconstexpr

apply() [2/6]

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

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

inlinestaticconstexpr

apply() [3/6]

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

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

inlinestaticconstexpr

Applies a (possibly transformed and restricted) Tensor to a Tensor.

This function first applies the transformation, then the restriction to the Tensor (note the order!). Afterwards, the obtained Tensor is multiplied with the Tensor (using an operator-by-tensor product).

Template Parameters

OT	enumerator from Operator::Transform (default is Operator::Transform::None)
OR	enumerator from Operator::Restrict (default is Operator::Restrict::None)
OH	enumerator from Operator::Hint (default is Operator::Hint::None)
XA	pRC tensorish class (inferred)
XB	pRC tensorish class (inferred)

Parameters

a	object of class XA
b	object of class XB

apply() [4/6]

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

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

inlinestaticconstexpr

Applies a (possibly transformed and restricted) Tensor to a Tensor.

This function first applies the transformation, then the restriction to the Tensor (note the order!). Afterwards, the obtained Tensor is multiplied with the Tensor (using an operator-by-tensor product).

This function is used if the argument can not be represented as a TensorView.

Template Parameters

OT	enumerator from Operator::Transform (default is Operator::Transform::None)
OR	enumerator from Operator::Restrict (default is Operator::Restrict::None)
OH	enumerator from Operator::Hint (default is Operator::Hint::None)
XA	pRC tensorish class (inferred)
XB	pRC tensorish class (inferred)

Parameters

a	object of class XA
b	object of class XB

apply() [5/6]

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

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

inlinestaticconstexpr

apply() [6/6]

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

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

inlinestaticconstexpr

arg() [1/3]

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

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

inlinestaticconstexpr

arg() [2/3]

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

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

inlinestaticconstexpr

Calculates the argument of a Float.

Calculates the argument of an Integer.

This function calculates the argument, as defined for complex numbers. Thus, it returns zero for non-negative inputs and pi for negative inputs.

Template Parameters

T	Float class (inferred)

Parameters

a	object of type T

This function calculates the argument, as defined for complex numbers. Thus, it returns zero for non-negative inputs and pi for negative inputs.

Template Parameters

T	Integer class (inferred)

Parameters

a	object of type T

arg() [3/3]

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

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

inlinestaticconstexpr

Returns the element-wise argument of a Tensor.

This function calculates the argument, as defined for complex numbers.

Template Parameters

X	pRC tensorish class (inferred)

Parameters

a	object of class X

asConst() [1/2]

template<class T >

AddConst< T > pRC::asConst

(

T &&

a

)

asConst() [2/2]

template<class T >

AddConst< T > & pRC::asConst

(

T &

a

)

asin() [1/3]

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

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

inlinestaticconstexpr

asin() [2/3]

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

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

inlinestaticconstexpr

Calculates the arcus sine of a Float.

Calculates the arcus sine of an Integer.

Template Parameters

T	Float class (inferred)

Parameters

a	object of class T

asin() [3/3]

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

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

inlinestaticconstexpr

Calculates element-wise arcus sine of a Tensor.

Template Parameters

X	pRC tensorish class (inferred)

Parameters

a	object of class X

asinh() [1/3]

template<class T >

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

inlinestaticconstexpr

asinh() [2/3]

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

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

inlinestaticconstexpr

Calculates the hyperbolic area sine of a Float.

Calculates the hyperbolic area sine of an Integer.

Template Parameters

T	Float class (inferred)

Parameters

a	object of class T

asinh() [3/3]

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

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

inlinestaticconstexpr

Calculates element-wise hyperbolic area sine of a Tensor.

Template Parameters

X	pRC tensorish class (inferred)

Parameters

a	object of class X

atan() [1/3]

template<class T >

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

inlinestaticconstexpr

atan() [2/3]

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

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

inlinestaticconstexpr

Calculates the arcus tangent of a Float.

Calculates the arcus tangent of an Integer.

Template Parameters

T	Float class (inferred)

Parameters

a	object of class T

Template Parameters

T	Integer class (inferred)

Parameters

a	object of class T

atan() [3/3]

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

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

inlinestaticconstexpr

Calculates element-wise arcus tangent of a Tensor.

Template Parameters

X	pRC tensorish class (inferred)

Parameters

a	object of class X

atan2() [1/2]

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

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

inlinestaticconstexpr

Calculates element-wise atan2 of two Tensors containing x and y coordinates.

For the definition of atan2, see Wikipedia

Template Parameters

XA	pRC tensorish class (inferred)
XB	pRC tensorish class (inferred)

Parameters

a	object of class XA, y coordinates
b	object of class XB, x coordinates

atan2() [2/2]

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

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

inlinestaticconstexpr

Calculates the atan2 of two Float coordinates.

Calculates the atan2 of two Integer coordinates.

Calculates the atan2 of a Float and an Integer coordinate.

Calculates the atan2 of an Integer and a Float coordinate.

For the definition of atan2, see Wikipedia

Template Parameters

Y	Float class (inferred)
X	Float class (inferred)

Parameters

y	object of class Y, y coordinate
x	object of class X, x coordinate

For the definition of atan2, see Wikipedia

Template Parameters

Y	Integer class (inferred)
X	Float class (inferred)

Parameters

y	object of class Y, y coordinate
x	object of class X, x coordinate

For the definition of atan2, see Wikipedia

Template Parameters

Y	Float class (inferred)
X	Integer class (inferred)

Parameters

y	object of class Y, y coordinate
x	object of class X, x coordinate

For the definition of atan2, see Wikipedia

Template Parameters

Y	Integer class (inferred)
X	Integer class (inferred)

Parameters

y	object of class Y, y coordinate
x	object of class X, x coordinate

atanh() [1/3]

template<class T >

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

inlinestaticconstexpr

atanh() [2/3]

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

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

inlinestaticconstexpr

Calculates the hyperbolic area tangent of a Float.

Calculates the hyperbolic area tangent of an Integer.

Template Parameters

T	Float class (inferred)

Parameters

a	object of class T

Template Parameters

T	Integer class (inferred)

Parameters

a	object of class T

atanh() [3/3]

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

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

inlinestaticconstexpr

Calculates element-wise hyperbolic area tangent of a Tensor.

Template Parameters

X	pRC tensorish class (inferred)

Parameters

a	object of class X

backwards() [1/3]

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

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

inlinestaticconstexpr

Flips the order of the indices of a Tensor.

Template Parameters

X	pRC tensorish class (inferred)

Parameters

a	object of class X

This function is used if the argument can not be represented as a TensorView.

Template Parameters

X	pRC tensorish class (inferred)

Parameters

a	object of class X

backwards() [2/3]

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

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

inlinestaticconstexpr

backwards() [3/3]

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

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

inlinestaticconstexpr

bitRotateLeft()

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

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

inlinestaticconstexpr

bitRotateRight()

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

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

inlinestaticconstexpr

block() [1/2]

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

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

inlinestaticconstexpr

Splits a Tensor into equal-sized blocks and returns one block specified by indices.

The number of blocks in each direction is given as template parameters, the position of the returned block is given as arguments. The mode sizes of the Tensor have to be divisible by the template parameters Bs.... Given block numbers B1, B2, ..., returned block position o1, o2, ... and a Tensor a, the returned Tensor's elements are given by block<B1, B2, ...>(a, o1, o2, ...)(i, j, ...) = a(B1*o1+i, B2*o2+j, ...).

Template Parameters

Bs...	parameter pack of class Size..., number of blocks along each axis
X	pRC tensorish class (inferred)
Os...	parameter pack of classes convertible to Index (inferred)

Parameters

a	object of class X
offsets...	parameter pack of classes Os..., specifying which block to return. In dimension i, the offset[i]-th block is returned.

block() [2/2]

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

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

inlinestaticconstexpr

Splits a Tensor into equal-sized blocks and returns one block specified by indices.

The number of blocks in each direction is given as template parameters, the position of the returned block is given as arguments. The mode sizes of the Tensor have to be divisible by the template parameters Bs.... Given block numbers B1, B2, ..., returned block position o1, o2, ... and a Tensor a, the returned Tensor's elements are given by block<B1, B2, ...>(a, o1, o2, ...)(i, j, ...) = a(B1*o1+i, B2*o2+j, ...).

This function is used if the argument can not be represented as a TensorView.

Template Parameters

Bs...	parameter pack of class Size..., number of blocks along each axis
X	pRC tensorish class (inferred)
Os...	parameter pack of classes convertible to Index (inferred)

Parameters

a	object of class X
offsets...	parameter pack of classes Os..., specifying which block to return. In dimension i, the offset[i]-th block is returned.

broadcast()

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

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

inlinestaticconstexpr

Broadcasts a Tensor into one whose mode sizes are a multiple of the mode sizes of the original Tensor.

Enlarging the mode sizes is done by repeating the Tensor along each axis a specified amount of times.

Template Parameters

Bs...	parameter pack of class Size..., Bs[i] copies are created along dimension i.
X	pRC tensorish class (inferred)

Parameters

a	object of class X

Enlarging the mode sizes is done by repeating the Tensor along each axis a specified amount of times.

This function is used if the argument can not be represented as a TensorView.

Template Parameters

Bs...	parameter pack of class Size..., Bs[i] copies are created along dimension i.
X	pRC tensorish class (inferred)

Parameters

a	object of class X

cast() [1/3]

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

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

inlinestaticconstexpr

cast() [2/3]

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

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

inlinestaticconstexpr

Casts a pRC value to a different pRC value.

Template Parameters

C	pRC value class, new class of the value
T	pRC value class (inferred)

Parameters

a	object of class T

cast() [3/3]

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

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

inlinestaticconstexpr

Casts the elements of a Tensor to a different value class.

Template Parameters

C	pRC value class, new class of the Tensor's values
X	pRC tensorish class (inferred)

Parameters

a	object of class X

ceil() [1/2]

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

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

inlinestaticconstexpr

Calculates the ceiling of a Float.

Calculates the ceiling of an Integer.

Template Parameters

T	Float class (inferred)

Parameters

a	object of class T

This function just returns the input and is only implemented for consistency reasons.

Template Parameters

T	Integer class (inferred)

Parameters

a	object of class T

ceil() [2/2]

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

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

inlinestaticconstexpr

Calculates element-wise ceiling of Tensor.

Template Parameters

X	pRC tensorish class (inferred)

Parameters

a	object of class X

ceilDiv()

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

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

inlinestaticconstexpr

chip() [1/5]

template<Index D, Index... Ds, class T , T... Is, If< IsSatisfied<(sizeof...(Ds)< sizeof...(Is))> > = 0, If< IsSatisfied<(max(D, Ds...)< sizeof...(Is))> > = 0, If< IsUnique< Constant< Index, D >, Constant< Index, Ds >... > > = 0>

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

inlinestaticconstexpr

chip() [2/5]

template<class T , T... Is>

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

inlinestaticconstexpr

chip() [3/5]

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

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

inlinestaticconstexpr

chip() [4/5]

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

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

inlinestaticconstexpr

Removes dimensions from a Tensor by specifying indices along them.

Template Parameters

Ds...	parameter pack of class Index..., dimensions that will be removed from the Tensor
X	pRC tensorish class (inferred)

Parameters

a	object of class X
indices...	parameter pack of classes Index..., indices to use along the removed dimensions

chip() [5/5]

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

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

inlinestaticconstexpr

Removes dimensions from a Tensor by specifying indices along them.

This function is used if the argument can not be represented as a TensorView.

Template Parameters

Ds...	parameter pack of class Index..., dimensions that will be removed from the Tensor
X	pRC tensorish class (inferred)

Parameters

a	object of class X
indices...	parameter pack of classes Index..., indices to use along the removed dimensions

cholesky()

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

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

inlinestaticconstexpr

CommonArray()

template<class T , Size N>

pRC::CommonArray

(

T

const(&)[N]

)

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

Complex() [1/2]

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

pRC::Complex

(

T const &

)

-> Complex< T >

Complex() [2/2]

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

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

complexify() [1/3]

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

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

inlinestaticconstexpr

Casts a Float to a Complex<Float>

The Complex<Float> is initialized with real part given by the variable, and imaginary part zero.

Template Parameters

T	Float class (inferred)

Parameters

a	object of class T

complexify() [2/3]

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

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

inlinestaticconstexpr

complexify() [3/3]

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

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

inlinestaticconstexpr

Casts a Tensors values element-wise to Complex.

Template Parameters

X	pRC tensorish class (inferred)

Parameters

a	object of class X

conj() [1/4]

template<class T >

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

inlinestaticconstexpr

conj() [2/4]

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

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

inlinestaticconstexpr

Calculates the complex conjugate of a pRC value type.

This function just returns the input and is only implemented for consistency reasons.

Template Parameters

T	pRC value class

Parameters

a	object of class T

conj() [3/4]

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

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

inlinestaticconstexpr

Calculates the element-wise complex conjugate of a Tensor.

Template Parameters

X	pRC tensorish class (inferred)

Parameters

a	object of class X

conj() [4/4]

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

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

inlinestaticconstexpr

contract() [1/4]

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

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

inlinestaticconstexpr

Contracts given indices of a Tensor.

The dimensions to contract are given as template arguments. The first half of the indices will be contracted one by one with the second half of the indices. Note that the number of indices passed to the function has to be even.

Template Parameters

Is.	parameter pack of class Index...
X	pRC tensorish class (inferred)

Parameters

a	object of class X

contract() [2/4]

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

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

inlinestaticconstexpr

Contracts given indices of a Tensor.

The dimensions to contract are given as template arguments. The first half of the indices will be contracted one by one with the second half of the indices. Note that the number of indices passed to the function has to be even.

This function is used if the argument can not be represented as a TensorView.

Template Parameters

Is.	parameter pack of class Index...
X	pRC tensorish class (inferred)

Parameters

a	object of class X

contract() [3/4]

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

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

inlinestaticconstexpr

Contracts given indices of two Tensors.

The dimensions to contract are given as template arguments. The first Tensor's dimensions specified by the first half of the indices will be contracted one by one with the second Tensor's dimensions specified by the second half of the indices. Note that the number of indices passed to the function has to be even.

Template Parameters

Is.	parameter pack of class Index...
XA	pRC tensorish class (inferred)
XB	pRC tensorish class (inferred)

Parameters

a	object of class XA
b	object of class XB

contract() [4/4]

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

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

inlinestaticconstexpr

Contracts given indices of two Tensors.

The dimensions to contract are given as template arguments. The first Tensor's dimensions specified by the first half of the indices will be contracted one by one with the second Tensor's dimensions specified by the second half of the indices. Note that the number of indices passed to the function has to be even.

This function is used if the argument can not be represented as a TensorView.

Template Parameters

Is.	parameter pack of class Index...
XA	pRC tensorish class (inferred)
XB	pRC tensorish class (inferred)

Parameters

a	object of class XA
b	object of class XB

copy()

template<Bool C = true, class X >

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

inlinestaticconstexpr

cos() [1/3]

template<class T >

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

inlinestaticconstexpr

cos() [2/3]

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

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

inlinestaticconstexpr

Calculates the cosine of a Float.

Calculates the cosine of an Integer.

Template Parameters

T	Float class (inferred)

Parameters

a	object of class T

Template Parameters

T	Integer class (inferred)

Parameters

a	object of class T

cos() [3/3]

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

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

inlinestaticconstexpr

Calculates the element-wise cosine of Tensor.

Template Parameters

X	pRC tensorish class (inferred)

Parameters

a	object of class X

cosh() [1/3]

template<class T >

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

inlinestaticconstexpr

cosh() [2/3]

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

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

inlinestaticconstexpr

Calculates the hyperbolic cosine of a Float.

Calculates the hyperbolic cosine of an Integer.

Template Parameters

T	Float class (inferred)

Parameters

a	object of class T

Template Parameters

T	Integer class (inferred)

Parameters

a	object of class T

cosh() [3/3]

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

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

inlinestaticconstexpr

Calculates the element-wise hyperbolic cosine of a Tensor.

Template Parameters

X	pRC tensorish class (inferred)

Parameters

a	object of class X

cut()

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

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

inlinestaticconstexpr

dealloc()

static auto pRC::dealloc ( void *  ptr )

inlinestatic

delta() [1/5]

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

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

inlinestaticconstexpr

delta() [2/5]

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

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

inlinestaticconstexpr

delta() [3/5]

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

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

inlinestaticconstexpr

delta() [4/5]

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

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

inlinestaticconstexpr

Calculates the absolute difference of two signed pRC value types.

Calculates the absolute difference of two pRC value types, with at least one of them being unsigned.

The result is calculated through absoluteError(a, b)=|a-b|.

Template Parameters

XA	signed pRC value class (inferred)
XB	signed pRC value class (inferred)

Parameters

a	object of class XA
b	object of class XB

The result is calculated through absoluteError(a, b)=|a-b|.

Template Parameters

XA	pRC value class (inferred)
XB	pRC value class (inferred)

Parameters

a	object of class XA
b	object of class XB

delta() [5/5]

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

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

inlinestaticconstexpr

Calculates element-wise difference of two Tensors.

Template Parameters

XA	pRC tensorish class (inferred)
XB	pRC tensorish class (inferred)

Parameters

a	object of class XA
b	object of class XB

diagonal()

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

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

inlinestaticconstexpr

Transforms a Tensor into diagonal form.

The resulting object has the same shape as the argument, with all off-diagonal entries being zero.

Template Parameters

X	pRC tensorish class (inferred)

Parameters

a	object of class X

The resulting object has the same shape as the argument, with all off-diagonal entries being zero.

This function is used if the argument can not be represented as a TensorView.

Template Parameters

X	pRC tensorish class (inferred)

Parameters

a	object of class X

directSum() [1/2]

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

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

inlinestaticconstexpr

Calculates the direct sum of two Tensors.

The definition of the direct sum for matrices can be seen on Wikipedia. The generalization for Tensors is straight-forward.

Template Parameters

XA	pRC tensorish class (inferred)
XB	pRC tensorish class (inferred)

Parameters

a	object of class XA, first summand
b	object of class XB, second summand

directSum() [2/2]

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

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

inlinestaticconstexpr

Calculates the direct sum of two Tensors.

The definition of the direct sum for matrices can be seen on Wikipedia. The generalization for Tensors is straight-forward.

This function is used if the argument can not be represented as a TensorView.

Template Parameters

XA	pRC tensorish class (inferred)
XB	pRC tensorish class (inferred)

Parameters

a	object of class XA, first summand
b	object of class XB, second summand

enumerate() [1/4]

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

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

inlinestaticconstexpr

enumerate() [2/4]

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

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

inlinestaticconstexpr

enumerate() [3/4]

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

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

inlinestaticconstexpr

enumerate() [4/4]

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

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

inlinestaticconstexpr

eval() [1/8]

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

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

inlinestaticconstexpr

eval() [2/8]

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

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

inlinestaticconstexpr

Evaluates a Tensor.

This function just forwards the argument and is only implemented for consistency reasons.

Template Parameters

X	Tensor class (inferred)

Parameters

a	object of class X

eval() [3/8]

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

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

inlinestaticconstexpr

Evaluates a TensorView.

Applies the operations stored in the TensorView and returns the resulting Tensor.

Template Parameters

X	TensorView class (inferred)

Parameters

a	object of class X

eval() [4/8]

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

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

inlinestaticconstexpr

Evaluates a Bool.

Evaluates a pRC value type.

This function just forwards the input and is only implemented for consistency reasons.

Template Parameters

X	Bool class

Parameters

a	object of type X

This function just forwards the input and is only implemented for consistency reasons.

Template Parameters

X	pRC value class

Parameters

a	object of type X

eval() [5/8]

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

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

inlinestaticconstexpr

eval() [6/8]

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

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

inlinestaticconstexpr

eval() [7/8]

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

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

inlinestaticconstexpr

eval() [8/8]

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

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

inlinestaticconstexpr

exclude() [1/4]

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

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

inlinestaticconstexpr

exclude() [2/4]

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

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

inlinestaticconstexpr

exclude() [3/4]

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

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

inlinestaticconstexpr

exclude() [4/4]

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

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

inlinestaticconstexpr

exp() [1/3]

template<class T >

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

inlinestaticconstexpr

exp() [2/3]

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

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

inlinestaticconstexpr

Calculates the exponential of a Float.

Calculates the exponential of an Integer.

Template Parameters

T	Float class (inferred)

Parameters

a	object of class T

Template Parameters

T	Integer class (inferred)

Parameters

a	object of class T

exp() [3/3]

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

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

inlinestaticconstexpr

Calculates element-wise exponential of a Tensor.

Template Parameters

X	pRC tensorish class (inferred)

Parameters

a	object of class X

expand()

template<class T , T... Seq, class F , class... Xs, If< IsInvocable< F, Xs..., Constant< T, Seq >... > > = 0>

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

inlinestaticconstexpr

forwards the values in a pRC::Sequence to a function as parameters

Parameters

_	Sequence that is passed
f	function that the Sequence is passed to
args...	additional arguments that are passed to f before the Sequence values

extractDiagonal()

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

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

inlinestaticconstexpr

Extracts the diagonal of a Tensor.

The resulting object is a Tensor with half the dimensions of the original tensor. Its mode sizes are equal to the corresponding mode sizes of the original Tensor.

Template Parameters

X	pRC tensorish class (inferred)

Parameters

a	object of class X

The resulting object is a Tensor with half the dimensions of the original tensor. Its mode sizes are equal to the corresponding mode sizes of the original Tensor.

This function is used if the argument can not be represented as a TensorView.

Template Parameters

X	pRC tensorish class (inferred)

Parameters

a	object of class X

filter()

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

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

inlinestaticconstexpr

flatten()

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

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

inlinestaticconstexpr

Flatten every dimension of a Tensor except for one.

The resulting tensor has two dimensions, the first mode size is the Kth mode size of the original tensor. The second mode size is the product of all remaining mode sizes of the original tensor.

Template Parameters

K	Index, dimension to keep seperate
X	pRC tensorish class (inferred)

Parameters

a	object of class X

The resulting tensor has two dimensions, the first mode size is the Kth mode size of the original tensor. The second mode size is the product of all remaining mode sizes of the original tensor.

This function is used if the argument can not be represented as a TensorView.

Template Parameters

K	Index, dimension to keep seperate
X	pRC tensorish class (inferred)

Parameters

a	object of class X

Float() [1/3]

pRC::Float

(

Float< 16 >::Fundamental const

)

-> Float< 16 >

Float() [2/3]

pRC::Float

(

Float< 32 >::Fundamental const

)

-> Float< 32 >

Float() [3/3]

pRC::Float

(

Float< 64 >::Fundamental const

)

-> Float< 64 >

floor() [1/2]

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

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

inlinestaticconstexpr

Calculates the floor of a Float.

Calculates the floor of an Integer.

Template Parameters

T	Float class (inferred)

Parameters

a	object of class T

This function just returns the input and is only implemented for consistency reasons.

Template Parameters

T	Integer class (inferred)

Parameters

a	object of class T

floor() [2/2]

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

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

inlinestaticconstexpr

Calculates element-wise floor of a Tensor.

Template Parameters

X	pRC tensorish class (inferred)

Parameters

a	object of class X

fmod() [1/2]

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

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

inlinestaticconstexpr

Calculates the floating-point remainder of an integer division for two Floats.

Calculates the floating-point remainder of an integer division for two Integers.

Calculates the floating-point remainder of an integer division for a Float and an Integer.

Calculates the floating-point remainder of an integer division for an Integer and a Float.

Template Parameters

TA	Float class (inferred)
TB	Float class (inferred)

Parameters

a	object of class TA, numerator
b	object of class TB, denominator

Template Parameters

TA	Integer class (inferred)
TB	Float class (inferred)

Parameters

a	object of class TA, numerator
b	object of class TB, denominator

Template Parameters

TA	Float class (inferred)
TB	Integer class (inferred)

Parameters

a	object of class TA, numerator
b	object of class TB, denominator

Template Parameters

TA	Integer class (inferred)
TB	Integer class (inferred)

Parameters

a	object of class TA, numerator
b	object of class TB, denominator

fmod() [2/2]

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

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

inlinestaticconstexpr

Calculates the floating-point remainder of an element-wise integer division of two Tensors.

Template Parameters

XA	pRC tensorish class (inferred)
XB	pRC tensorish class (inferred)

Parameters

a	object of class XA
b	object of class XB

fold() [1/3]

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

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

inlinestaticconstexpr

Repeatedly applies an operation to generate one pRC object out of many.

Base function of fold for one argument. Forwards the passed pRC object without performing any action (apart from evaluating, if E = true).

Application of this function can lead to unexpected behavior when the classes of the arguments differ due to implicit casting, e.g. 1ull-2ll=18446744073709551615ull.

Template Parameters

F	Functor representing the wanted operation
E	Bool, whether the obtained expression should be evaluated after every call to F() (default is false)
D	Direction in which to fold the pRC objects (default is pRC::Direction::Forwards)
XA	pRC object class

Parameters

a	object of class XA

fold() [2/3]

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

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

inlinestaticconstexpr

Repeatedly applies an operation to generate one pRC object out of many.

Base function of fold for two arguments. It applies the function represented by functor F to the pRC objects.

Application of this function can lead to unexpected behavior when the classes of the arguments differ due to implicit casting, e.g. 1ull-2ll=18446744073709551615ull.

Template Parameters

F	Functor representing the wanted operation
E	Bool, whether the obtained expression should be evaluated after every call to F() (default is false)
D	Direction in which to fold the pRC objects (default is pRC::Direction::Forwards)
XA	pRC object class
XB	pRC object class

Parameters

a	object of class XA
b	object of class XB

fold() [3/3]

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

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

inlinestaticconstexpr

Repeatedly applies an operation to generate one pRC object out of many.

Given pRC objects a, b, ..., y, z, this function recursively applies the function represented by functor F to arrive at a single pRC value, calculating F(F(F(...F(a, b), ...), y), z). E.g. if F is Add, the result is a + b + ... + y + z.

The direction in which to fold the pRC objects can be specified. For three arguments, using pRC::Direction::Forwards yields F(F(a, b), c), while pRC::Direction::Backwards yields F(a, F(b, c)).

Application of this function can lead to unexpected behavior when the classes of the arguments differ due to implicit casting, e.g. 1ull-2ll=18446744073709551615ull.

Template Parameters

F	Functor representing the wanted operation
E	Bool, whether the obtained expression should be evaluated after every call to F() (default is false)
D	Direction in which to fold the pRC objects (default is pRC::Direction::Forwards)
XA	pRC object class
XB	pRC object class
Xs...	pRC object classes

Parameters

a	object of class XA
b	object of class XB
args...	objects of classes Xs...

folding()

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

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

inlinestaticconstexpr

Reshapes a Tensor into a matrix.

The returned Tensor has two dimensions. Given a Position template parameter, either the left axes or the right axes are combined. For example, given Position::Right and a Tensor<T, a, b, c>, the shape of the returned Tensor is Tensor<T, a*b, c>. For Position::Left, the shape of the returned Tensor is Tensor<T, a, b*c>.

Template Parameters

P	Position, whether the left or right indices should combined (possible choices: Position::Left or Position::Right)
X	pRC tensorish class (inferred)

Parameters

a	object of class X

forwardAsTuple()

template<class... Xs>

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

inlinestaticconstexpr

fromDiagonal() [1/3]

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

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

inlinestaticconstexpr

Constructs a diagonal Tensor with given Sizes from a Tensor containing the diagonal.

The resulting Tensor has twice the dimensions of the original Tensor, with the mode sizes of the first and second halves equal to the mode sizes of the diagonal Tensor. The mode sizes of the resulting Tensor have to be provided as template parameters for this function.

Template Parameters

Ds...	parameter pack of class Size..., Sizes of the Tensor to construct
X	pRC tensorish class (inferred)

Parameters

a	object of class X, diagonal of the Tensor to construct

fromDiagonal() [2/3]

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

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

inlinestaticconstexpr

Constructs a diagonal Tensor with given Sizes from a Tensor containing the diagonal.

The resulting Tensor has twice the dimensions of the original Tensor, with the mode sizes of the first and second halves equal to the mode sizes of the diagonal Tensor. The mode sizes of the resulting Tensor have to be provided as template parameters for this function.

This function is used if the argument can not be represented as a TensorView.

Template Parameters

Ds...	parameter pack of class Size..., Sizes of the Tensor to construct
X	pRC tensorish class (inferred)

Parameters

a	object of class X, diagonal of the Tensor to construct

fromDiagonal() [3/3]

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

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

inlinestaticconstexpr

Constructs a diagonal Tensor from a Tensor containing the diagonal.

The resulting Tensor has twice the dimensions of the original Tensor, with the mode sizes of the first and second halves equal to the mode sizes of the diagonal Tensor. The mode sizes of the resulting Tensor are deduced for this function.

Template Parameters

X	pRC tensorish class (inferred)

Parameters

a	object of class X, diagonal of the Tensor to construct

generateCanonical()

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

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

inlinestaticconstexpr

getPermutation() [1/3]

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

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

inlinestaticconstexpr

getPermutation() [2/3]

template<class T , T... Froms>

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

inlinestaticconstexpr

getPermutation() [3/3]

template<class T , T... Froms, T... Tos, If< IsSatisfied<(sizeof...(Froms)==sizeof...(Tos))> > = 0>

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

inlinestaticconstexpr

getTimeInSeconds()

static Float< 64 > pRC::getTimeInSeconds ( )

inlinestatic

hadamardProduct() [1/3]

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

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

inlinestaticconstexpr

Calculates the Hadamard product of two Tensors.

The Hadamard product of two Tensors is their element-wise product, see Wikipedia

Template Parameters

XA	pRC tensorish class (inferred)
XB	pRC tensorish class (inferred)

Parameters

a	object of class XA
b	object of class XB

hadamardProduct() [2/3]

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

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

inlinestaticconstexpr

hadamardProduct() [3/3]

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

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

inlinestaticconstexpr

help()

template<class... Ps>

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

inlinestaticconstexpr

identity() [1/3]

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

static constexpr auto pRC::identity ( )

inlinestaticconstexpr

identity() [2/3]

static constexpr auto pRC::identity ( )

inlinestaticconstexpr

identity() [3/3]

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

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

inlinestaticconstexpr

iLog()

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

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

inlinestaticconstexpr

imag() [1/3]

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

static constexpr auto pRC::imag ( T const  )

inlinestaticconstexpr

Calculates the imaginary part of a pRC value.

This function just returns zero and is only implemented for consistency reasons.

Template Parameters

T	pRC value class

Parameters

a	object of class T

imag() [2/3]

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

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

inlinestaticconstexpr

imag() [3/3]

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

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

inlinestaticconstexpr

Calculates element-wise the imaginary part of a Tensor.

Template Parameters

X	pRC tensorish class (inferred)

Parameters

a	object of class X

Indices()

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

pRC::Indices

(

Is

const ...

)

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

inflate()

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

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

inlinestaticconstexpr

Inflates the sizes of a Tensor by repeating its values.

Template Parameters

Is...	parameter pack of class Size, number of repeats of values along each axis
X	pRC tensorish class (inferred)

Parameters

a	object of class X

This function is used if the argument can not be represented as a TensorView.

Template Parameters

Is...	parameter pack of class Size, number of repeats of values along each axis
X	pRC tensorish class (inferred)

Parameters

a	object of class X

innerProduct() [1/7]

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

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

inlinestaticconstexpr

innerProduct() [2/7]

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

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

inlinestaticconstexpr

innerProduct() [3/7]

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

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

inlinestaticconstexpr

innerProduct() [4/7]

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

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

inlinestaticconstexpr

Calculates the inner product of two pRC values.

For scalars, the inner product is just the simple product, i.e. innerProduct(a, b)=a*b

Template Parameters

TA	pRC value class (inferred)
TB	pRC value class (inferred)

Parameters

a	object of type TA, first term
b	object of type TB, second term

innerProduct() [5/7]

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

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

inlinestaticconstexpr

Calculates the inner product of two Tensors.

The inner product of two Tensors A and B is defined as the scalar product of the complex conjugate of A and B (see Wikipedia).

Template Parameters

XA	pRC tensorish class (inferred)
XB	pRC tensorish class (inferred)

Parameters

a	object of class XA, first factor
b	object of class XB, second factor

innerProduct() [6/7]

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

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

inlinestaticconstexpr

Calculates the inner product of two Tensors.

The inner product of two Tensors A and B is defined as the scalar product of the complex conjugate of A and B (see Wikipedia).

This function is used if the argument can not be represented as a TensorView.

Template Parameters

XA	pRC tensorish class (inferred)
XB	pRC tensorish class (inferred)

Parameters

a	object of class XA, first factor
b	object of class XB, second factor

innerProduct() [7/7]

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

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

inlinestaticconstexpr

Integer() [1/8]

pRC::Integer

(

Integer< false, 16 >::Fundamental const

)

-> Integer< false, 16 >

Integer() [2/8]

pRC::Integer

(

Integer< false, 32 >::Fundamental const

)

-> Integer< false, 32 >

Integer() [3/8]

pRC::Integer

(

Integer< false, 64 >::Fundamental const

)

-> Integer< false, 64 >

Integer() [4/8]

pRC::Integer

(

Integer< false, 8 >::Fundamental const

)

-> Integer< false, 8 >

Integer() [5/8]

pRC::Integer

(

Integer< true, 16 >::Fundamental const

)

-> Integer< true, 16 >

Integer() [6/8]

pRC::Integer

(

Integer< true, 32 >::Fundamental const

)

-> Integer< true, 32 >

Integer() [7/8]

pRC::Integer

(

Integer< true, 64 >::Fundamental const

)

-> Integer< true, 64 >

Integer() [8/8]

pRC::Integer

(

Integer< true, 8 >::Fundamental const

)

-> Integer< true, 8 >

integerFactorization()

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

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

inlinestaticconstexpr

iPow()

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

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

inlinestaticconstexpr

isApprox()

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

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

inlinestaticconstexpr

Checks if two pRC objects agree up to a given tolerance.

This function first calculates the absolute error of a and b. Then, it checks whether the absolute error is smaller than or equal to the product tolerance * min(norm(a), norm(b)). This means that true is returned only if both the relative error of a to b and the relative error of b to a are below the tolerance given.

Warning: Since this function works based on the relative error, unintuitive behavior can happen when one of the values is close to zero.

Template Parameters

XA	pRC object class (inferred)
XB	pRC object class (inferred)

Parameters

a	object of type XA, first object
b	object of type XB, second object
tolerance	object of compatible type, relative tolerance up to which a and b should agree

isDefined() [1/2]

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

True pRC::isDefined

(

T &&

)

isDefined() [2/2]

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

True pRC::isDefined

(

T *

)

isDiagonal()

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

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

inlinestaticconstexpr

Checks if a Tensor is diagonal.

Template Parameters

X	pRC tensorish class (inferred)

Parameters

a	object of class X, Tensor to check diagonality
tolerance	object of value class of X, tolerance up to which to check

isEven() [1/2]

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

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

inlinestaticconstexpr

isEven() [2/2]

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

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

inlinestaticconstexpr

isIdentity() [1/3]

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

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

inlinestaticconstexpr

isIdentity() [2/3]

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

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

inlinestaticconstexpr

isIdentity() [3/3]

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

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

inlinestaticconstexpr

Checks if a pRC object agrees with identity up to a given absolute tolerance.

This function checks if the absolute error between the passed value and identity is smaller than or equal to the given tolerance

Template Parameters

X	pRC object class (inferred)

Parameters

a	object of type X
tolerance	object of compatible type, absolute tolerance up to which a and identity should agree

isLowerTriangular()

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

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

inlinestaticconstexpr

Checks if a Tensor is lower triangular.

Template Parameters

X	pRC tensorish class (inferred)

Parameters

a	object of class X, Tensor to check lower triangularity
tolerance	object of value class of X, tolerance up to which to check

isnan()

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

inlinestaticconstexpr

isNaN()

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

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

inlinestaticconstexpr

Checks if a Float is NaN.

Checks if an Integer is NaN.

Template Parameters

T	Float class (inferred)

Parameters

a	object of type T

This function just returns false and is only implemented for consistency reasons.

Template Parameters

T	Integer Class (inferred)

Parameters

a	object of type T

isOdd() [1/2]

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

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

inlinestaticconstexpr

isOdd() [2/2]

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

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

inlinestaticconstexpr

isOffDiagonal()

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

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

inlinestaticconstexpr

Checks if a Tensor is off-diagonal.

Template Parameters

X	pRC tensorish class (inferred)

Parameters

a	object of class X, Tensor to check off-diagonality
tolerance	object of value class of X, tolerance up to which to check

isPowerOfTwo()

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

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

inlinestaticconstexpr

isProperAlignment()

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

inlinestaticconstexpr

iSqrt()

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

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

inlinestaticconstexpr

isSelfAdjoint()

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

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

inlinestaticconstexpr

Checks if a Tensor is self-adjoint.

Template Parameters

X	pRC tensorish class (inferred)

Parameters

a	object of class X, Tensor to check if it is self-adjoint
tolerance	object of value class of X, tolerance up to which to check

isStrictlyLowerTriangular()

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

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

inlinestaticconstexpr

Checks if a Tensor is strictly lower triangular.

Template Parameters

X	pRC tensorish class (inferred)

Parameters

a	object of class X, Tensor to check strict lower triangularity
tolerance	object of value class of X, tolerance up to which to check

isStrictlyUpperTriangular()

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

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

inlinestaticconstexpr

Checks if a Tensor is strictly upper triangular.

Template Parameters

X	pRC tensorish class (inferred)

Parameters

a	object of class X, Tensor to check strict upper triangularity
tolerance	object of value class of X, tolerance up to which to check

isSymmetric()

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

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

inlinestaticconstexpr

Checks if a Tensor is symmetric.

Template Parameters

X	pRC tensorish class (inferred)

Parameters

a	object of class X, Tensor to check symmetry
tolerance	object of value class of X, tolerance up to which to check

isTensorView() [1/2]

template<class >

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

inlinestaticconstexpr

isTensorView() [2/2]

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

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

inlinestaticconstexpr

isUnit() [1/3]

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

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

inlinestaticconstexpr

isUnit() [2/3]

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

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

inlinestaticconstexpr

isUnit() [3/3]

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

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

inlinestaticconstexpr

Checks if a pRC object agrees with unit up to a given absolute tolerance.

This function checks if the absolute error between the passed value and unit is smaller than or equal to the given tolerance

Template Parameters

X	pRC object class (inferred)

Parameters

a	object of type X
tolerance	object of compatible type, absolute tolerance up to which a and unit should agree

isUnitary()

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

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

inlinestaticconstexpr

Checks if a Tensor is unitary.

Template Parameters

X	pRC tensorish class (inferred)

Parameters

a	object of class X, Tensor to check unitarity
tolerance	object of value class of X, tolerance up to which to check

isUnitLowerTriangular()

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

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

inlinestaticconstexpr

Checks if a Tensor is unit lower triangular.

Template Parameters

X	pRC tensorish class (inferred)

Parameters

a	object of class X, Tensor to check unit lower triangularity
tolerance	object of value class of X, tolerance up to which to check

isUnitUpperTriangular()

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

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

inlinestaticconstexpr

Checks if a Tensor is unit upper triangular.

Template Parameters

X	pRC tensorish class (inferred)

Parameters

a	object of class X, Tensor to check unit upper triangular
tolerance	object of value class of X, tolerance up to which to check

isUpperTriangular()

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

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

inlinestaticconstexpr

Checks if a Tensor is upper triangular.

Template Parameters

X	pRC tensorish class (inferred)

Parameters

a	object of class X, Tensor to check upper triangularity
tolerance	object of value class of X, tolerance up to which to check

isZero() [1/3]

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

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

inlinestaticconstexpr

isZero() [2/3]

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

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

inlinestaticconstexpr

isZero() [3/3]

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

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

inlinestaticconstexpr

Checks if a pRC object agrees with zero up to a given absolute tolerance.

This function checks if the absolute error between the passed value and zero is smaller than or equal to the given tolerance

Template Parameters

X	pRC object class (inferred)

Parameters

a	object of type X
tolerance	object of compatible type, absolute tolerance up to which a and zero should agree

JacobiRotation() [1/4]

template<class T , Size M, Size N>

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

JacobiRotation() [2/4]

template<class T , Size N>

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

JacobiRotation() [3/4]

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

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

JacobiRotation() [4/4]

template<class V , class T , Size N>

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

kroneckerProduct() [1/2]

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

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

inlinestaticconstexpr

Calculates the Kronecker product of two Tensors.

The definition of the Kronecker product can be seen on Wikipedia

Template Parameters

XA	pRC tensorish class (inferred)
XB	pRC tensorish class (inferred)

Parameters

a	object of class XA, first factor
b	object of class XB, second factor

kroneckerProduct() [2/2]

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

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

inlinestaticconstexpr

Calculates the Kronecker product of two Tensors.

The definition of the Kronecker product can be seen on Wikipedia

This function is used if the argument can not be represented as a TensorView.

Template Parameters

XA	pRC tensorish class (inferred)
XB	pRC tensorish class (inferred)

Parameters

a	object of class XA, first factor
b	object of class XB, second factor

linearize()

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

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

inlinestaticconstexpr

Linearizes a Tensor into a vector.

The result only has one dimension, whose mode size is the product of the original Tensor's mode sizes.

Template Parameters

X	pRC tensorish class (inferred)

Parameters

a	object of class X

log() [1/3]

template<class T >

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

inlinestaticconstexpr

log() [2/3]

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

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

inlinestaticconstexpr

Calculates the natural (base e) logarithm of a Float.

Calculates the natural (base e) logarithm of an Integer.

Template Parameters

T	Float class (inferred)

Parameters

a	object of class T

Template Parameters

T	Integer class (inferred)

Parameters

a	object of class T

log() [3/3]

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

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

inlinestaticconstexpr

Calculates the element-wise natural (base e) logarithm of a Tensor.

Template Parameters

X	pRC tensorish class (inferred)

Parameters

a	object of class X

log10() [1/3]

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

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

inlinestaticconstexpr

log10() [2/3]

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

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

inlinestaticconstexpr

Calculates the base 10 logarithm of a Float.

Calculates the base 10 logarithm of an Integer.

Template Parameters

T	Float class (inferred)

Parameters

a	object of class T

Template Parameters

T	Integer class (inferred)

Parameters

a	object of class T

log10() [3/3]

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

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

inlinestaticconstexpr

Calculates the element-wise base 10 logarithm of a Tensor.

Template Parameters

X	pRC tensorish class (inferred)

Parameters

a	object of class X

log2() [1/3]

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

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

inlinestaticconstexpr

log2() [2/3]

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

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

inlinestaticconstexpr

Calculates the base 2 logarithm of a Float.

Calculates the base 2 logarithm of an Integer.

Template Parameters

T	Float class (inferred)

Parameters

a	object of class T

Template Parameters

T	Integer class (inferred)

Parameters

a	object of class T

log2() [3/3]

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

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

inlinestaticconstexpr

Calculates the element-wise base 2 logarithm of a Tensor.

Template Parameters

X	pRC tensorish class (inferred)

Parameters

a	object of class X

loop() [1/8]

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

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

inlinestaticconstexpr

Applies a function element-wise to Tensors.

Template Parameters

F	class of the function applied to the Tensors (inferred)
Xs...	pRC tensorish classes (inferred)

Parameters

f	object of class F, function to apply to the Tensors
args...	parameter pack of classes Xs...

loop() [2/8]

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

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

inlinestaticconstexpr

Applies a function element-wise to Tensors.

This function is used if the argument can not be represented as a TensorView.

Template Parameters

F	class of the function applied to the Tensors (inferred)
Xs...	pRC tensorish classes (inferred)

Parameters

f	object of class F, function to apply to the Tensors
args...	parameter pack of classes Xs...

loop() [3/8]

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

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

inlinestaticconstexpr

loop() [4/8]

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

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

inlinestaticconstexpr

loop() [5/8]

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

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

inlinestaticconstexpr

Applies a function element-wise to Tensors.

Template Parameters

F	pRC Functor class of the function applied to the Tensors
Xs...	pRC tensorish classes (inferred)

Parameters

args...

parameter pack of classes Xs...

loop() [6/8]

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

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

inlinestaticconstexpr

Applies a function element-wise to Tensors.

This function is used if the argument can not be represented as a TensorView.

Template Parameters

F	pRC Functor class of the function applied to the Tensors
Xs...	pRC tensorish classes (inferred)

Parameters

args...

parameter pack of classes Xs...

loop() [7/8]

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

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

inlinestaticconstexpr

loop() [8/8]

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

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

inlinestaticconstexpr

lowerTriangular()

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

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

inlinestaticconstexpr

Transforms a Tensor into lower triangular form.

Template Parameters

X	pRC tensorish class (inferred)

Parameters

a	object of class X

This function is used if the argument can not be represented as a TensorView.

Template Parameters

X	pRC tensorish class (inferred)

Parameters

a	object of class X

lq()

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

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

inlinestaticconstexpr

makeConstantSequence()

template<class T , Size N, T V>

static constexpr auto pRC::makeConstantSequence ( )

inlinestaticconstexpr

makeRange()

template<class T , T First, T Last, Direction D = Direction::Forwards, T Step = T(1), If< IsSatisfied<(D==Direction::Forwards||D==Direction::Backwards)> > = 0, If< IsSatisfied<((Last - First) % Step==0)> > = 0>

static constexpr auto pRC::makeRange ( )

inlinestaticconstexpr

makeSeries()

template<class T , T N>

static constexpr auto pRC::makeSeries ( )

inlinestaticconstexpr

makeSeriesFor() [1/2]

template<class T >

static constexpr auto pRC::makeSeriesFor ( )

inlinestaticconstexpr

makeSeriesFor() [2/2]

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

static constexpr auto pRC::makeSeriesFor ( )

inlinestaticconstexpr

matricize()

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

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

inlinestaticconstexpr

Reshapes a Tensor into a matrix (a 2-dimensional Tensor)

The first and second halves of the original Tensor's mode sizes constitute the resulting Tensor's first and second mode sizes.

Template Parameters

X	pRC tensorish class (inferred)

Parameters

a	object of class X

max() [1/3]

template<class X >

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

inlinestaticconstexpr

max() [2/3]

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

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

inlinestaticconstexpr

max() [3/3]

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

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

inlinestaticconstexpr

mean()

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

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

inlinestaticconstexpr

Calculates the mean of a variable ammount of pRC objects.

Template Parameters

Xs...

pRC object classes (inferred)

Parameters

args...

objects of classes Xs..., objects to calculate mean of

min() [1/3]

template<class X >

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

inlinestaticconstexpr

min() [2/3]

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

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

inlinestaticconstexpr

min() [3/3]

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

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

inlinestaticconstexpr

name() [1/2]

template<class T >

static constexpr auto pRC::name ( )

inlinestaticconstexpr

name() [2/2]

template<class T >

static constexpr auto pRC::name ( )

inlinestaticconstexpr

narrow() [1/2]

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

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

inlinestaticconstexpr

Performs an operation only along given dimensions of Tensors.

This function first chips of the dimensions not given by Es... from all of the Tensors, then f is applied to the resulting Tensors. When calculating an element of the resulting Tensor, the first Xs::Dimension()-sizeof...(Es) indices are used to specify which indices to use when chip is applied. The remaining indices are the indices of the Tensor resulting from application of f.

Template Parameters

Ns...	parameter pack of class Index..., dimensions of the Tensors to exclude
F	class of the function performed on the Tensors (inferred)
Xs...	pRC tensorish classes (inferred)

Parameters

f	object of class F, function performed on the Tensors
args...	parameter pack of classes Xs...

narrow() [2/2]

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

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

inlinestaticconstexpr

Performs an operation only along given dimensions of Tensors.

This function first chips of the dimensions not given by Es... from all of the Tensors, then F() is applied to the resulting Tensors. When calculating an element of the resulting Tensor, the first Xs::Dimension()-sizeof...(Es) indices are used to specify which indices to use when chip is applied. The remaining indices are the indices of the Tensor resulting from application of F().

Template Parameters

Ns...	parameter pack of class Index..., dimensions of the Tensors to exclude
F	pRC Functor class of the function applied to the Tensors
Xs...	pRC tensorish classes (inferred)

Parameters

args...

parameter pack of classes Xs...

norm() [1/4]

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

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

inlinestaticconstexpr

norm() [2/4]

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

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

inlinestaticconstexpr

Calculates p-norms of a pRC value.

Given two template parameters P and Q, the p-norm of a pRC value is calculated as norm<P, Q>(a) = (|a|^P)^(1/Q). For the special case Q=0, the result is calculated as norm<P, 0>(a) = |a|.

For more clarification on the effect of the template parameters P and Q, check the documentation for norm if the argument is a Tensor.

Allowed values for P and Q are:

• P=Q
• P=2, Q=1
• P arbitrary, Q=0

Template Parameters

P	Index which p-norm should be calculated (default is 2)
Q	Index specifying what to do with the result of the p-norm (see explanation for details) (default is P)
T	pRC value class (inferred)

Parameters

a	object of class T

norm() [3/4]

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

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

inlinestaticconstexpr

Calculates p-norms of a Tensor.

Given two template parameters P and Q, the p-norm of a Tensor A with its elements denoted as A_i (with multi-index i) is calculated as norm<P, Q>(A) = (sum_i |A_i|^P)^(1/Q). For the special case of Q=0, the result is calculated as norm<P, Q>(A) = max_i |A_i|.

Allowed values for P and Q are:

• P=Q=1
• P=Q=2
• P=2, Q=1
• P arbitrary, Q=0

For P=Q, this function calculates the usual p-norm, for P=2, Q=1, the square of the 2-norm is calculated. In the case Q=0, the value for P is not important.

Template Parameters

P	Index which p-norm should be calculated (default is 2)
Q	Index specifying what to do with the result of the p-norm (see explanation for details) (default is P)
X	pRC tensorish class (inferred)

Parameters

a	object of class X

Given two template parameters P and Q, the p-norm of a Tensor A with its elements denoted as A_i is calculated as norm<P, Q>(A) = (sum_i |A_i|^P)^(1/Q). For the special case of Q=0, the result is calculated as norm<P, Q>(A) = max_i |A_i|.

Allowed values for P and Q are:

• P=Q=1
• P=Q=2
• P=2, Q=1
• P arbitrary, Q=0

For P=Q, this function calculates the usual p-norm, for P=2, Q=1, the square of the 2-norm is calculated. In the case Q=0, the value for P is not important.

This function is used if the argument can not be represented as a TensorView.

Template Parameters

P	Index which p-norm should be calculated (default is 2)
Q	Index specifying what to do with the result of the p-norm (see explanation for details) (default is P)
X	pRC tensorish class (inferred)

Parameters

a	object of class X

norm() [4/4]

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

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

inlinestaticconstexpr

offDiagonal()

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

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

inlinestaticconstexpr

Transforms a Tensor into off-diagonal form.

Template Parameters

X	pRC tensorish class (inferred)

Parameters

a	object of class X

This function is used if the argument can not be represented as a TensorView.

Template Parameters

X	pRC tensorish class (inferred)

Parameters

a	object of class X

operator!() [1/2]

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

inlinestaticconstexpr

operator!() [2/2]

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

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

inlinestaticconstexpr

Calculates the element-wise logical not of a Tensors.

Template Parameters

X	pRC tensorish class (inferred)

Parameters

a	object of class X

operator!=() [1/17]

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

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

inlinestaticconstexpr

operator!=() [2/17]

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

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

inlinestaticconstexpr

operator!=() [3/17]

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

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

inlinestaticconstexpr

operator!=() [4/17]

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

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

inlinestaticconstexpr

operator!=() [5/17]

template<class T >

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

constexpr

operator!=() [6/17]

template<class TA , class TB >

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

inlinestaticconstexpr

operator!=() [7/17]

template<class T >

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

constexpr

operator!=() [8/17]

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

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

inlinestaticconstexpr

operator!=() [9/17]

template<class T , T... As, T... Bs, If< IsSatisfied<(sizeof...(As)==sizeof...(Bs))> > = 0>

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

inlinestaticconstexpr

operator!=() [10/17]

template<Size... Ns>

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

inlinestaticconstexpr

operator!=() [11/17]

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

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

inlinestaticconstexpr

operator!=() [12/17]

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

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

inlinestaticconstexpr

Checks whether two pRC values are not equal.

Template Parameters

TA	pRC value class (inferred)
TB	pRC value class (inferred)

Parameters

a	object of class TA
b	object of class TB

operator!=() [13/17]

template<class T >

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

constexpr

operator!=() [14/17]

template<class X >

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

inlinestaticconstexpr

operator!=() [15/17]

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

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

inlinestaticconstexpr

Checks non-equality of two Tensors.

Two Tensors are not equal if at least one of their elements are not equal.

Template Parameters

XA	pRC tensorish class (inferred)
XB	pRC tensorish class (inferred)

Parameters

a	object of class XA
b	object of class XB

operator!=() [16/17]

template<class X >

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

inlinestaticconstexpr

operator!=() [17/17]

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

inlinestaticconstexpr

operator%() [1/5]

template<class T , T... As, T B, If< IsInvocable< Mod, T, T > > = 0>

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

inlinestaticconstexpr

operator%() [2/5]

template<class T , T... As, T... Bs, If< IsInvocable< Mod, T, T > > = 0, If< IsSatisfied<(sizeof...(As)==sizeof...(Bs))> > = 0>

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

inlinestaticconstexpr

operator%() [3/5]

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

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

inlinestaticconstexpr

operator%() [4/5]

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

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

inlinestaticconstexpr

Calculates the modulus of an integer division of two Integers.

Given Integers a and b, this function returns ab.

Template Parameters

TA	Integer class
TB	Integer class

Parameters

a	object of type TA, numerator
b	object of type TB, denominator

operator%() [5/5]

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

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

inlinestaticconstexpr

Calculates element-wise modulus of an integer division of two Tensors.

Both of the Tensors have to have an Integer value type.

Template Parameters

XA	pRC tensorish class (inferred)
XB	pRC tensorish class (inferred)

Parameters

a	object of class XA, numerator
b	object of class XB, denominator

operator&&()

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

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

inlinestaticconstexpr

Calculates the element-wise logical and of two Tensors.

Template Parameters

XA	pRC tensorish class (inferred)
XB	pRC tensorish class (inferred)

Parameters

a	object of class XA
b	object of class XB

operator*() [1/17]

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

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

inlinestaticconstexpr

operator*() [2/17]

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

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

inlinestaticconstexpr

operator*() [3/17]

template<class T , T A, T... Bs, If< IsInvocable< Mul, T, T > > = 0>

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

inlinestaticconstexpr

operator*() [4/17]

template<class TA , class TB >

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

inlinestaticconstexpr

operator*() [5/17]

template<class T , T... As, T B, If< IsInvocable< Mul, T, T > > = 0>

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

inlinestaticconstexpr

operator*() [6/17]

template<class T , T... As, T... Bs, If< IsInvocable< Mul, T, T > > = 0, If< IsSatisfied<(sizeof...(As)==sizeof...(Bs))> > = 0>

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

inlinestaticconstexpr

operator*() [7/17]

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

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

inlinestaticconstexpr

operator*() [8/17]

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

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

inlinestaticconstexpr

operator*() [9/17]

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

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

inlinestaticconstexpr

operator*() [10/17]

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

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

inlinestaticconstexpr

Calculates the product of two Floats.

Calculates the product of two Integers.

Calculates the product of a Float and an Integer.

Calculates the product of an Integer and a Float.

Template Parameters

TA	Float class (inferred)
TB	Float class (inferred)

Parameters

a	object of type TA, first term
b	object of type TB, second term

Template Parameters

TA	Integer class (inferred)
TB	Float class (inferred)

Parameters

a	object of type TA, first term
b	object of type TB, second term

Template Parameters

TA	Float class (inferred)
TB	Integer class (inferred)

Parameters

a	object of type TA, first term
b	object of type TB, second term

Template Parameters

TA	Integer class (inferred)
TB	Integer class (inferred)

Parameters

a	object of type TA, first term
b	object of type TB, second term

operator*() [11/17]

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

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

inlinestaticconstexpr

Mutliplies a Tensor by a Tensor with one element.

One of the Tensors a and b has to be 0-dimensional. Then, each element of the other Tensor is multiplied by the value of the Tensor with one element.

Template Parameters

XA	pRC tensorish class (inferred)
XB	pRC tensorish class (inferred)

Parameters

a	object of class XA
b	object of class XB

operator*() [12/17]

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

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

inlinestaticconstexpr

Mutliplies a Tensor by a Value.

Mutliplies a Value by a Tensor.

Each element of the result is the respective element of the Tensor multiplied by the Value.

Template Parameters

XA	pRC tensorish class (inferred)
XB	pRC value class or pRC complex class (inferred)

Parameters

a	object of class XA
b	object of class XB

Each element of the result is the respective element of the Tensor multiplied by the Value.

Template Parameters

XA	pRC value class or pRC complex class (inferred)
XB	pRC tensorish class (inferred)

Parameters

a	object of class XA
b	object of class XB

operator*() [13/17]

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

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

inlinestaticconstexpr

Calculates an Operator-by-Tensor product.

Calculates an Operator-by-Operator product.

This function is used if the first Tensor has twice as many dimensions as the second and the second half of mode sizes of the first Tensor is the same as the second Tensor's mode sizes.

The result is calculated by contracting the second half of the first Tensor's indices pairwise with the indices of the second Tensor.

Template Parameters

XA	pRC tensorish class (inferred)
XB	pRC tensorish class (inferred)

Parameters

a	object of class XA
b	object of class XB

This function is used if the first Tensor has twice as many dimensions as the second and the first half of mode sizes of the first Tensor is the same as the second Tensor's mode sizes.

The result is calculated by contracting the first half of the first Tensor's indices pairwise with the indices of the second Tensor.

Template Parameters

XA	pRC tensorish class (inferred)
XB	pRC tensorish class (inferred)

Parameters

a	object of class XA
b	object of class XB

This function is used if the first Tensor has as many dimensions as the second and the second half of mode sizes of the first Tensor is the same as the first half of mode sizes of the second Tensor.

The result is calculated by contracting the second half of the first Tensor's indices pairwise with the first half of the second Tensor's indices.

Template Parameters

XA	pRC tensorish class (inferred)
XB	pRC tensorish class (inferred)

Parameters

a	object of class XA
b	object of class XB

operator*() [14/17]

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

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

inlinestaticconstexpr

operator*() [15/17]

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

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

inlinestaticconstexpr

operator*() [16/17]

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

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

inlinestaticconstexpr

operator*() [17/17]

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

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

inlinestaticconstexpr

operator+() [1/18]

template<Size M, Size N>

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

inlinestaticconstexpr

operator+() [2/18]

template<class T >

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

inlinestaticconstexpr

operator+() [3/18]

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

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

inlinestaticconstexpr

operator+() [4/18]

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

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

inlinestaticconstexpr

operator+() [5/18]

template<class T , T A, T... Bs, If< IsInvocable< Add, T, T > > = 0>

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

inlinestaticconstexpr

operator+() [6/18]

template<class T , T... As, T B, If< IsInvocable< Add, T, T > > = 0>

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

inlinestaticconstexpr

operator+() [7/18]

template<class T , T... As, T... Bs, If< IsInvocable< Add, T, T > > = 0, If< IsSatisfied<(sizeof...(As)==sizeof...(Bs))> > = 0>

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

inlinestaticconstexpr

operator+() [8/18]

template<Size M, Size N>

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

inlinestaticconstexpr

operator+() [9/18]

template<Size M, Size N>

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

inlinestaticconstexpr

operator+() [10/18]

template<Size... Ns>

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

inlinestaticconstexpr

operator+() [11/18]

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

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

inlinestaticconstexpr

• operator for a pRC value

This function just returns the input and is only implemented for consistency reasons.

Template Parameters

[pRC	value class](#ValueTypes) (inferred)

Parameters

a	object of class T

operator+() [12/18]

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

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

inlinestaticconstexpr

operator+() [13/18]

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

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

inlinestaticconstexpr

Calculates the sum of two Floats.

Calculates the sum of two Integers.

Calculates the sum of a Float and an Integer.

Calculates the sum of an Integer and a Float.

Template Parameters

TA	Float class (inferred)
TB	Float class (inferred)

Parameters

a	object of type TA, first summand
b	object of type TB, second summand

Template Parameters

TA	Integer class (inferred)
TB	Float class (inferred)

Parameters

a	object of type TA, first summand
b	object of type TB, second summand

Template Parameters

TA	Float class (inferred)
TB	Integer class (inferred)

Parameters

a	object of type TA, first summand
b	object of type TB, second summand

Template Parameters

TA	Integer class (inferred)
TB	Integer class (inferred)

Parameters

a	object of type TA, first summand
b	object of type TB, second summand

operator+() [14/18]

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

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

inlinestaticconstexpr

• operator for a Tensor

This function just returns the input and is only implemented for consistency reasons.

Template Parameters

X	pRC tensorish class (inferred)

Parameters

a	object of class X

operator+() [15/18]

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

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

inlinestaticconstexpr

operator+() [16/18]

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

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

inlinestaticconstexpr

Calculates sum of two Tensors.

Template Parameters

XA	pRC tensorish class (inferred)
XB	pRC tensorish class (inferred)

Parameters

a	object of class XA, first summand
b	object of class XB, second summand

operator+() [17/18]

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

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

inlinestaticconstexpr

operator+() [18/18]

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

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

inlinestaticconstexpr

operator,()

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

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

inlinestaticconstexpr

operator-() [1/14]

template<class T >

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

inlinestaticconstexpr

operator-() [2/14]

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

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

inlinestaticconstexpr

operator-() [3/14]

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

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

inlinestaticconstexpr

operator-() [4/14]

template<class T , T... As, T B, If< IsInvocable< Sub, T, T > > = 0>

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

inlinestaticconstexpr

operator-() [5/14]

template<class T , T... As, T... Bs, If< IsInvocable< Sub, T, T > > = 0, If< IsSatisfied<(sizeof...(As)==sizeof...(Bs))> > = 0>

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

inlinestaticconstexpr

operator-() [6/14]

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

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

inlinestaticconstexpr

operator-() [7/14]

template<Size... Ns>

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

inlinestaticconstexpr

operator-() [8/14]

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

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

inlinestaticconstexpr

Calculates the negative of a pRC value.

Template Parameters

[pRC	value class](#ValueTypes) (inferred)

Parameters

a	object of class T

operator-() [9/14]

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

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

inlinestaticconstexpr

operator-() [10/14]

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

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

inlinestaticconstexpr

Subtraction of two Floats.

Subtraction of two Integers.

Subtraction of a Float and an Integer.

Subtraction of an Integer and a Float.

Template Parameters

TA	Float class (inferred)
TB	Float class (inferred)

Parameters

a	object of type TA, minuend
b	object of type TB, subtrahend

Template Parameters

TA	Integer class (inferred)
TB	Float class (inferred)

Parameters

a	object of type TA, minuend
b	object of type TB, subtrahend

Template Parameters

TA	Float class (inferred)
TB	Integer class (inferred)

Parameters

a	object of type TA, minuend
b	object of type TB, subtrahend

Template Parameters

TA	Integer class (inferred)
TB	Integer class (inferred)

Parameters

a	object of type TA, minuend
b	object of type TB, subtrahend

operator-() [11/14]

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

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

inlinestaticconstexpr

Calculates the element-wise negative of a Tensor.

Template Parameters

X	pRC tensorish class (inferred)

Parameters

a	object of class X

operator-() [12/14]

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

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

inlinestaticconstexpr

operator-() [13/14]

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

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

inlinestaticconstexpr

Subtraction of two Tensors.

Template Parameters

XA	pRC tensorish class (inferred)
XB	pRC tensorish class (inferred)

Parameters

a	object of class XA
b	object of class XB

operator-() [14/14]

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

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

inlinestaticconstexpr

operator/() [1/12]

template<class TA , class TB >

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

inlinestaticconstexpr

operator/() [2/12]

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

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

inlinestaticconstexpr

operator/() [3/12]

template<class T , T... As, T B, If< IsInvocable< Div, T, T > > = 0>

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

inlinestaticconstexpr

operator/() [4/12]

template<class T , T... As, T... Bs, If< IsInvocable< Div, T, T > > = 0, If< IsSatisfied<(sizeof...(As)==sizeof...(Bs))> > = 0>

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

inlinestaticconstexpr

operator/() [5/12]

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

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

inlinestaticconstexpr

operator/() [6/12]

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

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

inlinestaticconstexpr

operator/() [7/12]

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

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

inlinestaticconstexpr

Calculates the division of two Floats.

Calculates the division of two Integers.

Calculates the division of a Float by an Integer.

Calculates the division of an Integer by a Float.

Template Parameters

TA	Float class (inferred)
TB	Float class (inferred)

Parameters

a	object of type TA, numerator
b	object of type TB, denominator

Template Parameters

TA	Integer class (inferred)
TB	Float class (inferred)

Parameters

a	object of type TA, numerator
b	object of type TB, denominator

Template Parameters

TA	Float class (inferred)
TB	Integer class (inferred)

Parameters

a	object of type TA, numerator
b	object of type TB, denominator

Note that this function does integer division only (e.g. 3/2=1), the result is not casted to a Float.

Template Parameters

TA	Float class (inferred)
TB	Float class (inferred)

Parameters

a	object of type TA, numerator
b	object of type TB, denominator

operator/() [8/12]

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

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

inlinestaticconstexpr

Calculates element-wise division of two Tensors.

Template Parameters

XA	pRC tensorish class (inferred)
XB	pRC tensorish class (inferred)

Parameters

a	object of class XA, numerator
b	object of class XB, denominator

operator/() [9/12]

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

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

inlinestaticconstexpr

Divides a Tensor with one element by a Tensor.

Divides a Tensor by a Tensor with one element.

The first Tensor has to be 0-dimensional. Then, each element of the result is given by the value of the first Tensor divided by the respective element of the second Tensor.

Template Parameters

XA	pRC tensorish class (inferred)
XB	pRC tensorish class (inferred)

Parameters

a	object of class XA
b	object of class XB

The second Tensor has to be 0-dimensional. Then, each element of the result is given by the respective element of the first Tensor divided by the value of the second Tensor.

Template Parameters

XA	pRC tensorish class (inferred)
XB	pRC tensorish class (inferred)

Parameters

a	object of class XA
b	object of class XB

operator/() [10/12]

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

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

inlinestaticconstexpr

Divides a Tensor by a Value.

Divides a Value by a Tensor.

Each element of the result is the respective element of the Tensor divided by the Value.

Template Parameters

XA	pRC tensorish class (inferred)
XB	pRC value class or pRC complex class (inferred)

Parameters

a	object of class XA
b	object of class XB

Each element of the result is the Value divided by the respective element of the Tensor.

Template Parameters

XA	pRC value class or pRC complex class (inferred)
XB	pRC tensorish class (inferred)

Parameters

a	object of class XA
b	object of class XB

operator/() [11/12]

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

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

inlinestaticconstexpr

operator/() [12/12]

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

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

inlinestaticconstexpr

operator<() [1/9]

template<class T , T A, T... Bs, If< IsInvocable< Equal, T, T > > = 0>

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

inlinestaticconstexpr

operator<() [2/9]

template<class T , T... As, T B, If< IsInvocable< Equal, T, T > > = 0>

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

inlinestaticconstexpr

operator<() [3/9]

template<class T , T... As, T... Bs, If< IsInvocable< Equal, T, T > > = 0, If< IsSatisfied<(sizeof...(As)==sizeof...(Bs))> > = 0>

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

inlinestaticconstexpr

operator<() [4/9]

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

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

inlinestaticconstexpr

Checks whether a pRC value is less than another pRC value.

This function is used if at least one of the pRC values is a Float

Template Parameters

TA	pRC value class (inferred)
TB	pRC value class (inferred)

Parameters

a	object of class TA
b	object of class TB

operator<() [5/9]

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

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

inlinestaticconstexpr

Checks whether an Integer is less than another Integer.

Template Parameters

TA	Integer class (inferred)
TB	Integer class (inferred)

Parameters

a	object of class TA
b	object of class TB

operator<() [6/9]

template<class X >

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

inlinestaticconstexpr

operator<() [7/9]

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

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

inlinestaticconstexpr

Checks element-wise whether a Tensor's elements are less than another Tensor's elements.

Template Parameters

XA	pRC tensorish class (inferred)
XB	pRC tensorish class (inferred)

Parameters

a	object of class XA
b	object of class XB

operator<() [8/9]

template<class X >

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

inlinestaticconstexpr

operator<() [9/9]

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

inlinestaticconstexpr

operator<=() [1/8]

template<class T , T A, T... Bs, If< IsInvocable< LessEqual, T, T > > = 0>

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

inlinestaticconstexpr

operator<=() [2/8]

template<class T , T... As, T B, If< IsInvocable< LessEqual, T, T > > = 0>

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

inlinestaticconstexpr

operator<=() [3/8]

template<class T , T... As, T... Bs, If< IsInvocable< LessEqual, T, T > > = 0, If< IsSatisfied<(sizeof...(As)==sizeof...(Bs))> > = 0>

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

inlinestaticconstexpr

operator<=() [4/8]

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

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

inlinestaticconstexpr

Checks whether a pRC value is less than or equal to another pRC value.

Template Parameters

TA	pRC value class (inferred)
TB	pRC value class (inferred)

Parameters

a	object of class TA
b	object of class TB

operator<=() [5/8]

template<class X >

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

inlinestaticconstexpr

operator<=() [6/8]

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

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

inlinestaticconstexpr

Checks element-wise whether a Tensor's elements are less than or equal to another Tensor's elements.

Template Parameters

XA	pRC tensorish class (inferred)
XB	pRC tensorish class (inferred)

Parameters

a	object of class XA
b	object of class XB

operator<=() [7/8]

template<class X >

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

inlinestaticconstexpr

operator<=() [8/8]

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

inlinestaticconstexpr

operator==() [1/18]

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

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

inlinestaticconstexpr

operator==() [2/18]

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

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

inlinestaticconstexpr

operator==() [3/18]

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

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

inlinestaticconstexpr

operator==() [4/18]

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

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

inlinestaticconstexpr

operator==() [5/18]

template<class T >

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

constexpr

operator==() [6/18]

template<class TA , class TB >

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

inlinestaticconstexpr

operator==() [7/18]

template<class T >

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

constexpr

operator==() [8/18]

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

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

inlinestaticconstexpr

operator==() [9/18]

template<class T , T... As, T... Bs, If< IsSatisfied<(sizeof...(As)==sizeof...(Bs))> > = 0>

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

inlinestaticconstexpr

operator==() [10/18]

template<Size... Ns>

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

inlinestaticconstexpr

operator==() [11/18]

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

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

inlinestaticconstexpr

operator==() [12/18]

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

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

inlinestaticconstexpr

Checks whether two Floats are equal.

Template Parameters

TA	Float class (inferred)
TB	Float class (inferred)

Parameters

a	object of class TA
b	object of class TB

operator==() [13/18]

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

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

inlinestaticconstexpr

Checks whether two Integers are equal.

Template Parameters

TA	Integer class (inferred)
TB	Integer class (inferred)

Parameters

a	object of class TA
b	object of class TB

operator==() [14/18]

template<class T >

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

constexpr

operator==() [15/18]

template<class X >

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

inlinestaticconstexpr

operator==() [16/18]

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

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

inlinestaticconstexpr

Checks equality of two Tensors.

Two Tensors are equal if their elements are equal.

Template Parameters

XA	pRC tensorish class (inferred)
XB	pRC tensorish class (inferred)

Parameters

a	object of class XA
b	object of class XB

operator==() [17/18]

template<class X >

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

inlinestaticconstexpr

operator==() [18/18]

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

inlinestaticconstexpr

operator>() [1/8]

template<class T , T A, T... Bs, If< IsInvocable< Equal, T, T > > = 0>

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

inlinestaticconstexpr

operator>() [2/8]

template<class T , T... As, T B, If< IsInvocable< Equal, T, T > > = 0>

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

inlinestaticconstexpr

operator>() [3/8]

template<class T , T... As, T... Bs, If< IsInvocable< Equal, T, T > > = 0, If< IsSatisfied<(sizeof...(As)==sizeof...(Bs))> > = 0>

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

inlinestaticconstexpr

operator>() [4/8]

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

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

inlinestaticconstexpr

Checks whether a pRC value is greater than another pRC value.

Template Parameters

TA	pRC value class (inferred)
TB	pRC value class (inferred)

Parameters

a	object of class TA
b	object of class TB

operator>() [5/8]

template<class X >

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

inlinestaticconstexpr

operator>() [6/8]

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

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

inlinestaticconstexpr

Checks element-wise whether a Tensor's elements are greater than another Tensor's elements.

Template Parameters

XA	pRC tensorish class (inferred)
XB	pRC tensorish class (inferred)

Parameters

a	object of class XA
b	object of class XB

operator>() [7/8]

template<class X >

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

inlinestaticconstexpr

operator>() [8/8]

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

inlinestaticconstexpr

operator>=() [1/8]

template<class T , T A, T... Bs, If< IsInvocable< GreaterEqual, T, T > > = 0>

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

inlinestaticconstexpr

operator>=() [2/8]

template<class T , T... As, T B, If< IsInvocable< GreaterEqual, T, T > > = 0>

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

inlinestaticconstexpr

operator>=() [3/8]

template<class T , T... As, T... Bs, If< IsInvocable< GreaterEqual, T, T > > = 0, If< IsSatisfied<(sizeof...(As)==sizeof...(Bs))> > = 0>

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

inlinestaticconstexpr

operator>=() [4/8]

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

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

inlinestaticconstexpr

Checks whether a pRC value is greater than or equal to another pRC value.

Template Parameters

TA	pRC value class (inferred)
TB	pRC value class (inferred)

Parameters

a	object of class TA
b	object of class TB

operator>=() [5/8]

template<class X >

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

inlinestaticconstexpr

operator>=() [6/8]

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

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

inlinestaticconstexpr

Checks element-wise whether a Tensor's elements are greater than or equal to another Tensor's elements.

Template Parameters

XA	pRC tensorish class (inferred)
XB	pRC tensorish class (inferred)

Parameters

a	object of class XA
b	object of class XB

operator>=() [7/8]

template<class X >

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

inlinestaticconstexpr

operator>=() [8/8]

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

inlinestaticconstexpr

operator||()

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

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

inlinestaticconstexpr

Calculates the element-wise logical or of two Tensors.

Template Parameters

XA	pRC tensorish class (inferred)
XB	pRC tensorish class (inferred)

Parameters

a	object of class XA
b	object of class XB

optimizationBarrier()

template<class T , class... Ts>

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

inlinestatic

optimize() [1/4]

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

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

inlinestaticconstexpr

This function is used to optimize over a tensorish object.

Template Parameters

Optimizer

the class of the optimizer used

The function's first template parameter has to be set, all other template parameters are inferred from the function's arguments.

Parameters

optimizer	the optimizer used
xx	the object to optimize
function	a lambda function [...](auto const &xx, auto &g) {...} that returns the score and updates the gradients g
callback	a lambda function that is called once after the optimization is complete
tolerance	the tolerance for the optimization

optimize() [2/4]

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

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

inlinestaticconstexpr

This function is used to optimize over a tensorish object.

Template Parameters

Optimizer

the class of the optimizer used

The function's first template parameter has to be set, all other template parameters are inferred from the function's arguments.

Parameters

optimizer	the optimizer used
xx	the object to optimize
function	a lambda function [...](auto const &xx, auto &g) {...} that returns the score and updates the gradients g
tolerance	the tolerance for the optimization

There is no callback lambda function in this case.

optimize() [3/4]

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

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

inlinestaticconstexpr

This function is used to optimize over a tensorish object.

Template Parameters

Optimizer

the class of the optimizer used

The function's first template parameter has to be set, all other template parameters are inferred from the function's arguments.

Parameters

xx	the object to optimize
function	a lambda function [...](auto const &xx, auto &g) {...} that returns the score and updates the gradients g
callback	a lambda function that is called once after the optimization is complete
tolerance	the tolerance for the optimization

The optimizer object is constructed from the Optimizer class with no arguments.

optimize() [4/4]

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

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

inlinestaticconstexpr

This function is used to optimize over a tensorish object.

Template Parameters

Optimizer

the class of the optimizer used

The function's first template parameter has to be set, all other template parameters are inferred from the function's arguments.

Parameters

xx	the object to optimize
function	a lambda function [...](auto const &xx, auto &g) {...} that returns the score and updates the gradients g
tolerance	the tolerance for the optimization

The optimizer object is constructed from the Optimizer class with no arguments. Also, there is no callback function in this case.

orthogonalize()

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

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

inlinestaticconstexpr

outerProduct() [1/2]

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

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

inlinestaticconstexpr

Calculates the outer product of two Tensors.

The outer product of two Tensors A and B is defined as the tensor product of A and the complex conjugate of B (see Wikipedia).

Template Parameters

XA	pRC tensorish class (inferred)
XB	pRC tensorish class (inferred)

Parameters

a	object of class XA, first factor
b	object of class XB, second factor

outerProduct() [2/2]

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

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

inlinestaticconstexpr

Calculates the outer product of two Tensors.

The outer product of two Tensors A and B is defined as the tensor product of A and the complex conjugate of B (see Wikipedia).

This function is used if the argument can not be represented as a TensorView.

Template Parameters

XA	pRC tensorish class (inferred)
XB	pRC tensorish class (inferred)

Parameters

a	object of class XA, first factor
b	object of class XB, second factor

parameter() [1/4]

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

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

inlinestaticconstexpr

parameter() [2/4]

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

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

inlinestaticconstexpr

parameter() [3/4]

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

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

inlinestaticconstexpr

parameter() [4/4]

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

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

inlinestaticconstexpr

parse()

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

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

inlinestaticconstexpr

permute() [1/5]

template<Index... Ps, class T , T... Is, If< IsSatisfied<(sizeof...(Is)==sizeof...(Ps))> > = 0, If< IsSatisfied<((Ps< sizeof...(Is)) &&...)> > = 0, If< IsUnique< Constant< Index, Ps >... > > = 0>

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

inlinestaticconstexpr

permute() [2/5]

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

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

inlinestaticconstexpr

permute() [3/5]

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

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

inlinestaticconstexpr

Permutes the indices of a Tensor.

The new ordering of the indices is passed as a permutation of (0, ..., X::Dimension()).

Template Parameters

Ps...	parameter pack of class Index..., new order of the indices
X	pRC tensorish class (inferred)

Parameters

a	object of class X

permute() [4/5]

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

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

inlinestaticconstexpr

Permutes the indices of a Tensor.

The new ordering of the indices is passed as a permutation of (0, ..., X::Dimension()).

This function is a specialization for 0-dimensional Tensors, implemented for consistency reasons.

Template Parameters

X	pRC tensorish class (inferred)

Parameters

a	object of class X

permute() [5/5]

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

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

inlinestaticconstexpr

Permutes the indices of a Tensor.

The new ordering of the indices is passed as a permutation of (0, ..., X::Dimension()).

This function is used if the argument can not be represented as a TensorView.

Template Parameters

Ps...	parameter pack of class Index..., new order of the indices
X	pRC tensorish class (inferred)

Parameters

a	object of class X

pi() [1/2]

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

static constexpr T pRC::pi ( )

inlinestaticconstexpr

Returns pi as a Float.

The template parameter T is the Float that the pi returned has.

Template Parameters

T	Float class

pi() [2/2]

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

static constexpr auto pRC::pi ( )

inlinestaticconstexpr

Returns pi as a Float.

If T is an Integer class, pi is returned as a standard Float object.

Template Parameters

T	Integer class

pick()

template<class F , class T , T... As, T... Bs, class... Seqs, If< IsInvocable< F, T, T > > = 0, If< IsSatisfied<((Sequence< T, As... >::size()==Seqs::size()) &&... &&(Sequence< T, As... >::size()==Sequence< T, Bs... >::size()))> >

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

inlinestaticconstexpr

polar()

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

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

inlinestaticconstexpr

pow() [1/5]

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

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

inlinestaticconstexpr

Calculates a Float to the power of another Float.

Calculates an Integer to the power of another Integer.

Calculates a Float to the power of an Integer.

Calculates an Integer to the power of a Float.

Template Parameters

B	Float class (inferred)
N	Float class (inferred)

Parameters

base	object of class B, base
exp	object of class N, exponent

Template Parameters

B	Integer class (inferred)
N	Float class (inferred)

Parameters

base	object of class B, base
exp	object of class N, exponent

Template Parameters

B	Float class (inferred)
N	Integer class (inferred)

Parameters

base	object of class B, base
exp	object of class N, exponent

Template Parameters

B	Integer class (inferred)
N	Integer class (inferred)

Parameters

base	object of class B, base
exp	object of class N, exponent

pow() [2/5]

template<class X , class Y >

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

inlinestaticconstexpr

pow() [3/5]

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

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

inlinestaticconstexpr

pow() [4/5]

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

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

inlinestaticconstexpr

pow() [5/5]

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

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

inlinestaticconstexpr

Takes a Tensor element-wise to the power of another Tensor.

Template Parameters

XA	pRC tensorish class (inferred)
XB	pRC tensorish class (inferred)

Parameters

a	object of class XA, base
b	object of class XB, exponent

print() [1/18]

template<class S >

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

inlinestatic

print() [2/18]

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

inlinestatic

print() [3/18]

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

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

inlinestatic

print() [4/18]

template<class T , T V, class S >

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

inlinestatic

print() [5/18]

template<class S >

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

inlinestatic

print() [6/18]

template<class S >

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

inlinestatic

print() [7/18]

template<Size N, class S >

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

inlinestatic

print() [8/18]

template<Size N, class S >

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

inlinestatic

print() [9/18]

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

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

inlinestatic

print() [10/18]

template<Size... Ns, class S >

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

inlinestatic

print() [11/18]

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

inlinestatic

print() [12/18]

template<Size N>

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

inlinestatic

print() [13/18]

template<Size... Ns, class S >

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

inlinestatic

print() [14/18]

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

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

inlinestatic

print() [15/18]

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

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

inlinestatic

Prints a Float to a C stream.

Prints an unsigned Integer to a C stream.

Prints a signed Integer to a C stream.

Template Parameters

T	Float class

Parameters

value	object of class T, Float to print
*stream	C stream to print to

Template Parameters

T	signed Integer class

Parameters

value	object of class T, signed Integer to print
*stream	C stream to print to

Template Parameters

T	unsigned Integer class

Parameters

value	object of class T, unsigned Integer to print
*stream	C stream to print to

print() [16/18]

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

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

inlinestatic

print() [17/18]

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

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

inlinestatic

Prints a Tensor to a stream.

Template Parameters

X	pRC tensorish class (inferred)
S	class of the stream to print to (inferred)

Parameters

arg	object of class X, Tensor to print
stream	object of class S, stream to print to

print() [18/18]

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

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

inlinestatic

qr()

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

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

inlinestaticconstexpr

random()

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

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

inlinestaticconstexpr

range() [1/7]

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

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

inlinestaticconstexpr

range() [2/7]

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

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

inlinestaticconstexpr

range() [3/7]

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

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

inlinestaticconstexpr

range() [4/7]

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

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

inlinestaticconstexpr

range() [5/7]

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

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

inlinestaticconstexpr

range() [6/7]

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

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

inlinestaticconstexpr

range() [7/7]

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

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

inlinestaticconstexpr

rcp() [1/3]

template<class T >

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

inlinestaticconstexpr

rcp() [2/3]

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

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

inlinestaticconstexpr

Calculates the reciprocal of a pRC value.

Template Parameters

T	pRC value class (inferred)

Parameters

a	object of class T

rcp() [3/3]

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

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

inlinestaticconstexpr

Calculates the element-wise reciprocal of a Tensor.

Template Parameters

X	pRC tensorish class (inferred)

Parameters

a	object of class X

real() [1/3]

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

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

inlinestaticconstexpr

real() [2/3]

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

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

inlinestaticconstexpr

Calculates element-wise the real part of a Tensor.

Template Parameters

X	pRC tensorish class (inferred)

Parameters

a	object of class X

real() [3/3]

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

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

inlinestaticconstexpr

Calculates the real part of a pRC value.

This function just returns the value passed to it and is only implemented for consistency reasons.

Template Parameters

T	pRC value class

Parameters

a	object of class T

RecursiveLambda()

template<class X >

pRC::RecursiveLambda

(

X &&

)

-> RecursiveLambda< RemoveReference< X > >

reduce() [1/5]

template<class F , class T , T I>

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

inlinestaticconstexpr

reduce() [2/5]

template<class F , class T , T I1, T I2, T... Is, If< IsInvocable< F, T, T > > = 0>

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

inlinestaticconstexpr

reduce() [3/5]

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

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

inlinestaticconstexpr

Reduces a Tensor's dimensions by performing an operation along some of its axes.

Performs the function given by F() along the axes specified by Is.... The result is a Tensor with dimension X::Dimension()-sizeof...(Is).

Template Parameters

F	pRC Functor class
Is...	parameter pack of class Index..., axes to reduce
X	pRC tensorish class (inferred)

Parameters

a	object of class X

reduce() [4/5]

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

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

inlinestaticconstexpr

Reduces a Tensor's dimensions by performing an operation along all of its axes.

Performs the function given by F() along all of the Tensor's axes.

Template Parameters

F	pRC Functor class
X	pRC tensorish class (inferred)

Parameters

a	object of class X

reduce() [5/5]

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

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

inlinestaticconstexpr

Reduces a Tensor's dimensions by performing an operation along some of its axes.

Performs the function given by F() along the axes specified by Is.... The result is a Tensor with dimension X::Dimension()-sizeof...(Is).

This function is used if the argument can not be represented as a TensorView.

Template Parameters

F	pRC Functor class
Is...	parameter pack of class Index..., axes to reduce
X	pRC tensorish class (inferred)

Parameters

a	object of class X

relativeError()

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

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

inlinestaticconstexpr

Calculates the relative error of a pRC object from another pRC object.

This function is used when the value of both pRC objects is of Float class.

Note that relativeError is not symmetrical in its arguments. Given two parameters a and b, the function calculates relativeError(a, b)=absoluteError(a, b) / norm(a).

Template Parameters

XA	pRC object class (inferred)
XB	pRC object class (inferred)

Parameters

a	object of class XA, value from which relative error is calculated
b	object of class XB, value of which the relative error is calculated

This function is used when the value of the first pRC object is of Float class, and the value of the second pRC object is of Integer class.

Note that relativeError is not symmetrical in its arguments. Given two parameters a and b, the function calculates relativeError(a, b)=absoluteError(a, b) / norm(a).

Template Parameters

XA	pRC object class (inferred)
XB	pRC object class (inferred)

Parameters

a	object of class XA, value from which relative error is calculated
b	object of class XB, value of which the relative error is calculated

This function is used when the value of the first pRC object is of Integer class, and the value of the second pRC object is of Float class.

Note that relativeError is not symmetrical in its arguments. Given two parameters a and b, the function calculates relativeError(a, b)=absoluteError(a, b) / norm(a).

Template Parameters

XA	pRC object class (inferred)
XB	pRC object class (inferred)

Parameters

a	object of class XA, value from which relative error is calculated
b	object of class XB, value of which the relative error is calculated

This function is used when the value of both pRC objects is of Integer class.

Note that relativeError is not symmetrical in its arguments. Given two parameters a and b, the function calculates relativeError(a, b)=absoluteError(a, b) / norm(a).

Template Parameters

XA	pRC object class (inferred)
XB	pRC object class (inferred)

Parameters

a	object of class XA, value from which relative error is calculated
b	object of class XB, value of which the relative error is calculated

report()

template<class... Ps>

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

inlinestaticconstexpr

reshape()

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

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

inlinestaticconstexpr

Reshapes a Tensor.

The new mode sizes are given as template parameters. Their product must be the same as the product of the argument's mode sizes.

Template Parameters

Ns...	parameter pack of class Size..., mode sizes of the new Tensor
X	pRC tensorish class (inferred)

Parameters

a	object of class X

The new mode sizes are given as template parameters. Their product must be the same as the product of the argument's mode sizes.

This function is used if the argument can not be represented as a TensorView.

Template Parameters

Ns...	parameter pack of class Size..., mode sizes of the new Tensor
X	pRC tensorish class (inferred)

Parameters

a	object of class X

restrict() [1/2]

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

static constexpr decltype(auto) pRC::restrict ( X &&  a )

inlinestaticconstexpr

Applies a restriction to a Tensor.

Template Parameters

OR	enumerator from Operator::Restrict (default is Operator::Restrict::None)
X	pRC tensorish class (inferred)

Parameters

a	object of class X

restrict() [2/2]

template<Operator::Restrict OR = Operator::Restrict::None, class X , class R = RemoveReference<X>, If< TensorTrain::IsOperatorish< R > > = 0>

static constexpr decltype(auto) pRC::restrict ( X &&  a )

inlinestaticconstexpr

reverse() [1/4]

static constexpr auto pRC::reverse ( Direction const  D )

inlinestaticconstexpr

reverse() [2/4]

template<class T , T... Is>

static constexpr auto pRC::reverse ( Sequence< T, Is... > const  )

inlinestaticconstexpr

reverse() [3/4]

template<Size... Ns>

static constexpr auto pRC::reverse ( Subscripts< Ns... > const &  arg )

inlinestaticconstexpr

reverse() [4/4]

template<Bool... Rs, class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< View, X > > = 0, If< IsSatisfied<(sizeof...(Rs)==typename R::Dimension())> > = 0>

static constexpr auto pRC::reverse ( X &&  a )

inlinestaticconstexpr

Reverses a Tensor along specified axes.

A total of X::Dimension() boolean values are passed as template parameters, the i-th of which indicates if the i-th axis should be reversed (true: reverse, false: leave as is).

Template Parameters

Rs...	parameter pack of class Bool..., whether to reverse each of the axes
X	pRC tensorish class (inferred)

Parameters

a	object of class X

A total of X::Dimension() boolean values are passed as template parameters, the i-th of which indicates if the i-th axis should be reversed (true: reverse, false: leave as is).

This function is used if the argument can not be represented as a TensorView.

Template Parameters

Rs...	parameter pack of class Bool..., whether to reverse each of the axes
X	pRC tensorish class (inferred)

Parameters

a	object of class X

rotate() [1/4]

template<Direction D, Size Step, class T , If< IsSatisfied<(D==Direction::Leftwards||D==Direction::Rightwards)> > = 0>

static constexpr auto pRC::rotate ( Sequence< T > const  )

inlinestaticconstexpr

rotate() [2/4]

template<Direction D, Size Step, class T , T First, T... Is, If< IsSatisfied<(D==Direction::Leftwards||D==Direction::Rightwards)> > = 0>

static constexpr auto pRC::rotate ( Sequence< T, First, Is... > const  )

inlinestaticconstexpr

rotate() [3/4]

template<Direction D, Size Step, Size... Ns, If< True< decltype(rotate< D, Step >(makeSeriesFor< Index, Ns... >()))> >

static constexpr auto pRC::rotate ( Subscripts< Ns... > const &  arg )

inlinestaticconstexpr

rotate() [4/4]

template<Direction D, Size S = 1, class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsSatisfied<(D==Direction::Leftwards||D==Direction::Rightwards)> > = 0>

static constexpr auto pRC::rotate ( X &&  a )

inlinestaticconstexpr

Rotates the indices of a Tensor.

The indices of the Tensor are rotated by S places in the direction specified by D. For example, rotating a 3-dimensional Tensor A leftward by one place is the same as permute<2, 0, 1>(A).

Template Parameters

D	pRC::Direction in which to rotate (Leftwards or Rightwards)
S	Size, number of places to rotate the indices by (default is 1)
X	pRC tensorish class (inferred)

Parameters

a	object of class X

round() [1/6]

template<std::int64_t D = 0, class T , If< IsInvocable< Round< D >, T > > = 0>

static constexpr auto pRC::round ( Complex< T > const &  a )

inlinestaticconstexpr

round() [2/6]

template<std::int64_t D = 0, class T , If< IsFloat< T > > = 0>

static constexpr auto pRC::round ( T const &  a )

inlinestaticconstexpr

Rounds a Float to a given number of digits after the decimal point.

Rounds an Integer to a given number of digits after the decimal point.

Passing a negative number of digits after the decimal point is permitted, e.g. passing -1 as the number of digits leads to rounding to the nearest multiple of 10.

Values exactly in between possible rounded values are rounded away from zero.

Template Parameters

D	Size, number of digits after the decimal point (default: 0)
T	Float class (inferred)

Parameters

a	object of class T, object to be rounded

Passing a negative number of digits after the decimal point is permitted, e.g. passing -1 as the number of digits leads to rounding to the nearest multiple of 10.

For integers, passing values >=0 to the number of digits leaves the value unchanged.

Values exactly in between possible rounded values are rounded away from zero.

Template Parameters

D	Size, number of digits after the decimal point (default: 0)
T	Integer class (inferred)

Parameters

a	object of class T, object to be rounded

round() [3/6]

template<std::int64_t D = 0, class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Round< D > >, X > > = 0>

static constexpr auto pRC::round ( X &&  a )

inlinestaticconstexpr

Rounds a Tensor element-wise to a given number of digits after the decimal point.

Passing a negative number of digits after the decimal point is permitted, e.g. passing -1 as the number of digits leads to rounding to the nearest multiple of 10.

Values exactly in between possible rounded values are rounded away from zero.

Template Parameters

D	Size, number of digits after the decimal point (default is 0)
X	pRC tensorish class (inferred)

Parameters

a	object of class X

round() [4/6]

template<class Ranks , class X , class R = RemoveReference<X>, class V = typename R::Value, class VT = V, If< All< IsFloat< V >, IsFloat< VT > > > = 0, If< Any< TensorTrain::IsTensorish< R >, TensorTrain::IsOperatorish< R > > > = 0, If< IsSizes< Ranks > > = 0, If< IsSatisfied<(typename Ranks::Dimension()==typename R::Dimension() - 1)> > = 0>

static constexpr auto pRC::round ( X &&  a, VT const &  tolerance = NumericLimits<VT>::epsilon()  )

inlinestaticconstexpr

round() [5/6]

template<class X , class R = RemoveReference<X>, class V = typename R::Value, class VT = V, If< All< IsFloat< V >, IsFloat< VT > > > = 0, If< Any< TensorTrain::IsTensorish< R >, TensorTrain::IsOperatorish< R > > > = 0>

static constexpr auto pRC::round ( X &&  a, VT const &  tolerance = NumericLimits<VT>::epsilon()  )

inlinestaticconstexpr

round() [6/6]

template<Size C, class X , class R = RemoveReference<X>, class V = typename R::Value, class VT = V, If< All< IsFloat< V >, IsFloat< VT > > > = 0, If< Any< TensorTrain::IsTensorish< R >, TensorTrain::IsOperatorish< R > > > = 0>

static constexpr auto pRC::round ( X &&  a, VT const &  tolerance = NumericLimits<VT>::epsilon()  )

inlinestaticconstexpr

scalar()

template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsSatisfied<(R::Sizes::size()==1)> > = 0, If< IsInvocable< Reshape<>, X > > = 0>

static constexpr auto pRC::scalar ( X &&  a )

inlinestaticconstexpr

Casts a Tensor with one element to its Value class.

Template Parameters

X	pRC tensorish class (inferred)

Parameters

a	object of class X

scalarProduct() [1/8]

template<class TA , class TB , If< IsInvocable< Mul, Complex< TA >, Complex< TB > > > = 0>

static constexpr auto pRC::scalarProduct ( Complex< TA > const &  a, Complex< TB > const &  b  )

inlinestaticconstexpr

scalarProduct() [2/8]

template<class TA , class TB , If< IsValue< TB > > = 0, If< IsInvocable< Mul, Complex< TA >, TB > > = 0>

static constexpr auto pRC::scalarProduct ( Complex< TA > const &  a, TB const &  b  )

inlinestaticconstexpr

scalarProduct() [3/8]

template<class TA , class TB , If< IsValue< TA > > = 0, If< IsInvocable< Mul, TA, Complex< TB > > > = 0>

static constexpr auto pRC::scalarProduct ( TA const &  a, Complex< TB > const &  b  )

inlinestaticconstexpr

scalarProduct() [4/8]

template<class TA , class TB , If< IsValue< TA > > = 0, If< IsValue< TB > > = 0>

static constexpr auto pRC::scalarProduct ( TA const &  a, TB const &  b  )

inlinestaticconstexpr

Calculates the scalar product of two pRC values.

For scalars, the scalar product is just the simple product, i.e. scalarProduct(a, b)=a*b

Template Parameters

TA	pRC value class (inferred)
TB	pRC value class (inferred)

Parameters

a	object of type TA, first term
b	object of type TB, second term

scalarProduct() [5/8]

template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< IsTensorish< RA > > = 0, If< IsInvocable< View, XA > > = 0, If< IsTensorish< RB > > = 0, If< IsInvocable< View, XB > > = 0, If< IsSame< typename RA::Sizes, typename RB::Sizes > > = 0, If< IsInvocable< HadamardProduct, XA, XB > > = 0, If< IsInvocable< Reduce< Add >, ResultOf< HadamardProduct, XA, XB > > > = 0>

static constexpr auto pRC::scalarProduct ( XA &&  a, XB &&  b  )

inlinestaticconstexpr

Calculates the scalar product of two Tensors.

The scalar product of two Tensors is defined as the sum of their Hadamard product (see Wikipedia).

Template Parameters

XA	pRC tensorish class (inferred)
XB	pRC tensorish class (inferred)

Parameters

a	object of class XA
b	object of class XB

scalarProduct() [6/8]

template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< IsTensorish< RA > > = 0, If< IsTensorish< RB > > = 0, If< Not< All< IsInvocable< View, XA >, IsInvocable< View, XB > > > > = 0, If< IsInvocable< ScalarProduct, XA &, XB & > > = 0>

static constexpr auto pRC::scalarProduct ( XA &&  a, XB &&  b  )

inlinestaticconstexpr

Calculates the scalar product of two Tensors.

The scalar product of two Tensors is defined as the sum of their Hadamard product (see Wikipedia).

This function is used if the argument can not be represented as a TensorView.

Template Parameters

XA	pRC tensorish class (inferred)
XB	pRC tensorish class (inferred)

Parameters

a	object of class XA
b	object of class XB

scalarProduct() [7/8]

template<class XA , class XB , If< TensorTrain::IsOperatorish< RemoveReference< XA > > > = 0, If< TensorTrain::IsOperatorish< RemoveReference< XB > > > = 0, If< IsInvocable< HadamardProduct, XA, XB > > = 0>

static constexpr auto pRC::scalarProduct ( XA &&  a, XB &&  b  )

inlinestaticconstexpr

scalarProduct() [8/8]

template<class XA , class XB , If< TensorTrain::IsTensorish< RemoveReference< XA > > > = 0, If< TensorTrain::IsTensorish< RemoveReference< XB > > > = 0, If< IsInvocable< HadamardProduct, XA, XB > > = 0>

static constexpr auto pRC::scalarProduct ( XA &&  a, XB &&  b  )

inlinestaticconstexpr

SeedSequence()

template<class... Ts>

pRC::SeedSequence

(

Ts &&

...

)

-> SeedSequence< sizeof...(Ts)>

select() [1/2]

template<Index S, Index... Ss, class T , T... Is, If< IsSatisfied<(sizeof...(Ss)< sizeof...(Is))> > = 0, If< IsSatisfied<(max(S, Ss...)< sizeof...(Is))> > = 0, If< IsUnique< Constant< Index, S >, Constant< Index, Ss >... > > = 0>

static constexpr auto pRC::select ( Sequence< T, Is... > const  )

inlinestaticconstexpr

select() [2/2]

template<class T , T... Is>

static constexpr auto pRC::select ( Sequence< T, Is... > const  )

inlinestaticconstexpr

Sequence() [1/2]

template<Size... Ns>

pRC::Sequence

(

Sizes< Ns... > const

)

-> Sequence< Size, Ns... >

Sequence() [2/2]

template<class T , T... Seq>

pRC::Sequence

(

std::integer_sequence< T, Seq... > const

)

-> Sequence< T, Seq... >

sign() [1/3]

template<class T , If< IsInvocable< Sign, T > > = 0>

static constexpr auto pRC::sign ( Complex< T > const &  a )

inlinestaticconstexpr

sign() [2/3]

template<class T , If< IsValue< T > > = 0, If< IsSatisfied<(typename T::Signed()==true)> > = 0>

static constexpr auto pRC::sign ( T const &  a )

inlinestaticconstexpr

Calculates the sign of a signed pRC value type.

Calculates the sign of an unsigned pRC value type.

If the passed value is larger/smaller than zero, an (negative) identity of the same type is returned. If the passed value is zero, a zero of the same type is returned.

Template Parameters

T	signed pRC value class (inferred)

Parameters

a	object of class T

If the passed value is larger than zero, an identity of the same type is returned. If the passed value is zero, a zero of the same type is returned.

Template Parameters

T	unsgined pRC value class (inferred)

Parameters

a	object of class T

sign() [3/3]

template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Sign >, X > > = 0>

static constexpr auto pRC::sign ( X &&  a )

inlinestaticconstexpr

Calculates the element-wise sign of a Tensor.

Template Parameters

X	pRC tensorish class (inferred)

Parameters

a	object of class X

sin() [1/3]

template<class T >

static constexpr auto pRC::sin ( Complex< T > const &  a )

inlinestaticconstexpr

sin() [2/3]

template<class T , If< IsFloat< T > > = 0>

static constexpr auto pRC::sin ( T const  a )

inlinestaticconstexpr

Calculates the sine of a Float.

Calculates the sine of an Integer.

Template Parameters

T	Float class (inferred)

Parameters

a	object of class T

Template Parameters

T	Integer class (inferred)

Parameters

a	object of class T

sin() [3/3]

template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Sin >, X > > = 0>

static constexpr auto pRC::sin ( X &&  a )

inlinestaticconstexpr

Calculates the element-wise sine of a Tensor.

Template Parameters

X	pRC tensorish class (inferred)

Parameters

a	object of class X

sinh() [1/3]

template<class T >

static constexpr auto pRC::sinh ( Complex< T > const &  a )

inlinestaticconstexpr

sinh() [2/3]

template<class T , If< IsFloat< T > > = 0>

static constexpr auto pRC::sinh ( T const  a )

inlinestaticconstexpr

Calculates the hyperbolic sine of a Float.

Calculates the hyperbolic sine of an Integer.

Template Parameters

T	Float class (inferred)

Parameters

a	object of class T

Template Parameters

T	Integer class (inferred)

Parameters

a	object of class T

sinh() [3/3]

template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Sinh >, X > > = 0>

static constexpr auto pRC::sinh ( X &&  a )

inlinestaticconstexpr

Calculates the element-wise hyperbolic sine of a Tensor.

Template Parameters

X	pRC tensorish class (inferred)

Parameters

a	object of class X

slice() [1/2]

template<Size... Es, class X , class... Os, class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< View, X > > = 0, If< All< IsConvertible< Os, Index >... > > = 0, If< IsSatisfied<(sizeof...(Es)==typename R::Dimension())> > = 0, If< IsSatisfied<(sizeof...(Os)==typename R::Dimension())> > = 0, If< IsSatisfied<(Sizes< Es... >()<=typename R::Sizes())> >

static constexpr auto pRC::slice ( X &&  a, Os const ...  offsets  )

inlinestaticconstexpr

Returns a specified slice of a Tensor.

The sizes of the slice along each dimension are specified by template parameters Es..., and the offsets are given as arguments. Given a Tensor a and offsets o1, o2, ..., the returned Tensor's elements are slice<Es...>(a, o1, o2, ...)(i, j, ...) = a(o1+i, o2+j, ...).

Template Parameters

Es...	parameter pack of class Size..., sizes of the Tensor slice
X	pRC tensorish class (inferred)

Parameters

a	object of class X
offsets...	parameter pack of classes convertible to Index..., offsets along the dimensions

slice() [2/2]

template<Size... Es, class X , class... Os, class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< Not< IsInvocable< View, X > > > = 0, If< IsInvocable< Slice< Es... >, X &, Os... > > = 0>

static constexpr auto pRC::slice ( X &&  a, Os const ...  offsets  )

inlinestaticconstexpr

Returns a specified slice of a Tensor.

The Sizes of the slice are specified by template parameters Es..., and the offsets are given as arguments. Given a Tensor a and offsets o1, o2, ..., the returned Tensor's elements are slice<Es...>(a, o1, o2, ...)(i, j, ...) = a(o1+i, o2+j, ...).

This function is used if the argument can not be represented as a TensorView.

Template Parameters

Es...	parameter pack of class Size..., sizes of the Tensor slice
X	pRC tensorish class (inferred)

Parameters

a	object of class X
offsets...	parameter pack of classes convertible to Index..., offsets along the dimensions

solve() [1/8]

template<Operator::Transform T = Operator::Transform::None, Operator::Restrict R = Operator::Restrict::None, Operator::Hint H = Operator::Hint::None, class Solver , class XA , class XB , If< IsInvocable< Solver, XA, XB > > = 0>

static constexpr decltype(auto) pRC::solve ( Solver &&  solver, XA &&  A, XB &&  b  )

inlinestaticconstexpr

solve() [2/8]

template<Operator::Transform T = Operator::Transform::None, Operator::Restrict R = Operator::Restrict::None, Operator::Hint H = Operator::Hint::None, class Solver , class XA , class XB , class VT , If< IsInvocable< Solver, XA, XB, VT > > = 0>

static constexpr decltype(auto) pRC::solve ( Solver &&  solver, XA &&  A, XB &&  b, VT const &  tolerance  )

inlinestaticconstexpr

solve() [3/8]

template<Operator::Transform T = Operator::Transform::None, Operator::Restrict R = Operator::Restrict::None, Operator::Hint H = Operator::Hint::None, class Solver , class XA , class XB , class XX , If< IsInvocable< Solver, XA, XB, XX > > = 0>

static constexpr decltype(auto) pRC::solve ( Solver &&  solver, XA &&  A, XB &&  b, XX &&  x0  )

inlinestaticconstexpr

solve() [4/8]

template<Operator::Transform T = Operator::Transform::None, Operator::Restrict R = Operator::Restrict::None, Operator::Hint H = Operator::Hint::None, class Solver , class XA , class XB , class XX , class VT , If< IsInvocable< Solver, XA, XB, XX, VT > > = 0>

static constexpr decltype(auto) pRC::solve ( Solver &&  solver, XA &&  A, XB &&  b, XX &&  x0, VT const &  tolerance  )

inlinestaticconstexpr

solve() [5/8]

template<class Solver , Operator::Transform T = Operator::Transform::None, Operator::Restrict R = Operator::Restrict::None, Operator::Hint H = Operator::Hint::None, class XA , class XB , If< IsInvocable< Solver, XA, XB > > = 0>

static constexpr decltype(auto) pRC::solve ( XA &&  A, XB &&  b  )

inlinestaticconstexpr

solve() [6/8]

template<class Solver , Operator::Transform T = Operator::Transform::None, Operator::Restrict R = Operator::Restrict::None, Operator::Hint H = Operator::Hint::None, class XA , class XB , class VT , If< IsInvocable< Solver, XA, XB, VT > > = 0>

static constexpr decltype(auto) pRC::solve ( XA &&  A, XB &&  b, VT const &  tolerance  )

inlinestaticconstexpr

solve() [7/8]

template<class Solver , Operator::Transform T = Operator::Transform::None, Operator::Restrict R = Operator::Restrict::None, Operator::Hint H = Operator::Hint::None, class XA , class XB , class XX , If< IsInvocable< Solver, XA, XB, XX > > = 0>

static constexpr decltype(auto) pRC::solve ( XA &&  A, XB &&  b, XX &&  x0  )

inlinestaticconstexpr

solve() [8/8]

template<class Solver , Operator::Transform T = Operator::Transform::None, Operator::Restrict R = Operator::Restrict::None, Operator::Hint H = Operator::Hint::None, class XA , class XB , class XX , class VT , If< IsInvocable< Solver, XA, XB, XX, VT > > = 0>

static constexpr decltype(auto) pRC::solve ( XA &&  A, XB &&  b, XX &&  x0, VT const &  tolerance  )

inlinestaticconstexpr

sort() [1/3]

template<class C , class T , If< IsSubscriptable< T > > = 0, class S = ResultOf<Subscript, T &, Index>, If< IsInvocable< C, S, S > > = 0, If< IsAssignable< S > > = 0>

static constexpr void pRC::sort ( C const &  compare, T &  a, Size const  k = T::size(), Size const  d = 0  )

inlinestaticconstexpr

sort() [2/3]

template<class F = Less, class T , T I, T... Is, If< IsInvocableResult< Bool, F, T, T > > = 0>

static constexpr auto pRC::sort ( Sequence< T, I, Is... > const  )

inlinestaticconstexpr

sort() [3/3]

template<class C = Less, class T , If< IsSubscriptable< T > > = 0, class S = ResultOf<Subscript, T &, Index>, If< IsInvocable< C, S, S > > = 0, If< IsAssignable< S > > = 0>

static constexpr void pRC::sort ( T &  a, Size const  k = T::size(), Size const  d = 0  )

inlinestaticconstexpr

sqrt() [1/3]

template<class T >

static constexpr auto pRC::sqrt ( Complex< T > const &  a )

inlinestaticconstexpr

sqrt() [2/3]

template<class T , If< IsFloat< T > > = 0>

static constexpr auto pRC::sqrt ( T const &  a )

inlinestaticconstexpr

Calculates the square root of a Float.

Calculates the square root of an Integer.

Template Parameters

T	Float class (inferred)

Parameters

a	object of class T

Template Parameters

T	Integer class (inferred)

Parameters

a	object of class T

sqrt() [3/3]

template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Sqrt >, X > > = 0>

static constexpr auto pRC::sqrt ( X &&  a )

inlinestaticconstexpr

Calculates the element-wise square root of a Tensor.

Template Parameters

X	pRC tensorish class (inferred)

Parameters

a	object of class X

square() [1/3]

template<class T , If< IsInvocable< Mul, T, T > > = 0, If< IsInvocable< Sub, T, T > > = 0>

static constexpr auto pRC::square ( Complex< T > const &  a )

inlinestaticconstexpr

square() [2/3]

template<class T , If< IsValue< T > > = 0>

static constexpr auto pRC::square ( T const &  a )

inlinestaticconstexpr

Calculates the square of a pRC value.

Template Parameters

T	pRC value class (inferred)

Parameters

a	object of class T

square() [3/3]

template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Square >, X > > = 0>

static constexpr auto pRC::square ( X &&  a )

inlinestaticconstexpr

Calculates the element-wise square of a Tensor.

Template Parameters

X	pRC tensorish class (inferred)

Parameters

a	object of class X

squeeze()

template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0>

static constexpr auto pRC::squeeze ( X &&  a )

inlinestaticconstexpr

Remove axes with mode size 1 from a Tensor.

Reshapes the Tensor into Sizes ommiting all 1s in the Tensor's Sizes.

Template Parameters

X	pRC tensorish class (inferred)

Parameters

a	object of class X

strictlyLowerTriangular()

template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< View, X > > = 0, If< IsSatisfied<(typename R::Dimension()==2)> > = 0>

static constexpr auto pRC::strictlyLowerTriangular ( X &&  a )

inlinestaticconstexpr

Transforms a Tensor into strictly lower triangular form.

Template Parameters

X	pRC tensorish class (inferred)

Parameters

a	object of class X

This function is used if the argument can not be represented as a TensorView.

Template Parameters

X	pRC tensorish class (inferred)

Parameters

a	object of class X

strictlyUpperTriangular()

template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< View, X > > = 0, If< IsSatisfied<(typename R::Dimension()==2)> > = 0>

static constexpr auto pRC::strictlyUpperTriangular ( X &&  a )

inlinestaticconstexpr

Transforms a Tensor into strictly upper triangular form.

Template Parameters

X	pRC tensorish class (inferred)

Parameters

a	object of class X

This function is used if the argument can not be represented as a TensorView.

Template Parameters

X	pRC tensorish class (inferred)

Parameters

a	object of class X

stride() [1/2]

template<Size... Ss, class X , class... Os, class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< View, X > > = 0, If< All< IsConvertible< Os, Index >... > > = 0, If< IsSatisfied<(sizeof...(Ss)==typename R::Dimension())> > = 0, If< IsSatisfied<(sizeof...(Os)==typename R::Dimension())> > = 0, If< IsSatisfied<(typename R::Sizes() % Sizes< Ss... >()==Constant< Size, 0 >())> >

static constexpr auto pRC::stride ( X &&  a, Os const ...  offsets  )

inlinestaticconstexpr

Constructs a Tensor by taking equally-sized steps through the input Tensor.

The step size in each direction is given as template parameters, the initial offsets are given as arguments. The mode sizes of the Tensor have to be divisible by the template parameters Ss.... Given step sizes S1, S2, ..., offsets o1, o2, ... and a Tensor a, the returned Tensor's elements are given by stride<S1, S2, ...>(a, o1, o2, ...)(i, j, ...) = a(o1+S1*i, o2+S2*j, ...).

Template Parameters

Ss...	parameter pack of class Size..., step sizes in each direction
X	pRC tensorish class (inferred)
Os...	parameter pack of classes convertible to Index (inferred)

Parameters

a	object of class X
offsets...	parameter pack of classes convertible to Index..., initial offsets

stride() [2/2]

template<Size... Ss, class X , class... Os, class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< Not< IsInvocable< View, X > > > = 0, If< IsInvocable< Stride< Ss... >, X &, Os... > > = 0>

static constexpr auto pRC::stride ( X &&  a, Os const ...  offsets  )

inlinestaticconstexpr

Splits a Tensor into equal sized blocks and returns one of them.

The number of blocks in each direction is given as template parameters, the position of the returned block is given as arguments. The mode sizes of the Tensor have to be divisible by the template parameters Ss.... Given block numbers S1, S2, ..., returned block position o1, o2, ... and a Tensor a, the returned Tensor's elements are given by stride<S1, S2, ...>(a, o1, o2, ...)(i, j, ...) = a(S1*o1+i, S2*o2+j, ...).

This function is used if the argument can not be represented as a TensorView.

Template Parameters

Ss...	parameter pack of class Size..., number of blocks along each axis
X	pRC tensorish class (inferred)

Parameters

a	object of class X
offsets...	parameter pack of classes convertible to Index..., position of the returned block

String() [1/2]

pRC::String

(

char const &

)

-> String< 1 >

String() [2/2]

template<Size N>

pRC::String

(

char

const(&)[N]

)

-> String< N - 1 >

svd() [1/2]

template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsFloat< typename R::Value > > = 0, If< IsSatisfied<(typename R::Dimension()==2)> > = 0>

static constexpr auto pRC::svd ( X &&  input )

inlinestaticconstexpr

svd() [2/2]

template<Size C, class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, class V = typename R::Value, class VT = V, If< All< IsFloat< V >, IsFloat< VT > > > = 0, If< IsSatisfied<(typename R::Dimension()==2)> > = 0, If< IsSatisfied<(C< min(R::size(0), R::size(1)))> > = 0>

static constexpr auto pRC::svd ( X &&  input, VT const &  tolerance = NumericLimits<VT>::tolerance()  )

inlinestaticconstexpr

swap()

template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< IsTensorish< RA > > = 0, If< IsInvocable< View, XA > > = 0, If< IsTensorish< RB > > = 0, If< IsInvocable< View, XB > > = 0, If< IsSame< typename RA::Sizes, typename RB::Sizes > > = 0, class EA = ResultOf<XA, typename RA::Subscripts>, class EB = ResultOf<XB, typename RB::Subscripts>, If< IsInvocable< Swap, EA, EB > > = 0>

static constexpr auto pRC::swap ( XA &&  a, XB &&  b  )

inlinestaticconstexpr

Swaps two Tensors.

Template Parameters

XA	pRC tensorish class (inferred)
XB	pRC tensorish class (inferred)

Parameters

a	object of class XA
b	object of class XB

tan() [1/3]

template<class T >

static constexpr auto pRC::tan ( Complex< T > const &  a )

inlinestaticconstexpr

tan() [2/3]

template<class T , If< IsFloat< T > > = 0>

static constexpr auto pRC::tan ( T const  a )

inlinestaticconstexpr

Calculates the tangent of a Float.

Template Parameters

T	Float class (inferred)

Parameters

a	object of class T

tan() [3/3]

template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Tan >, X > > = 0>

static constexpr auto pRC::tan ( X &&  a )

inlinestaticconstexpr

Calculates the element-wise tangent of a Tensor.

Template Parameters

X	pRC tensorish class (inferred)

Parameters

a	object of class X

tanh() [1/3]

template<class T >

static constexpr auto pRC::tanh ( Complex< T > const &  a )

inlinestaticconstexpr

tanh() [2/3]

template<class T , If< IsFloat< T > > = 0>

static constexpr auto pRC::tanh ( T const  a )

inlinestaticconstexpr

Calculates the hyperbolic tangent of a Float.

Template Parameters

T	Float class (inferred)

Parameters

a	object of class T

tanh() [3/3]

template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Tanh >, X > > = 0>

static constexpr auto pRC::tanh ( X &&  a )

inlinestaticconstexpr

Calculates the element-wise tangent hyperbolicus of a Tensor.

Template Parameters

X	pRC tensorish class (inferred)

Parameters

a	object of class X

Tensor() [1/5]

template<class T , Size... Ms, Size... Ns, class R >

pRC::Tensor

(

TensorTrain::Operator< T, Sizes< Ms... >, Sizes< Ns... >, R > const &

)

-> Tensor< T, Ms..., Ns... >

Tensor() [2/5]

template<class T , Size... Ms, Size... Ns, class R , class F >

pRC::Tensor

(

TensorTrain::OperatorViews::View< T, Sizes< Ms... >, Sizes< Ns... >, R, F > const &

)

-> Tensor< T, Ms..., Ns... >

Tensor() [3/5]

template<class T , Size... Ns, class R >

pRC::Tensor

(

TensorTrain::Tensor< T, Sizes< Ns... >, R > const &

)

-> Tensor< T, Ns... >

Tensor() [4/5]

template<class T , Size... Ns, class R , class F >

pRC::Tensor

(

TensorTrain::TensorViews::View< T, Sizes< Ns... >, R, F > const &

)

-> Tensor< T, Ns... >

Tensor() [5/5]

template<class F , class T , Size... Ns>

pRC::Tensor

(

TensorViews::View< T, Sizes< Ns... >, F > const &

)

-> Tensor< T, Ns... >

tensorProduct() [1/2]

template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< IsTensorish< RA > > = 0, If< IsInvocable< View, XA > > = 0, If< IsTensorish< RB > > = 0, If< IsInvocable< View, XB > > = 0, class EA = ResultOf<XA, typename RA::Subscripts>, class EB = ResultOf<XB, typename RB::Subscripts>, If< IsInvocable< Mul, EA, EB > > = 0>

static constexpr auto pRC::tensorProduct ( XA &&  a, XB &&  b  )

inlinestaticconstexpr

Calculates the tensor product of two Tensors.

The definition of the tensor product can be seen on Wikipedia.

Template Parameters

XA	pRC tensorish class (inferred)
XB	pRC tensorish class (inferred)

Parameters

a	object of class XA
b	object of class XB

tensorProduct() [2/2]

template<class XA , class XB , class RA = RemoveReference<XA>, class RB = RemoveReference<XB>, If< IsTensorish< RA > > = 0, If< IsTensorish< RB > > = 0, If< Not< All< IsInvocable< View, XA >, IsInvocable< View, XB > > > > = 0, If< IsInvocable< TensorProduct, XA &, XB & > > = 0>

static constexpr auto pRC::tensorProduct ( XA &&  a, XB &&  b  )

inlinestaticconstexpr

Calculates the tensor product of two Tensors.

The definition of the tensor product can be seen on Wikipedia.

This function is used if the argument can not be represented as a TensorView.

Template Parameters

XA	pRC tensorish class (inferred)
XB	pRC tensorish class (inferred)

Parameters

a	object of class XA
b	object of class XB

trace() [1/2]

template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< View, X > > = 0, If< IsInvocable< ExtractDiagonal, X > > = 0, If< IsInvocable< Reduce< Add >, ResultOf< ExtractDiagonal, X > > > = 0>

static constexpr auto pRC::trace ( X &&  a )

inlinestaticconstexpr

Calculates the trace of a Tensor.

The trace of a Tensor is defined as the sum of its diagonal.

Template Parameters

X	pRC tensorish class (inferred)

Parameters

a	object of class X

trace() [2/2]

template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< Not< IsInvocable< View, X > > > = 0, If< IsInvocable< Trace, X & > > = 0>

static constexpr auto pRC::trace ( X &&  a )

inlinestaticconstexpr

Calculates the trace of a Tensor.

The trace of a Tensor is defined as the sum of its diagonal.

This function is used if the argument can not be represented as a TensorView.

Template Parameters

X	pRC tensorish class (inferred)

Parameters

a	object of class X

transform() [1/2]

template<Operator::Transform OT = Operator::Transform::None, class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0>

static constexpr decltype(auto) pRC::transform ( X &&  a )

inlinestaticconstexpr

Applies a transformation to a Tensor.

Template Parameters

OT	enumerator from Operator::Transform (default is Operator::Transform::None)
X	pRC tensorish class (inferred)

Parameters

a	object of class X

transform() [2/2]

template<Operator::Transform OT = Operator::Transform::None, class X , class R = RemoveReference<X>, If< TensorTrain::IsOperatorish< R > > = 0>

static constexpr decltype(auto) pRC::transform ( X &&  a )

inlinestaticconstexpr

transpose() [1/3]

template<class T >

static constexpr auto pRC::transpose ( JacobiRotation< T > const &  a )

inlinestaticconstexpr

transpose() [2/3]

template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsSatisfied<(isEven(typename R::Dimension()))> > = 0>

static constexpr auto pRC::transpose ( X &&  a )

inlinestaticconstexpr

Calculates the transposed of a Tensor.

Template Parameters

X	pRC tensorish class (inferred)

Parameters

a	object of class X

transpose() [3/3]

template<class X , class R = RemoveReference<X>, If< TensorTrain::IsOperatorish< R > > = 0, If< IsInvocable< Loop< Permute< 0, 2, 1, 3 > >, X > > = 0>

static constexpr auto pRC::transpose ( X &&  a )

inlinestaticconstexpr

trim()

template<Index I, Index L, class T , T... Is, If< IsSatisfied<(L<=sizeof...(Is))> > = 0, If< IsSatisfied<(I< L)> > = 0>

static constexpr auto pRC::trim ( Sequence< T, Is... > const  )

inlinestaticconstexpr

trunc() [1/3]

template<class T , If< IsInvocable< Trunc, T > > = 0>

static constexpr auto pRC::trunc ( Complex< T > const &  a )

inlinestaticconstexpr

trunc() [2/3]

template<class T , If< IsFloat< T > > = 0>

static constexpr auto pRC::trunc ( T const &  a )

inlinestaticconstexpr

Truncates the fractional part of a Float.

Truncates the fractional part of an Integer.

Computes the nearest integer not greater in magnitude than the passed value.

Template Parameters

T	Float class (inferred)

Parameters

a	object of class T, object to be rounded

This function just returns the input and is only implemented for consistency reasons.

Template Parameters

T	Float class (inferred)

Parameters

a	object of class T, object to be rounded

trunc() [3/3]

template<class X , If< IsTensorish< RemoveReference< X > > > = 0, If< IsInvocable< Loop< Trunc >, X > > = 0>

static constexpr auto pRC::trunc ( X &&  a )

inlinestaticconstexpr

Truncates element-wise the fractional part of a Tensor.

Template Parameters

X	pRC tensorish class (inferred)

Parameters

a	object of class X

truncate()

template<Size C, Position P, class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, class V = typename R::Value, class VT = V, If< All< IsFloat< V >, IsFloat< VT > > > = 0, If< IsSatisfied<(P==Position::Left||P==Position::Right)> > = 0>

static constexpr auto pRC::truncate ( X &&  a, VT const &  tolerance = NumericLimits<VT>::epsilon()  )

inlinestaticconstexpr

unfolding()

template<Index K, class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsSatisfied<(typename R::Dimension{} > 1)> , If< IsSatisfied<(K+1< typename R::Dimension{})> > = 0, If< IsInvocable< Reshape< R::size(K), R::Sizes::size()/R::size(K)>, X > > = 0>

static constexpr auto pRC::unfolding ( X &&  a )

inlinestaticconstexpr

Reshapes a Tensor into a matrix.

The returned Tensor has two axes. The first mode size is the product of the first K axes of the input Tensor. The second mode size is the product of the remaining mode sizes.

Template Parameters

K	Index, last axis that is used for the first axis of the returned 2-dimensional Tensor (matrix)
X	pRC tensorish class (inferred)

Parameters

a	object of class X

unit() [1/3]

template<class T , If< IsDefined< Unit< T > > > = 0, If< IsConstructible< Unit< T > > > = 0, If< IsInvocable< Unit< T > > > = 0>

static constexpr auto pRC::unit ( )

inlinestaticconstexpr

unit() [2/3]

static constexpr auto pRC::unit ( )

inlinestaticconstexpr

unit() [3/3]

template<class T , class X , If< IsDefined< Unit< T > > > = 0, If< IsConstructible< Unit< T > > > = 0, If< IsInvocable< Unit< T >, X > > = 0>

static constexpr auto pRC::unit ( X &&  value )

inlinestaticconstexpr

unitLowerTriangular()

template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< View, X > > = 0, If< IsSatisfied<(typename R::Dimension()==2)> > = 0>

static constexpr auto pRC::unitLowerTriangular ( X &&  a )

inlinestaticconstexpr

Transforms a Tensor into unit lower triangular form.

Template Parameters

X	pRC tensorish class (inferred)

Parameters

a	object of class X

This function is used if the argument can not be represented as a TensorView.

Template Parameters

X	pRC tensorish class (inferred)

Parameters

a	object of class X

unitUpperTriangular()

template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< View, X > > = 0, If< IsSatisfied<(typename R::Dimension()==2)> > = 0>

static constexpr auto pRC::unitUpperTriangular ( X &&  a )

inlinestaticconstexpr

Transforms a Tensor into unit upper triangular form.

Template Parameters

X	pRC tensorish class (inferred)

Parameters

a	object of class X

This function is used if the argument can not be represented as a TensorView.

Template Parameters

X	pRC tensorish class (inferred)

Parameters

a	object of class X

upperTriangular()

template<class X , class R = RemoveReference<X>, If< IsTensorish< R > > = 0, If< IsInvocable< View, X > > = 0, If< IsSatisfied<(typename R::Dimension()==2)> > = 0>

static constexpr auto pRC::upperTriangular ( X &&  a )

inlinestaticconstexpr

Transforms a Tensor into upper triangular form.

Template Parameters

X	pRC tensorish class (inferred)

Parameters

a	object of class X

This function is used if the argument can not be represented as a TensorView.

Template Parameters

X	pRC tensorish class (inferred)

Parameters

a	object of class X

view() [1/12]

template<class T , Size... Ns>

static constexpr auto pRC::view ( Tensor< T, Ns... > &  a )

inlinestaticconstexpr

Returns a TensorView obtained from a Tensor.

Template Parameters

T	pRC value class of the Tensor (inferred)
Ns...	parameter pack of class Size..., mode sizes of the Tensor (inferred)

Parameters

a	object of class Tensor<T, Ns...>

view() [2/12]

template<class T , Size... Ns>

static constexpr auto pRC::view ( Tensor< T, Ns... > const &&  )

inlinestaticconstexprdelete

A TensorView can not be created from an rvalue Tensor.

view() [3/12]

template<class T , Size... Ns>

static constexpr auto pRC::view ( Tensor< T, Ns... > const &  a )

inlinestaticconstexpr

Returns a TensorView obtained from a const Tensor.

Template Parameters

T	pRC value class of the Tensor (inferred)
Ns...	parameter pack of class Size..., mode sizes of the Tensor (inferred)

Parameters

a	object of class Tensor<T, Ns...> const

view() [4/12]

template<class T , class M , class N , class R >

static constexpr auto pRC::view ( TensorTrain::Operator< T, M, N, R > &  a )

inlinestaticconstexpr

view() [5/12]

template<class T , class M , class N , class R >

static constexpr auto pRC::view ( TensorTrain::Operator< T, M, N, R > const &&  )

inlinestaticconstexprdelete

view() [6/12]

template<class T , class M , class N , class R >

static constexpr auto pRC::view ( TensorTrain::Operator< T, M, N, R > const &  a )

inlinestaticconstexpr

view() [7/12]

template<class T , class N , class R >

static constexpr auto pRC::view ( TensorTrain::Tensor< T, N, R > &  a )

inlinestaticconstexpr

view() [8/12]

template<class T , class N , class R >

static constexpr auto pRC::view ( TensorTrain::Tensor< T, N, R > const &&  )

inlinestaticconstexprdelete

view() [9/12]

template<class T , class N , class R >

static constexpr auto pRC::view ( TensorTrain::Tensor< T, N, R > const &  a )

inlinestaticconstexpr

view() [10/12]

template<class X , If< IsTensorView< RemoveReference< X > > > = 0>

static constexpr X pRC::view ( X &&  a )

inlinestaticconstexpr

Returns a TensorView obtained from a TensorView.

This function just forwards the argument and is only implemented for consistency reasons.

Template Parameters

X	pRC TensorView class (inferred)

Parameters

a	object of class X

view() [11/12]

template<class X , If< TensorTrain::IsOperatorView< RemoveReference< X > > > = 0>

static constexpr X pRC::view ( X &&  a )

inlinestaticconstexpr

view() [12/12]

template<class X , If< TensorTrain::IsTensorView< RemoveReference< X > > > = 0>

static constexpr X pRC::view ( X &&  a )

inlinestaticconstexpr

where() [1/5]

template<class TE , class T , If< IsBool< TE > > = 0>

static constexpr T pRC::where ( TE const  e, T &&  a, T &&  b  )

inlinestaticconstexpr

where() [2/5]

template<class TE , class T , If< IsBool< TE > > = 0>

static constexpr T const & pRC::where ( TE const  e, T &  a, T const &  b  )

inlinestaticconstexpr

where() [3/5]

template<class TE , class T , If< IsBool< TE > > = 0>

static constexpr T const & pRC::where ( TE const  e, T const &  a, T &  b  )

inlinestaticconstexpr

where() [4/5]

template<class TE , class XA , class XB , If< IsBool< TE > > = 0>

static constexpr auto pRC::where ( TE const  e, XA &&  a, XB &&  b  )

inlinestaticconstexpr

where() [5/5]

template<class XE , class XA , class XB , If< IsTensorish< RemoveReference< XE > > > = 0, If< IsTensorish< RemoveReference< XA > > > = 0, If< IsTensorish< RemoveReference< XB > > > = 0, If< IsInvocable< Loop< Where >, XE, XA, XB > > = 0>

static constexpr auto pRC::where ( XE &&  e, XA &&  a, XB &&  b  )

inlinestaticconstexpr

Uses a mask to choose element-wise which of two Tensors' element to return.

This function takes three Tensors of the same shape as arguments. The first Tensor's value type has to be Bool. Each of the returned Tensor's elements is chosen from a if the corresponding element in e is true, otherwise it is taken from b.

Template Parameters

XE	pRC tensorish class with value type Bool (inferred)
XA	pRC tensorish class (inferred)
XB	pRC tensorish class (inferred)

Parameters

e	object of class XE
a	object of class XA
b	object of class XB

zero() [1/2]

template<class T , If< IsDefined< Zero< T > > > = 0, If< IsConstructible< Zero< T > > > = 0, If< IsInvocable< Zero< T > > > = 0>

static constexpr auto pRC::zero ( )

inlinestaticconstexpr

zero() [2/2]

static constexpr auto pRC::zero ( )

inlinestaticconstexpr

zip()

template<Index O = 0, class T , T... Is, class... Seqs, If< IsSatisfied<((Sequence< T, Is... >::size()==Seqs::size()) &&...)> >

static constexpr auto pRC::zip ( Sequence< T, Is... > const  , Seqs  const ...  )

inlinestaticconstexpr

Variable Documentation

cCacheLineSizeByte

constexpr Size pRC::cCacheLineSizeByte = 64

constexpr

cDebugLevel

constexpr auto pRC::cDebugLevel = DebugLevel::Low

constexpr

cHugepageSizeByte

constexpr Size pRC::cHugepageSizeByte = 2 * 1024 * 1024

constexpr

cLogLevel

constexpr auto pRC::cLogLevel = LogLevel::Info

constexpr

cPageSizeByte

constexpr Size pRC::cPageSizeByte = 4 * 1024

constexpr

cSimdSizeByte

constexpr Size pRC::cSimdSizeByte

constexpr

Initial value:

=
 
 
 
 
 
        16

isDefined

False pRC::isDefined(...)

(

...

)