Description

Collaboration diagram for Multicore math:

Classes

class  chrono::real2
 Chrono::Multicore pair (2-dimensional vector). More...
 
class  chrono::real3
 Chrono::Multicore triplet (3-dimensional vector). More...
 
class  chrono::real4
 Chrono multicore qudruple (4-dimensional array). More...
 
class  chrono::quaternion
 Chrono multicore quaternion class. More...
 

Macros

#define THRUST_PAR
 
#define Thrust_Inclusive_Scan_Sum(x, y)
 
#define Thrust_Sort_By_Key(x, y)   thrust::sort_by_key(THRUST_PAR x.begin(), x.end(), y.begin())
 
#define Run_Length_Encode(y, z, w)
 
#define Thrust_Inclusive_Scan(x)   thrust::inclusive_scan(THRUST_PAR x.begin(), x.end(), x.begin())
 
#define Thrust_Exclusive_Scan(x)   thrust::exclusive_scan(THRUST_PAR x.begin(), x.end(), x.begin())
 
#define Thrust_Fill(x, y)   thrust::fill(x.begin(), x.end(), y)
 
#define Thrust_Sort(x)   thrust::sort(THRUST_PAR x.begin(), x.end())
 
#define Thrust_Count(x, y)   thrust::count(THRUST_PAR x.begin(), x.end(), y)
 
#define Thrust_Sequence(x)   thrust::sequence(x.begin(), x.end())
 
#define Thrust_Equal(x, y)   thrust::equal(THRUST_PAR x.begin(), x.end(), y.begin())
 
#define Thrust_Max(x)   x[thrust::max_element(THRUST_PAR x.begin(), x.end()) - x.begin()]
 
#define Thrust_Min(x)   x[thrust::min_element(THRUST_PAR x.begin(), x.end()) - x.begin()]
 
#define Thrust_Total(x)   thrust::reduce(THRUST_PAR x.begin(), x.end())
 
#define Thrust_Unique(x)   thrust::unique(THRUST_PAR x.begin(), x.end()) - x.begin();
 
#define DBG(x)   printf(x);
 
#define OPERATOR_EQUALS(op, tin, tout)
 
#define OPERATOR_EQUALSALT_PROTO(op, tin, tout)   tout& operator op##=(tout& a, const tin& scale);
 
#define OPERATOR_EQUALSALT(op, tin, tout)
 
#define OPERATOR_EQUALS_PROTO(op, tin, tout)   tout& operator op##=(tout& a, const tin& scale);
 
#define OPERATOR_EQUALS_IMPL(op, tin, tout)
 
#define C_REAL_MAX   DBL_MAX
 
#define C_REAL_MIN   DBL_MIN
 
#define C_REAL_EPSILON   DBL_EPSILON
 
#define C_REAL_MAX   FLT_MAX
 
#define C_REAL_MIN   FLT_MIN
 
#define C_REAL_EPSILON   FLT_EPSILON
 

Typedefs

typedef double chrono::real
 

Functions

template<typename Enumeration >
auto chrono::as_integer (Enumeration const value) -> typename std::underlying_type< Enumeration >::type
 Explicit conversion of scoped enumeration to int (e.g. for streaming).
 
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator >
OutputIterator chrono::Thrust_Expand (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, OutputIterator output)
 Utility to expand an input sequence by replicating each element a variable number of times. More...
 
CUDA_HOST_DEVICE ChApi real3 chrono::operator* (const Mat33 &M, const real3 &v)
 
CUDA_HOST_DEVICE ChApi Mat33 chrono::operator* (const Mat33 &N, const real scale)
 
CUDA_HOST_DEVICE ChApi Mat33 chrono::operator* (const Mat33 &M, const Mat33 &N)
 
CUDA_HOST_DEVICE ChApi Mat33 chrono::operator+ (const Mat33 &M, const Mat33 &N)
 
CUDA_HOST_DEVICE ChApi Mat33 chrono::operator- (const Mat33 &M, const Mat33 &N)
 
