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< InfoA, InfoB >

struct	Config

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

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<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 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	CPUInstructionSet { sse4_1 , avx , avx2 , neon , fallback }

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

CPUInstructionSet	getHighestSupportedCPUInstructionSet ()

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<class A , class B >
consteval size_t	getCommonExtent ()
	Returns std::dynamic_extent in case both 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 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 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.

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.

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

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.

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

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

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

Function Documentation

◆ assertCommonSize()

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.

◆ 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 A , class B >

consteval size_t vctr::getCommonExtent ( )

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

Throws in case both sources specify a non-matching non-dynamic extent. Returns the non-dynamic extent found otherwise.

◆ makeExpressionChainBuilderWithRuntimeArgs()

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

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

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)

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

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

◆ DataType

◆ ExpressionChainBuilder

◆ FloatType

◆ RealType

◆ StorageInfoType

◆ ValueType

Function Documentation

◆ assertCommonSize()

◆ functionName() [1/2]

◆ functionName() [2/2]

◆ getCommonExtent()

◆ makeExpressionChainBuilderWithRuntimeArgs()

◆ makeSimdAlignedSpan() [1/2]

◆ makeSimdAlignedSpan() [2/2]

◆ makeTemplateExpressionChainBuilderWithRuntimeArgs()

◆ operator==()

◆ simdAlignedSpanStorageInfo()

◆ sizeToInt()

◆ typeName()

Variable Documentation

◆ extentOf