The main namespace of the VCTR project. More...

Namespaces
namespace	juce_helpers
	Helper functions to integrate vctr into dsp code written with JUCE (https://github.com/juce-framework/JUCE).

Classes
class	AlignedAllocator
	Returns aligned pointers when allocations are requested. More...

class	Array
	The stack-based container type. More...

struct	AVXRegister

struct	CombinedStorageInfo

struct	CombinedStorageInfo< First, Others... >

struct	Config

struct	Constant
	A helper struct to pass a constant as argument wrapped in a struct with a single public static constexpr member variable named value. More...

struct	ConstantRangeEnd
	Evaluates the return value of getEnd called on the constant reference template argument and wraps that in a struct with a single public static constexpr member variable named value. More...

struct	ConstantRangeStart
	Evaluates the return value of getStart called on the constant reference template argument and wraps that in a struct with a single public static constexpr member variable named value. More...

struct	CPUInstructionSets

struct	dBFS
	Decibel constant dbFS to be passed to dbToMag or magToDb. More...

struct	dBPower
	Decibel constant dbPower to be passed to dbToMag or magToDb. More...

struct	dBVoltage
	Decibel constant dbVoltage to be passed to dbToMag or magToDb. More...

struct	DefaultVectorAllocator
	The default allocator choice for non-arithmetic types is a simple std::allocator. More...

struct	DefaultVectorAllocator< ElementType >
	The default allocator choice for arithmetic types is an AlignedAllocator. More...

struct	DisabledConstant
	A helper struct to indicate that a constant template should be considered disabled. More...

struct	ExpressionChainBuilderWithRuntimeArgs
	An expression chain builder is an object which supplies various operator<< overloads which build chains of Expression Templates by prepending the templated ExpressionType to the source. More...

struct	ExpressionTemplateBase
	The base class to every expression template. More...

struct	NeonRegister

class	OwnedArray
	A handy shortcut for Array<std::unique_ptr<OwnedElementType>, n>. More...

class	OwnedVector
	A handy shortcut for Vector<std::unique_ptr<OwnedElementType>>. More...

class	Range
	A simple range class. More...

class	ReductionExpression
	A collection of static functions used to evaluate reduction expressions. More...

struct	RequireConstexpr
	A helper struct intended to check if a value is a constexpr. More...

class	Span
	The view type. More...

struct	SSERegister

struct	StaticStorageInfo
	A storage info type especially used to pass compile time constant traits when viewing externally owned memory via a Span in case we know that the viewed memory will fulfil certain traits. More...

struct	StorageInfo
	A helper class to describe some properties regarding the storage class wrapped in a VctrBase instance. More...

struct	StorageInfo< detail::VectorBoolWorkaround< Allocator > >

struct	StorageInfo< std::array< ElementType, size > >

struct	StorageInfo< std::vector< ElementType, AlignedAllocator< ElementType, alignmentInBytes > > >

struct	StorageInfo< StorageType >

struct	StorageInfoWithMemberAlignment
	A storage info type especially used for vctr::Span. More...

class	VctrBase
	The base class to all one dimensional containers and views in the VCTR project. More...

class	Vector
	The heap-allocated container type. More...

Typedefs
template<class ElementType , bool isDataSIMDAligned, bool isStorageSIMDExtended = false>
using	SpanStorageInfo = StaticStorageInfo< isDataSIMDAligned, isStorageSIMDExtended, alignof(std::span< ElementType >)>
	A StaticStorageInfo type alias suitable for vctr::Span.

template<template< size_t, class... > class ExpressionType, class... AdditionalCompileTimeParameters>
using	ExpressionChainBuilder = ExpressionChainBuilderWithRuntimeArgs< ExpressionType, detail::RuntimeArgChain< std::tuple<> >, AdditionalCompileTimeParameters... >
	Convenient typedef to create a simple expression chain builder instance for an expression template.

template<class A , class B , auto op>
using	CommonVecExpressionType = typename detail::CommonVecExpressionType< A, B, op >::type
	Used to figure out the value_type for binary vector-vector operations.

template<class T >
using	ValueType = typename detail::ValueType< std::remove_cvref_t< T > >::Type
	If T is an expression template, it equals its return type, if it's a type that defines value_type as a public typedef, it equals value_type.

template<class T >
using	DataType = typename detail::DataType< std::remove_reference_t< T > >::Type
	The const correct element type derived from a call to T::data.

template<is::number T>
using	RealType = typename detail::RealType< std::remove_cvref_t< T > >::Type
	If T is any instance of std::complex, this will be the real value_type, otherwise this will be T.

template<is::realNumber T>
using	FloatType = typename detail::FloatType< std::remove_cvref_t< T > >::Type
	The best matching float type for the real number type T.

template<has::sizeAndData T>
using	StorageInfoType = typename detail::StorageInfoType< std::remove_cvref_t< T > >::Type
	If t is a type derived from VctrBase, this will equal the return value of T::getStorageInfo, otherwise this will be StorageInfo<T>.

Enumerations
enum class	CompareOp : int { less = _CMP_LT_OQ , lessOrEqual = _CMP_LE_OQ , greater = _CMP_GT_OQ , greaterOrEqual = _CMP_GE_OQ , equal = _CMP_EQ_OQ , notEqual = _CMP_NEQ_OQ }
	Possible types of (SIMD) compare operations. More...

Functions
template<class OtherElementType , size_t otherSize>
	Array (std::array< OtherElementType, otherSize > &&) -> Array< OtherElementType, otherSize, otherSize >

template<class First , is::suitableInitializerForElementType< std::remove_cvref_t< First > >... Other>
	Array (First &&, Other &&...) -> Array< std::remove_cvref_t< First >, sizeof...(Other)+1 >

template<class SingleArg >
	Array (SingleArg &&) -> Array< typename detail::SingleArgDeductionHelper< SingleArg >::Type, detail::SingleArgDeductionHelper< SingleArg >::extent >

template<class Pointer , std::same_as< Pointer >... Pointers>
	OwnedArray (Pointer , Pointers ...) -> OwnedArray< Pointer, sizeof...(Pointers)+1 >

template<class ElementType >
consteval auto	simdAlignedSpanStorageInfo ()
	Creates a StaticStorageInfo instance suitable to be passed to a Span constructor.

template<class ElementType , bool isDataSIMDAligned, bool isStorageSIMDExtended>
	Span (ElementType *, size_t, const StaticStorageInfo< isDataSIMDAligned, isStorageSIMDExtended, alignof(std::span< ElementType >)> &) -> Span< ElementType, std::dynamic_extent, StaticStorageInfo< isDataSIMDAligned, isStorageSIMDExtended, alignof(std::span< ElementType >)> >

template<class Container >
	Span (Container &&) -> Span< DataType< Container >, extentOf< Container >, StorageInfoWithMemberAlignment< alignof(std::span< DataType< Container >, extentOf< Container > >), StorageInfoType< Container > > >

template<class ElementType , size_t size>
	Span (ElementType(&)[size]) -> Span< ElementType, size, StorageInfoWithMemberAlignment< alignof(std::span< ElementType, size >), StorageInfo< std::span< ElementType, size > > > >

template<class ElementType >
auto	makeSimdAlignedSpan (ElementType *data, size_t size)
	Creates a span with dynamic extent pointing to a memory location that is expected to be SIMD aligned.

template<size_t extent, class ElementType > requires (extent != std::dynamic_extent)
auto	makeSimdAlignedSpan (ElementType *data)
	Creates a span with static extent pointing to a memory location that is expected to be SIMD aligned.

template<is::anyVctr Lhs, is::anyVctr Rhs> requires std::same_as<ValueType<Lhs>, ValueType<Rhs>>
constexpr bool	operator== (const Lhs &lhs, const Rhs &rhs)
	Compares lhs and rhs for equality.

template<is::triviallyCopyableWithDataAndSize OtherContainer>
	Vector (const OtherContainer &other) -> Vector< ValueType< OtherContainer > >

template<std::input_iterator Iterator, std::sentinel_for< Iterator > Sentinel>
	Vector (Iterator first, Sentinel last) -> Vector< std::iter_value_t< Iterator > >

template<is::suitableInitializerFunction Fn>
	Vector (size_t size, Fn &&initializerFunction) -> Vector< std::invoke_result_t< Fn, size_t > >

template<is::expression Expression>
	Vector (Expression &&e) -> Vector< ValueType< Expression > >

template<is::uniquePtr FirstArg, is::uniquePtr... Args> requires (are::same<FirstArg, Args...>)
	OwnedVector (FirstArg &&, Args &&...) -> OwnedVector< typename FirstArg::element_type >

template<is::anyVctrOrExpression SrcAType, is::anyVctrOrExpression SrcBType>
constexpr auto	operator+ (SrcAType &&a, SrcBType &&b)
	Returns an expression that adds two vector or expression sources.

template<is::anyVctrOrExpression Src>
constexpr auto	operator+ (typename std::remove_cvref_t< Src >::value_type single, Src &&vec)
	Returns an expression that adds a single value to a vector or expression source.

template<is::anyVctrOrExpression Src>
constexpr auto	operator+ (Src &&vec, typename std::remove_cvref_t< Src >::value_type single)
	Returns an expression that adds a vector or expression source to a single value.

template<class T >
constexpr auto	clampLow (T lowerBound)
	Ensures that the elements are not lower than lowerBound.

template<class T >
constexpr auto	clampHigh (T upperBound)
	Ensures that the elements are not greater than upperBound.

template<class T >
constexpr auto	clamp (T lowerBound, T upperBound)
	Ensures that the elements are not lower than lowerBound and not higher than upperBound.

template<is::range Range>
constexpr auto	clamp (const Range &range)
	Ensures that the elements are within the range.

template<class SrcAType , class SrcBType > requires (is::anyVctrOrExpression<std::remove_cvref_t<SrcAType>> && is::anyVctrOrExpression<std::remove_cvref_t<SrcBType>>)
constexpr auto	operator/ (SrcAType &&a, SrcBType &&b)
	Returns an expression that divides vector or expression a by vector or expression b.

template<class Src > requires is::anyVctrOrExpression<Src>
constexpr auto	operator/ (typename std::remove_cvref_t< Src >::value_type single, Src &&vec)
	Returns an expression that divides a single value by a vector or expression source.

template<class Src > requires is::anyVctrOrExpression<Src>
constexpr auto	operator/ (Src &&vec, typename std::remove_cvref_t< Src >::value_type single)
	Returns an expression that divides a vector or expression source by a single value.

template<class SrcAType , class SrcBType > requires (is::anyVctrOrExpression<std::remove_cvref_t<SrcAType>> && is::anyVctrOrExpression<std::remove_cvref_t<SrcBType>>)
constexpr auto	operator* (SrcAType &&a, SrcBType &&b)
	Returns an expression that multiplies vector or expression a with vector or expression b.

template<class Src > requires is::anyVctrOrExpression<Src>
constexpr auto	operator* (typename std::remove_cvref_t< Src >::value_type single, Src &&vec)
	Returns an expression that multiplies a single value with a vector or expression source.

template<class Src > requires is::anyVctrOrExpression<Src>
constexpr auto	operator* (Src &&vec, typename std::remove_cvref_t< Src >::value_type single)
	Returns an expression that multiplies a vector or expression source with a single value.

template<class SrcAType , class SrcBType , class SrcCType > requires (is::anyVctrOrExpression<std::remove_cvref_t<SrcAType>> && is::anyVctrOrExpression<std::remove_cvref_t<SrcBType>> && is::anyVctrOrExpression<std::remove_cvref_t<SrcCType>>)
constexpr auto	multiplyAccumulate (SrcAType &&a, SrcBType &&b, SrcCType &&c)
	Computes the multiply-accumulate operation (a * b) + c.

template<class SrcAType , class SrcBType , class SrcCType > requires (is::anyVctrOrExpression<std::remove_cvref_t<SrcAType>> && is::anyVctrOrExpression<std::remove_cvref_t<SrcBType>> && is::anyVctrOrExpression<std::remove_cvref_t<SrcCType>>)
constexpr auto	multiplySubtract (SrcAType &&a, SrcBType &&b, SrcCType &&c)
	Computes the multiply-subtract operation c - (a * b).

template<class SrcAType , class SrcBType > requires (is::anyVctrOrExpression<std::remove_cvref_t<SrcAType>> && is::anyVctrOrExpression<std::remove_cvref_t<SrcBType>>)
constexpr auto	operator- (SrcAType &&a, SrcBType &&b)
	Returns an expression that subtracts vector or expression b from vector or expression a.

template<class Src > requires is::anyVctrOrExpression<Src>
constexpr auto	operator- (typename std::remove_cvref_t< Src >::value_type single, Src &&vec)
	Returns an expression that subtracts a vector or expression source from a single value.

template<class Src > requires is::anyVctrOrExpression<Src>
constexpr auto	operator- (Src &&vec, typename std::remove_cvref_t< Src >::value_type single)
	Returns an expression that subtracts a single value from a vector or expression.

template<is::anyVctrOrExpression SrcBaseType, is::anyVctrOrExpression SrcExpType>
constexpr auto	pow (SrcBaseType &&bases, SrcExpType &&exponents)
	Returns an expression that raises the elements in bases element-wise to the power of the elements in exponents.

template<is::anyVctrOrExpression Src>
constexpr auto	pow (typename std::remove_cvref_t< Src >::value_type base, Src &&exponents)
	Returns an expression that raises the base value base to the power of the elements in exponents.

template<is::anyVctrOrExpression Src>
constexpr auto	pow (Src &&bases, typename std::remove_cvref_t< Src >::value_type exponent)
	Returns an expression that raises the elements in bases to the power of the exponent value.

template<template< size_t, class... > class ExpressionType, class... RuntimeArgs> requires (sizeof... (RuntimeArgs) > 0)
constexpr auto	makeExpressionChainBuilderWithRuntimeArgs (RuntimeArgs... runtimeArgs)
	Helper function to build factory functions for expressions that rely on runtime argument values.

template<template< size_t, class... > class ExpressionType, class ExpressionTemplateArg , class... RuntimeArgs> requires (sizeof... (RuntimeArgs) > 0)
constexpr auto	makeTemplateExpressionChainBuilderWithRuntimeArgs (RuntimeArgs... runtimeArgs)
	Helper function to build factory functions for expressions that rely on runtime argument values.

template<is::range RangeType>
auto	map (RangeType &&srcValueRange, RangeType &&dstValueRange)
	Maps all source element values from srcValueRange to values in dstValueRange.

template<is::realFloatNumber T>
auto	map (T srcValueRangeStart, T srcValueRangeEnd, T dstValueRangeStart, T dstValueRangeEnd)
	Maps all source element values from the range srcValueRangeStart to srcValueRangeEnd to values in [dstValueRangeStart, dstValueRangeEnd].

template<is::range RangeType>
auto	mapFrom0To1 (RangeType &&dstValueRange)
	Maps all source element values from the range [0.0 to 1.0] to values in dstValueRange.

template<is::realFloatNumber T>
auto	mapFrom0To1 (T dstValueRangeStart, T dstValueRangeEnd)
	Maps all source element values from the range [0.0 to 1.0] to values in the range from [dstValueRangeStart to dstValueRangeEnd].

template<is::range RangeType>
auto	mapTo0To1 (RangeType &&srcValueRange)
	Maps all source element values from srcValueRange to values in the range [0.0 to 1.0].

template<is::realFloatNumber T>
auto	mapTo0To1 (T srcValueRangeStart, T srcValueRangeEnd)
	Maps all source element values from teh range [srcValueRangeStart to srcValueRangeEnd] to values in the range [0.0 to 1.0].

template<class Fn >
constexpr auto	transformedBy (Fn &&fn)
	Transforms all source elements by applying fn to them.

template<class ElementType , size_t alignmentInBytesLHS, size_t alignmentInBytesRHS>
constexpr bool	operator== (const AlignedAllocator< ElementType, alignmentInBytesLHS > &, const AlignedAllocator< ElementType, alignmentInBytesRHS > &)

CPUInstructionSets	getSupportedCPUInstructionSets ()

template<is::anyVctrOrExpression V>
std::ostream &	operator<< (std::ostream &s, const V &vec)

int	sizeToInt (size_t size)
	Casts the size_t argument to an int.

template<uintptr_t requiredAlignment = Config::maxSIMDRegisterSize>
constexpr bool	isPtrAligned (const void *ptr)
	Helper function to check if a pointer is aligned to the required alignment value.

template<class First , class... Other>
consteval size_t	getCommonExtent ()
	Returns std::dynamic_extent in case all the sources specify a dynamic extent.

template<class A , class B >
constexpr void	assertCommonSize (const A &a, const B &b)
	Ensures that both sources have the same size.

template<class A , class B , class C >
constexpr void	assertCommonSize (const A &a, const B &b, const C &c)
	Ensures that all three sources have the same size.

template<class T >
consteval std::string_view	typeName ()
	Returns a string containing the templates type name.

template<>
consteval std::string_view	typeName< void > ()

template<>
consteval std::string_view	typeName< int8_t > ()

template<>
consteval std::string_view	typeName< uint8_t > ()

template<>
consteval std::string_view	typeName< int16_t > ()

template<>
consteval std::string_view	typeName< uint16_t > ()

template<>
consteval std::string_view	typeName< int32_t > ()

template<>
consteval std::string_view	typeName< uint32_t > ()

template<>
consteval std::string_view	typeName< int64_t > ()

template<>
consteval std::string_view	typeName< uint64_t > ()

template<class T >
consteval std::string_view	typeName (const T &)

template<class R , class Arg , R(*)(Arg) fn>
consteval std::string_view	functionName ()
	Returns the name for a function with a single argument.

template<class R , class ArgA , class ArgB , R(*)(ArgA, ArgB) fn>
consteval std::string_view	functionName ()
	Returns the name for a function with two arguments.

Variables
constexpr ExpressionChainBuilder< expressions::Abs >	abs
	Computes the absolute value of the source values.

template<auto constantValue>
constexpr ExpressionChainBuilder< expressions::AddConstantToVec, Constant< constantValue > >	addConstant
	Returns an expression that adds a compile time constant to a vector or expression source.

template<auto lowerBound>
constexpr ExpressionChainBuilder< expressions::ClampByConstant, Constant< lowerBound >, DisabledConstant >	clampLowByConstant
	Ensures that the elements are not lower than lowerBound.

template<auto upperBound>
constexpr ExpressionChainBuilder< expressions::ClampByConstant, DisabledConstant, Constant< upperBound > >	clampHighByConstant
	Ensures that the elements are not higher than upperBound.

template<auto lowerBound, auto upperBound>
constexpr ExpressionChainBuilder< expressions::ClampByConstant, Constant< lowerBound >, Constant< upperBound > >	clampByConstant
	Ensures that the elements are not lower than lowerBound and not higher than upperBound.

template<const auto & range>
constexpr ExpressionChainBuilder< expressions::ClampByConstant, ConstantRangeStart< range >, ConstantRangeEnd< range > >	clampToRange
	Ensures that the elements are within the range.

constexpr ExpressionChainBuilder< expressions::Cube >	cube
	Raises the source values to the power of three.

constexpr ExpressionChainBuilder< expressions::Max >	max
	Computes the maximum value of the source values.

constexpr ExpressionChainBuilder< expressions::MaxAbs >	maxAbs
	Computes the maximum value of the absolute value of the source values.

constexpr ExpressionChainBuilder< expressions::Mean >	mean
	Computes the mean value of the source values.

constexpr ExpressionChainBuilder< expressions::MeanSquare >	meanSquare
	Computes the mean value of the squared source values.

constexpr ExpressionChainBuilder< expressions::RootMeanSquare >	rms
	Computes the square root of the mean value of the squared source values.

constexpr ExpressionChainBuilder< expressions::Min >	min
	Computes the minimum value of the source values.

constexpr ExpressionChainBuilder< expressions::MinAbs >	minAbs
	Computes the minimum value of the absolute value of the source values.

template<auto constantValue>
constexpr ExpressionChainBuilder< expressions::MultiplyVecByConstant, Constant< constantValue > >	multiplyByConstant
	Returns an expression that multiplies a vector or expression source with a compile time constant.

constexpr ExpressionChainBuilder< expressions::NormalizeSum >	normalizeSum
	Computes the sum of the source elements and divides all source elements by that sum.

constexpr ExpressionChainBuilder< expressions::Sqrt >	sqrt
	Computes the square root of the source values.

constexpr ExpressionChainBuilder< expressions::Square >	square
	Squares the source values.

constexpr ExpressionChainBuilder< expressions::Sum >	sum
	Computes the sum of the source values.

constexpr ExpressionChainBuilder< expressions::Angle >	angle
	Computes the phase angles of the complex source values.

constexpr ExpressionChainBuilder< expressions::Conjugate >	conjugate
	Computes the complex conjugate of the source values.

constexpr ExpressionChainBuilder< expressions::Imag >	imag
	Extracts the imaginary parts of the complex source values.

constexpr ExpressionChainBuilder< expressions::PowerSpectrum >	powerSpectrum
	Computes the power spectrum of the complex source values.

constexpr ExpressionChainBuilder< expressions::Real >	real
	Extracts the real parts of the complex source values.

constexpr ExpressionChainBuilder< expressions::RealToComplex >	realToComplex
	Converts a sequence of real numbers into a sequence of complex numbers with their imaginary part set to 0.

template<is::constant DecibelConstant, auto minDb = -100>
constexpr ExpressionChainBuilderWithRuntimeArgs< expressions::MagToDb, detail::RuntimeArgChain< std::tuple<>, std::tuple<>, std::tuple<> >, DecibelConstant, Constant< minDb > >	magToDb
	Converts the source magnitude into a decibel representation.

template<is::constant DecibelConstant>
constexpr ExpressionChainBuilderWithRuntimeArgs< expressions::DBToMag, detail::RuntimeArgChain< std::tuple<>, std::tuple<>, std::tuple<> >, DecibelConstant >	dbToMag
	Converts the source decibel values into their magnitude representation.

constexpr ExpressionChainBuilder< expressions::FastExp >	fastExp
	A fast approximation of the exp function, using only basic algebraic operations in a continued fraction Padé approximation.

constexpr ExpressionChainBuilder< expressions::FastExp2 >	fastExp2
	A fast approximation of the exp2 function (e.g.

constexpr ExpressionChainBuilder< expressions::FastLog2 >	fastLog2
	A fast approximation of the log2 function (e.g.

constexpr ExpressionChainBuilder< expressions::Exp >	exp
	Computes e (Euler's number, 2.7182818...) raised to the source vector elements power.

constexpr ExpressionChainBuilder< expressions::Ln >	ln
	Computes the natural logarithm of the source values.

constexpr ExpressionChainBuilder< expressions::Log10 >	log10
	Computes the logarithm to the base of ten of the source values.

constexpr ExpressionChainBuilder< expressions::Log2 >	log2
	Computes the logarithm to the base of two of the source values.

template<auto base>
constexpr ExpressionChainBuilder< expressions::PowConstantBase, Constant< base > >	powConstantBase
	Evaluates base raised to the power of the source elements.

template<auto exponent>
constexpr ExpressionChainBuilder< expressions::PowConstantExponent, Constant< exponent > >	powConstantExponent
	Evaluates the source elements raised to the power of exponent.

constexpr ExpressionChainBuilder< expressions::NoAccelerationFilter >	dontUseAcceleration
	This filter expression ensures that only basic operator[] based evaluation of the previous expression is possible.

constexpr ExpressionChainBuilder< expressions::PlatformVectorOpsFilter >	usePlatformVectorOps
	Filter expression to force platform vector operation based accelerated evaluation.

constexpr ExpressionChainBuilder< expressions::SSEFilter >	useSSE
	This filter expression ensures that only SSE based accelerated evaluation of the previous expression is possible.

constexpr ExpressionChainBuilder< expressions::AVXFilter >	useAVX
	This filter expression ensures that only AVX based accelerated evaluation of the previous expression is possible.

constexpr ExpressionChainBuilder< expressions::NeonFilter >	useNeon
	This filter expression ensures that only Neon based accelerated evaluation of the previous expression is possible.

constexpr ExpressionChainBuilder< expressions::AVXFilter >	useNeonOrAVX

constexpr ExpressionChainBuilder< expressions::SSEFilter >	useNeonOrSSE

constexpr ExpressionChainBuilder< expressions::AnySIMDFilter >	useSIMD
	This filter expression ensures that only SIMD based accelerated evaluation of the previous expression is possible.

constexpr ExpressionChainBuilder< expressions::AssertSIMDFilter >	assertSIMD
	This filter inserts an assertion that will be hit in case that an expression is evaluated with anything but SIMD operations.

template<class DstType >
constexpr ExpressionChainBuilder< expressions::TransformedByStaticCast, DstType >	transformedByStaticCastTo
	Transforms all source elements to DstValueType by applying a static_cast<DstValueType> to them.

constexpr ExpressionChainBuilder< expressions::Acos >	acos
	Computes the inverse cosine of each source element.

constexpr ExpressionChainBuilder< expressions::Acosh >	acosh
	Computes the inverse hyperbolic cosine of each source element.

constexpr ExpressionChainBuilder< expressions::Asin >	asin
	Computes the inverse sine of each source element.

constexpr ExpressionChainBuilder< expressions::Asinh >	asinh
	Computes the inverse hyperbolic sine of each source element.

constexpr ExpressionChainBuilder< expressions::Atan >	atan
	Computes the inverse tangent of each source element.

constexpr ExpressionChainBuilder< expressions::Atanh >	atanh
	Computes the inverse hyperbolic tangent of each source element.

constexpr ExpressionChainBuilder< expressions::Cos >	cos
	Computes the cosine of each source element.

constexpr ExpressionChainBuilder< expressions::Cosh >	cosh
	Computes the hyperbolic cosine of each source element.

constexpr ExpressionChainBuilder< expressions::Sin >	sin
	Computes the sine of each source element.

constexpr ExpressionChainBuilder< expressions::Sinh >	sinh
	Computes the hyperbolic sine of each source element.

constexpr ExpressionChainBuilder< expressions::Tan >	tan
	Computes the tangent of each source element.

constexpr ExpressionChainBuilder< expressions::Tanh >	tanh
	Computes the hyperbolic tangent of each source element.

constexpr auto	_CMP_LT_OQ = 0

constexpr auto	_CMP_LE_OQ = 1

constexpr auto	_CMP_GT_OQ = 2

constexpr auto	_CMP_GE_OQ = 3

constexpr auto	_CMP_EQ_OQ = 4

constexpr auto	_CMP_NEQ_OQ = 5

template<has::size T>
constexpr size_t	extentOf = detail::Extent<std::remove_cvref_t<T>>::value
	Equals the extent of the container or expression type.

Detailed Description

The main namespace of the VCTR project.

Typedef Documentation

◆ CommonVecExpressionType

template<class A , class B , auto op>

using vctr::CommonVecExpressionType = typedef typename detail::CommonVecExpressionType<A, B, op>::type

Used to figure out the value_type for binary vector-vector operations.

The op template should be a function that calls the binary operation implemented by the expression.

◆ DataType

template<class T >

using vctr::DataType = typedef typename detail::DataType<std::remove_reference_t<T> >::Type

The const correct element type derived from a call to T::data.

◆ ExpressionChainBuilder

template<template< size_t, class... > class ExpressionType, class... AdditionalCompileTimeParameters>

using vctr::ExpressionChainBuilder = typedef ExpressionChainBuilderWithRuntimeArgs<ExpressionType, detail::RuntimeArgChain<std::tuple<> >, AdditionalCompileTimeParameters...>

Convenient typedef to create a simple expression chain builder instance for an expression template.

◆ FloatType

template<is::realNumber T>

using vctr::FloatType = typedef typename detail::FloatType<std::remove_cvref_t<T> >::Type

The best matching float type for the real number type T.

If T is an integer, the type will be float if T is < 32 Bit and double otherwise. If T is a floating point type, the type will be T.

◆ RealType

template<is::number T>

using vctr::RealType = typedef typename detail::RealType<std::remove_cvref_t<T> >::Type

If T is any instance of std::complex, this will be the real value_type, otherwise this will be T.

◆ SpanStorageInfo

template<class ElementType , bool isDataSIMDAligned, bool isStorageSIMDExtended = false>

using vctr::SpanStorageInfo = typedef StaticStorageInfo<isDataSIMDAligned, isStorageSIMDExtended, alignof (std::span<ElementType>)>

A StaticStorageInfo type alias suitable for vctr::Span.

Useful if you want to define a Span type to point to some externally managed raw data pointer that you know to be SIMD aligned.

float a alignas (32) [12]
 
using SIMDAlignedFloatSpan = vctr::Span<float, sizeof (a), vctr::SpanStorageInfo<float, true>>;
 
SIMDAlignedFloatSpan aSpan (a, sizeof (a));

◆ StorageInfoType

template<has::sizeAndData T>

using vctr::StorageInfoType = typedef typename detail::StorageInfoType<std::remove_cvref_t<T> >::Type

If t is a type derived from VctrBase, this will equal the return value of T::getStorageInfo, otherwise this will be StorageInfo<T>.

◆ ValueType

template<class T >

using vctr::ValueType = typedef typename detail::ValueType<std::remove_cvref_t<T> >::Type

If T is an expression template, it equals its return type, if it's a type that defines value_type as a public typedef, it equals value_type.

Enumeration Type Documentation

◆ CompareOp

enum class vctr::CompareOp : int

strong

Possible types of (SIMD) compare operations.

Function Documentation

◆ assertCommonSize() [1/2]

template<class A , class B >

constexpr void vctr::assertCommonSize	(	const A &	a,
		const B &	b
	)

constexpr

Ensures that both sources have the same size.

In case they both specify a non-dynamic extent, this will be a compile-time static_assert, otherwise it will perform a runtime assert comparing the sizes.

◆ assertCommonSize() [2/2]

template<class A , class B , class C >

constexpr void vctr::assertCommonSize	(	const A &	a,
		const B &	b,
		const C &	c
	)

constexpr

Ensures that all three sources have the same size.

In case they all specify a non-dynamic extent, this will be a compile-time static_assert, otherwise it will perform a runtime assert comparing the sizes.

◆ functionName() [1/2]

template<class R , class Arg , R(*)(Arg) fn>

consteval std::string_view vctr::functionName ( )

Returns the name for a function with a single argument.

◆ functionName() [2/2]

template<class R , class ArgA , class ArgB , R(*)(ArgA, ArgB) fn>

consteval std::string_view vctr::functionName ( )

Returns the name for a function with two arguments.

◆ getCommonExtent()

template<class First , class... Other>

consteval size_t vctr::getCommonExtent ( )

Returns std::dynamic_extent in case all the sources specify a dynamic extent.

Returns the non-dynamic extent found otherwise.

Note: This helper assumes, that you know that all sources have a common size. If in doubt, use assertCommonSize to verify that.

◆ isPtrAligned()

template<uintptr_t requiredAlignment = Config::maxSIMDRegisterSize>

constexpr bool vctr::isPtrAligned ( const void * ptr )

inlineconstexpr

Helper function to check if a pointer is aligned to the required alignment value.

The default alignment value is maxSIMDRegisterSize, which is the alignment that VCTR tries to use wherever possible.

In case of constant evaluation, this function will always return false, since alignment does not have any meaning in that context.

◆ makeExpressionChainBuilderWithRuntimeArgs()

template<template< size_t, class... > class ExpressionType, class... RuntimeArgs>
requires (sizeof... (RuntimeArgs) > 0)

constexpr auto vctr::makeExpressionChainBuilderWithRuntimeArgs ( RuntimeArgs... runtimeArgs )

constexpr

Helper function to build factory functions for expressions that rely on runtime argument values.

These kinds of expressions don't expose a constexpr instance of the expression chain builder but supply a factory function, which returns an expression chain builder instance which holds the desired value to apply. Example: Example:

// The factory function that takes the desired runtime argument s.
template <class T>
constexpr auto clamp (T lowerBound, T upperBound)
{
    return makeExpressionChainBuilderWithRuntimeArgs<Clamp> (lowerBound, upperBound);
}

The expression chain created like that will later pass the two arguments to the void applyRuntimeArgs member function of the expression in the same order as they were passed to makeExpressionChainBuilderWithRuntimeArgs – so in case you want to build an expression that takes runtime arguments, make sure to implement that function.

◆ makeSimdAlignedSpan() [1/2]

template<size_t extent, class ElementType >
requires (extent != std::dynamic_extent)

auto vctr::makeSimdAlignedSpan ( ElementType * data )

Creates a span with static extent pointing to a memory location that is expected to be SIMD aligned.

◆ makeSimdAlignedSpan() [2/2]

template<class ElementType >

auto vctr::makeSimdAlignedSpan	(	ElementType *	data,
		size_t	size
	)

Creates a span with dynamic extent pointing to a memory location that is expected to be SIMD aligned.

◆ makeTemplateExpressionChainBuilderWithRuntimeArgs()

template<template< size_t, class... > class ExpressionType, class ExpressionTemplateArg , class... RuntimeArgs>
requires (sizeof... (RuntimeArgs) > 0)

constexpr auto vctr::makeTemplateExpressionChainBuilderWithRuntimeArgs ( RuntimeArgs... runtimeArgs )

constexpr

Helper function to build factory functions for expressions that rely on runtime argument values.

This function is just like makeExpressionChainBuilderWithRuntimeArgs except for allowing to pass one further template type argument to the ExpressionType.

◆ operator==()

template<is::anyVctr Lhs, is::anyVctr Rhs>
requires std::same_as<ValueType<Lhs>, ValueType<Rhs>>

constexpr bool vctr::operator==	(	const Lhs &	lhs,
		const Rhs &	rhs
	)

constexpr

Compares lhs and rhs for equality.

They are considered equal if their size is the same and every element at a certain index in lhs compares equal to the corresponding element at the same index in rhs.

◆ simdAlignedSpanStorageInfo()

template<class ElementType >

consteval auto vctr::simdAlignedSpanStorageInfo ( )

Creates a StaticStorageInfo instance suitable to be passed to a Span constructor.

Declares the viewed data to be SIMD aligned. Required alignment is 32 byte on x64 and 16 byte on ARM.

◆ sizeToInt()

int vctr::sizeToInt ( size_t size )

inline

Casts the size_t argument to an int.

In a debug build, this checks for potential overflow issues

◆ typeName()

template<class T >

consteval std::string_view vctr::typeName ( )

Returns a string containing the templates type name.

Variable Documentation

◆ extentOf

template<has::size T>

constexpr size_t vctr::extentOf = detail::Extent<std::remove_cvref_t<T>>::value

constexpr

Equals the extent of the container or expression type.

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Detailed Description

Typedef Documentation

◆ CommonVecExpressionType

◆ DataType

◆ ExpressionChainBuilder

◆ FloatType

◆ RealType

◆ SpanStorageInfo

◆ StorageInfoType

◆ ValueType

Enumeration Type Documentation

◆ CompareOp

Function Documentation

◆ assertCommonSize() [1/2]

◆ assertCommonSize() [2/2]

◆ functionName() [1/2]

◆ functionName() [2/2]

◆ getCommonExtent()

◆ isPtrAligned()

◆ makeExpressionChainBuilderWithRuntimeArgs()

◆ makeSimdAlignedSpan() [1/2]

◆ makeSimdAlignedSpan() [2/2]

◆ makeTemplateExpressionChainBuilderWithRuntimeArgs()

◆ operator==()

◆ simdAlignedSpanStorageInfo()

◆ sizeToInt()

◆ typeName()

Variable Documentation

◆ extentOf