CUDA_HOST_DEVICE ChApi OPERATOR_EQUALSALT_PROTO real CUDA_HOST_DEVICE ChApi OPERATOR_EQUALSALT_PROTO Mat33 CUDA_HOST_DEVICE ChApi chrono::OPERATOR_EQUALSALT_PROTO (+, Mat33, Mat33) CUDA_HOST_DEVICE ChApi OPERATOR_EQUALSALT_PROTO(-
 
CUDA_HOST_DEVICE ChApi OPERATOR_EQUALSALT real CUDA_HOST_DEVICE ChApi OPERATOR_EQUALSALT Mat33 CUDA_HOST_DEVICE ChApi Mat33 CUDA_HOST_DEVICE ChApi Mat33 chrono::operator- (const Mat33 &M)
 
CUDA_HOST_DEVICE ChApi Mat33 chrono::operator* (const real s, const Mat33 &a)
 
CUDA_HOST_DEVICE ChApi Mat33 chrono::SkewSymmetric (const real3 &r)
 
CUDA_HOST_DEVICE ChApi Mat33 chrono::SkewSymmetricAlt (const real3 &r)
 
CUDA_HOST_DEVICE ChApi real chrono::Determinant (const Mat33 &m)
 
CUDA_HOST_DEVICE ChApi Mat33 chrono::Abs (const Mat33 &m)
 
CUDA_HOST_DEVICE ChApi Mat33 chrono::Transpose (const Mat33 &a)
 
CUDA_HOST_DEVICE ChApi Mat33 chrono::MultTranspose (const Mat33 &M, const Mat33 &N)
 
CUDA_HOST_DEVICE ChApi Mat33 chrono::TransposeMult (const Mat33 &M, const Mat33 &N)
 
CUDA_HOST_DEVICE ChApi real chrono::Trace (const Mat33 &m)
 
CUDA_HOST_DEVICE ChApi Mat33 chrono::OuterProduct (const real3 &a, const real3 &b)
 
CUDA_HOST_DEVICE ChApi real chrono::InnerProduct (const Mat33 &A, const Mat33 &B)
 
CUDA_HOST_DEVICE ChApi Mat33 chrono::Adjoint (const Mat33 &A)
 
CUDA_HOST_DEVICE ChApi Mat33 chrono::AdjointTranspose (const Mat33 &A)
 
CUDA_HOST_DEVICE ChApi Mat33 chrono::Inverse (const Mat33 &A)
 
CUDA_HOST_DEVICE ChApi Mat33 chrono::InverseTranspose (const Mat33 &A)
 
CUDA_HOST_DEVICE ChApi real chrono::Norm (const Mat33 &A)
 
CUDA_HOST_DEVICE ChApi real chrono::NormSq (const Mat33 &A)
 
CUDA_HOST_DEVICE ChApi real chrono::DoubleDot (const Mat33 &A, const Mat33 &B)
 
CUDA_HOST_DEVICE ChApi real3 chrono::LargestColumnNormalized (const Mat33 &A)
 
CUDA_HOST_DEVICE ChApi Mat33 chrono::operator* (const DiagMat33 &M, const Mat33 &N)
 
CUDA_HOST_DEVICE ChApi real3 chrono::operator* (const DiagMat33 &M, const real3 &v)
 
CUDA_HOST_DEVICE ChApi SymMat33 chrono::operator- (const SymMat33 &M, const real &v)
 
CUDA_HOST_DEVICE ChApi real3 chrono::operator* (const Mat32 &M, const real2 &v)
 
CUDA_HOST_DEVICE ChApi SymMat22 chrono::operator- (const SymMat22 &M, const real &v)
 
CUDA_HOST_DEVICE ChApi SymMat22 chrono::CofactorMatrix (const SymMat22 &A)
 
CUDA_HOST_DEVICE ChApi real2 chrono::LargestColumnNormalized (const SymMat22 &A)
 
CUDA_HOST_DEVICE ChApi SymMat33 chrono::NormalEquationsMatrix (const Mat33 &A)
 
CUDA_HOST_DEVICE ChApi SymMat33 chrono::CofactorMatrix (const SymMat33 &A)
 
CUDA_HOST_DEVICE ChApi real3 chrono::LargestColumnNormalized (const SymMat33 &A)
 
CUDA_HOST_DEVICE ChApi Mat32 chrono::operator* (const SymMat33 &M, const Mat32 &N)
 
CUDA_HOST_DEVICE ChApi SymMat22 chrono::TransposeTimesWithSymmetricResult (const Mat32 &A, const Mat32 &B)
 
CUDA_HOST_DEVICE ChApi SymMat22 chrono::ConjugateWithTranspose (const Mat32 &A, const SymMat33 &B)
 
CUDA_HOST_DEVICE ChApi void chrono::Print (const Mat33 &A, const char *name)
 
CUDA_HOST_DEVICE ChApi void chrono::Print (const Mat32 &A, const char *name)
 
CUDA_HOST_DEVICE ChApi void chrono::Print (const SymMat33 &A, const char *name)
 
CUDA_HOST_DEVICE ChApi void chrono::Print (const SymMat22 &A, const char *name)
 
CUDA_HOST_DEVICE ChApi void chrono::PrintLine (const Mat33 &A, const char *name)
 
CUDA_HOST_DEVICE ChApi void chrono::PrintLine (const Mat32 &A, const char *name)
 
CUDA_HOST_DEVICE ChApi void chrono::PrintLine (const SymMat33 &A, const char *name)
 
CUDA_HOST_DEVICE ChApi void chrono::PrintLine (const SymMat22 &A, const char *name)
 
CUDA_HOST_DEVICE ChApi vec3 chrono::operator- (const vec3 &a, const vec3 &b)
 
CUDA_HOST_DEVICE ChApi vec3 chrono::operator- (const vec3 &a, const int &b)
 
CUDA_HOST_DEVICE ChApi vec3 chrono::operator+ (const vec3 &a, const vec3 &b)
 
CUDA_HOST_DEVICE ChApi vec3 chrono::operator+ (const vec3 &a, const int &b)
 
CUDA_HOST_DEVICE ChApi vec3 chrono::Clamp (const vec3 &a, const vec3 &clamp_min, const vec3 &clamp_max)
 
CUDA_HOST_DEVICE ChApi vec3 chrono::Max (const vec3 &a, const vec3 &b)
 
CUDA_HOST_DEVICE ChApi vec3 chrono::Min (const vec3 &a, const vec3 &b)
 
CUDA_HOST_DEVICE real chrono::Lerp (const real &start, const real &end, const real &t)
 
template<typename T >
CUDA_HOST_DEVICE void chrono::Swap (T &a, T &b)
 
template<typename T >
CUDA_HOST_DEVICE void chrono::Sort (T &a, T &b, T &c)
 
template<typename T >
CUDA_HOST_DEVICE void chrono::SwapIfGreater (T &a, T &b)
 
CUDA_HOST_DEVICE real chrono::Clamp (real x, real low, real high)
 Clamps a given value a between user specified minimum and maximum values.
 
CUDA_HOST_DEVICE void chrono::ClampValue (real &x, real low, real high)
 Clamps a given value a between user specified minimum and maximum values.
 
CUDA_HOST_DEVICE real chrono::ClampMin (real x, real low)
 
CUDA_HOST_DEVICE real chrono::ClampMax (real x, real high)
 
CUDA_HOST_DEVICE real2 chrono::operator+ (const real2 &a, real b)
 
CUDA_HOST_DEVICE real2 chrono::operator- (const real2 &a, real b)
 
CUDA_HOST_DEVICE real2 chrono::operator* (const real2 &a, real b)
 
CUDA_HOST_DEVICE real2 chrono::operator/ (const real2 &a, real b)
 
CUDA_HOST_DEVICE real2 chrono::operator+ (const real2 &a, const real2 &b)
 
CUDA_HOST_DEVICE real2 chrono::operator- (const real2 &a, const real2 &b)
 
CUDA_HOST_DEVICE real2 chrono::operator* (const real2 &a, const real2 &b)
 
CUDA_HOST_DEVICE real2 chrono::operator/ (const real2 &a, const real2 &b)
 
CUDA_HOST_DEVICE real2 chrono::operator- (const real2 &a)
 
CUDA_HOST_DEVICE chrono::OPERATOR_EQUALS_PROTO (/, real, real2)
 
CUDA_HOST_DEVICE chrono::OPERATOR_EQUALS_PROTO (+, real, real2)
 
CUDA_HOST_DEVICE chrono::OPERATOR_EQUALS_PROTO (-, real, real2)
 
CUDA_HOST_DEVICE chrono::OPERATOR_EQUALS_PROTO (/, real2, real2)
 
CUDA_HOST_DEVICE chrono::OPERATOR_EQUALS_PROTO (+, real2, real2)
 
CUDA_HOST_DEVICE chrono::OPERATOR_EQUALS_PROTO (-, real2, real2)
 
CUDA_HOST_DEVICE real2 chrono::operator* (real lhs, const real2 &rhs)
 
CUDA_HOST_DEVICE bool chrono::operator== (const real2 &lhs, const real2 &rhs)
 
CUDA_HOST_DEVICE real2 chrono::Max (const real2 &a, const real2 &b)
 
CUDA_HOST_DEVICE real2 chrono::Min (const real2 &a, const real2 &b)
 
CUDA_HOST_DEVICE real chrono::Dot (const real2 &v1, const real2 &v2)
 
CUDA_HOST_DEVICE real chrono::Dot (const real2 &v)
 
CUDA_HOST_DEVICE real chrono::Length2 (const real2 &v1)
 
CUDA_HOST_DEVICE real2 chrono::Normalize (const real2 &v1)
 
CUDA_HOST_DEVICE void chrono::Print (real2 v, const char *name)
 
CUDA_HOST_DEVICE ChApi real3 chrono::Set3 (real x)
 
CUDA_HOST_DEVICE ChApi real3 chrono::Set3 (real x, real y, real z)
 
CUDA_HOST_DEVICE ChApi real3 chrono::operator+ (const real3 &a, real b)
 
CUDA_HOST_DEVICE ChApi real3 chrono::operator- (const real3 &a, real b)
 
CUDA_HOST_DEVICE ChApi real3 chrono::operator* (const real3 &a, real b)
 
CUDA_HOST_DEVICE ChApi real3 chrono::operator/ (const real3 &a, real b)
 
CUDA_HOST_DEVICE ChApi real3 chrono::operator+ (const real3 &a, const real3 &b)
 
CUDA_HOST_DEVICE ChApi real3 chrono::operator- (const real3 &a, const real3 &b)
 
CUDA_HOST_DEVICE ChApi real3 chrono::operator* (const real3 &a, const real3 &b)
 
CUDA_HOST_DEVICE ChApi real3 chrono::operator/ (const real3 &a, const real3 &b)
 
CUDA_HOST_DEVICE ChApi chrono::OPERATOR_EQUALS_PROTO (/, real, real3)
 
CUDA_HOST_DEVICE ChApi chrono::OPERATOR_EQUALS_PROTO (+, real, real3)
 
CUDA_HOST_DEVICE ChApi chrono::OPERATOR_EQUALS_PROTO (-, real, real3)
 
CUDA_HOST_DEVICE ChApi chrono::OPERATOR_EQUALS_PROTO (/, real3, real3)
 
CUDA_HOST_DEVICE ChApi chrono::OPERATOR_EQUALS_PROTO (+, real3, real3)
 
CUDA_HOST_DEVICE ChApi chrono::OPERATOR_EQUALS_PROTO (-, real3, real3)
 
CUDA_HOST_DEVICE ChApi real3 chrono::operator- (const real3 &a)
 
CUDA_HOST_DEVICE ChApi real3 chrono::operator* (real lhs, const real3 &rhs)
 
CUDA_HOST_DEVICE ChApi real3 chrono::operator/ (real lhs, const real3 &rhs)
 
CUDA_HOST_DEVICE ChApi bool chrono::operator< (const real3 &a, const real3 &b)
 
CUDA_HOST_DEVICE ChApi bool chrono::operator> (const real3 &a, const real3 &b)
 
CUDA_HOST_DEVICE ChApi bool chrono::operator== (const real3 &a, const real3 &b)
 
CUDA_HOST_DEVICE ChApi real3 chrono::Cross (const real3 &b, const real3 &c)
 
CUDA_HOST_DEVICE ChApi real chrono::Dot (const real3 &v1, const real3 &v2)
 
CUDA_HOST_DEVICE ChApi real chrono::Dot (const real3 &v)
 
CUDA_HOST_DEVICE ChApi real3 chrono::Normalize (const real3 &v)
 
CUDA_HOST_DEVICE ChApi real3 chrono::Sqrt (const real3 &v)
 
CUDA_HOST_DEVICE ChApi real3 chrono::Round (const real3 &v)
 
CUDA_HOST_DEVICE ChApi real chrono::Length (const real3 &v)
 
CUDA_HOST_DEVICE ChApi real chrono::Length2 (const real3 &v1)
 
CUDA_HOST_DEVICE ChApi real chrono::SafeLength (const real3 &v)
 
CUDA_HOST_DEVICE ChApi real3 chrono::SafeNormalize (const real3 &v, const real3 &safe)
 
CUDA_HOST_DEVICE ChApi real chrono::Max (const real3 &a)
 
CUDA_HOST_DEVICE ChApi real chrono::Min (const real3 &a)
 
CUDA_HOST_DEVICE ChApi real3 chrono::Max (const real3 &a, const real3 &b)
 
CUDA_HOST_DEVICE ChApi real3 chrono::Min (const real3 &a, const real3 &b)
 
CUDA_HOST_DEVICE ChApi real3 chrono::Max (const real3 &a, const real &b)
 
CUDA_HOST_DEVICE ChApi real3 chrono::Min (const real3 &a, const real &b)
 
CUDA_HOST_DEVICE ChApi bool chrono::IsZero (const real3 &v)
 
CUDA_HOST_DEVICE ChApi real3 chrono::Abs (const real3 &v)
 
CUDA_HOST_DEVICE ChApi real3 chrono::Sign (const real3 &v)
 
CUDA_HOST_DEVICE ChApi real3 chrono::Clamp (const real3 &v, real max_length)
 
CUDA_HOST_DEVICE ChApi real3 chrono::Clamp (const real3 &a, const real3 &clamp_min, const real3 &clamp_max)
 
CUDA_HOST_DEVICE ChApi real3 chrono::OrthogonalVector (const real3 &v)
 
CUDA_HOST_DEVICE ChApi real3 chrono::UnitOrthogonalVector (const real3 &v)
 
CUDA_HOST_DEVICE ChApi void chrono::Sort (real &a, real &b, real &c)
 
CUDA_HOST_DEVICE ChApi void chrono::Print (real3 v, const char *name)
 
CUDA_HOST_DEVICE ChApi real4 chrono::Set4 (real x)
 
CUDA_HOST_DEVICE ChApi real4 chrono::Set4 (real x, real y, real z, real w)
 
CUDA_HOST_DEVICE ChApi real4 chrono::operator+ (const real4 &a, const real4 &b)
 
CUDA_HOST_DEVICE ChApi real4 chrono::operator- (const real4 &a, const real4 &b)
 
CUDA_HOST_DEVICE ChApi real4 chrono::operator* (const real4 &a, const real4 &b)
 
CUDA_HOST_DEVICE ChApi real4 chrono::operator/ (const real4 &a, const real4 &b)
 
CUDA_HOST_DEVICE ChApi real4 chrono::operator+ (const real4 &a, real b)
 
CUDA_HOST_DEVICE ChApi real4 chrono::operator- (const real4 &a, real b)
 
CUDA_HOST_DEVICE ChApi real4 chrono::operator* (const real4 &a, real b)
 
CUDA_HOST_DEVICE ChApi real4 chrono::operator/ (const real4 &a, real b)
 
CUDA_HOST_DEVICE ChApi chrono::OPERATOR_EQUALS_PROTO (/, real, real4)
 
CUDA_HOST_DEVICE ChApi chrono::OPERATOR_EQUALS_PROTO (+, real, real4)
 
CUDA_HOST_DEVICE ChApi chrono::OPERATOR_EQUALS_PROTO (-, real, real4)
 
CUDA_HOST_DEVICE ChApi chrono::OPERATOR_EQUALS_PROTO (/, real4, real4)
 
CUDA_HOST_DEVICE ChApi chrono::OPERATOR_EQUALS_PROTO (+, real4, real4)
 
CUDA_HOST_DEVICE ChApi chrono::OPERATOR_EQUALS_PROTO (-, real4, real4)
 
CUDA_HOST_DEVICE ChApi real4 chrono::operator- (const real4 &a)
 
CUDA_HOST_DEVICE ChApi real4 chrono::Dot4 (const real3 &v, const real3 &v1, const real3 &v2, const real3 &v3, const real3 &v4)
 
CUDA_HOST_DEVICE ChApi quaternion chrono::SetQ (real x)
 
CUDA_HOST_DEVICE ChApi quaternion chrono::SetQ (real w, real x, real y, real z)
 
CUDA_HOST_DEVICE ChApi quaternion chrono::operator+ (const quaternion &a, real b)
 
CUDA_HOST_DEVICE ChApi quaternion chrono::operator- (const quaternion &a, real b)
 
CUDA_HOST_DEVICE ChApi quaternion chrono::operator* (const quaternion &a, real b)
 
CUDA_HOST_DEVICE ChApi quaternion chrono::operator/ (const quaternion &a, real b)
 
CUDA_HOST_DEVICE ChApi quaternion chrono::operator~ (const quaternion &a)
 
CUDA_HOST_DEVICE ChApi quaternion chrono::Inv (const quaternion &a)
 
CUDA_HOST_DEVICE ChApi real chrono::Dot (const quaternion &v1, const quaternion &v2)
 
CUDA_HOST_DEVICE ChApi real chrono::Dot (const quaternion &v)
 
CUDA_HOST_DEVICE ChApi quaternion chrono::Mult (const quaternion &a, const quaternion &b)
 
CUDA_HOST_DEVICE ChApi quaternion chrono::Normalize (const quaternion &v)
 
CUDA_HOST_DEVICE ChApi real3 chrono::Rotate (const real3 &v, const quaternion &q)
 
CUDA_HOST_DEVICE ChApi real3 chrono::RotateT (const real3 &v, const quaternion &q)
 
CUDA_HOST_DEVICE ChApi real3 chrono::AbsRotate (const quaternion &q, const real3 &v)
 
CUDA_HOST_DEVICE ChApi quaternion chrono::QuatFromAngleAxis (const real &angle, const real3 &axis)
 
CUDA_HOST_DEVICE ChApi real3 chrono::AMatU (const quaternion &q)
 
CUDA_HOST_DEVICE ChApi real3 chrono::AMatV (const quaternion &q)
 
CUDA_HOST_DEVICE ChApi real3 chrono::AMatW (const quaternion &q)
 
CUDA_HOST_DEVICE ChApi void chrono::Print (quaternion v, const char *name)
 

Variables

CUDA_HOST_DEVICE ChApi OPERATOR_EQUALSALT real CUDA_HOST_DEVICE ChApi OPERATOR_EQUALSALT Mat33 CUDA_HOST_DEVICE ChApi chrono::Mat33
 
CUDA_HOST_DEVICE OPERATOR_EQUALS_IMPL * chrono::real2
 
CUDA_HOST_DEVICE ChApi OPERATOR_EQUALS_IMPL * chrono::real3
 
CUDA_HOST_DEVICE ChApi OPERATOR_EQUALS_IMPL * chrono::real4
 

Macro Definition Documentation

◆ OPERATOR_EQUALS

#define OPERATOR_EQUALS (   op,
  tin,
  tout 
)
Value:
inline tout& operator op##=(tin scale) { \
*this = *this op scale; \
return *this; \
}

◆ OPERATOR_EQUALS_IMPL

#define OPERATOR_EQUALS_IMPL (   op,
  tin,
  tout 
)
Value:
tout& operator op##=(tout& a, const tin& scale) { \
a = a op scale; \
return a; \
}

◆ OPERATOR_EQUALSALT

#define OPERATOR_EQUALSALT (   op,
  tin,
  tout 
)
Value:
tout& operator op##=(tout& a, const tin& scale) { \
a = a op scale; \
return a; \
}

◆ Run_Length_Encode

#define Run_Length_Encode (   y,
  z,
 
)
Value:
(thrust::reduce_by_key(THRUST_PAR y.begin(), y.end(), thrust::constant_iterator<uint>(1), z.begin(), w.begin()) \
.second) - \
w.begin()

◆ Thrust_Inclusive_Scan_Sum

#define Thrust_Inclusive_Scan_Sum (   x,
 
)
Value:
thrust::inclusive_scan(THRUST_PAR x.begin(), x.end(), x.begin()); \
y = x.back();

Function Documentation

◆ Thrust_Expand()

template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator >
OutputIterator chrono::Thrust_Expand ( InputIterator1  first1,
InputIterator1  last1,
InputIterator2  first2,
OutputIterator  output 
)

Utility to expand an input sequence by replicating each element a variable number of times.

For example,

  • expand([2,2,2],[A,B,C]) -> [A,A,B,B,C,C]
  • expand([3,0,1],[A,B,C]) -> [A,A,A,C]
  • expand([1,3,2],[A,B,C]) -> [A,B,B,B,C,C]

The element counts are assumed to be non-negative integers (from Thrust's example expand.cu)