Vector processing functions. More...

Functions
static void	pl_VectorFillF_N1 (PlankF *result, PlankF value, PlankUL N)
	Fills a vector with a constant.
static void	pl_VectorClearF_N (PlankF *result, PlankUL N)
	Fills a vector with zeros.
static void	pl_VectorRampF_N11 (PlankF *result, PlankF a, PlankF b, PlankUL N)
	Fills a vector with a ramp.
static void	pl_VectorLineF_N11 (PlankF *result, PlankF a, PlankF b, PlankUL N)
	Fills a vector with a line.
static void	pl_VectorMoveF_NN (PlankF result, const PlankF a, PlankUL N)
	Applies the function pl_MoveF() to each item in a vector.
static void	pl_VectorIncF_NN (PlankF result, const PlankF a, PlankUL N)
	Applies the function pl_IncF() to each item in a vector.
static void	pl_VectorDecF_NN (PlankF result, const PlankF a, PlankUL N)
	Applies the function pl_DecF() to each item in a vector.
static void	pl_VectorNegF_NN (PlankF result, const PlankF a, PlankUL N)
	Applies the function pl_NegF() to each item in a vector.
static void	pl_VectorAbsF_NN (PlankF result, const PlankF a, PlankUL N)
	Applies the function pl_AbsF() to each item in a vector.
static void	pl_VectorSquaredF_NN (PlankF result, const PlankF a, PlankUL N)
	Applies the function pl_SquaredF() to each item in a vector.
static void	pl_VectorCubedF_NN (PlankF result, const PlankF a, PlankUL N)
	Applies the function pl_CubedF() to each item in a vector.
static void	pl_VectorSignF_NN (PlankF result, const PlankF a, PlankUL N)
	Applies the function pl_SignF() to each item in a vector.
static void	pl_VectorAddF_NNN (PlankF result, const PlankF a, const PlankF *b, PlankUL N)
	Applies the binary operator function pl_AddF() to each item in two input vectors.
static void	pl_VectorAddF_NN1 (PlankF result, const PlankF a, PlankF b, PlankUL N)
	Applies the binary operator function pl_AddF() to an input vector and a scalar value.
static void	pl_VectorAddF_N1N (PlankF result, PlankF a, const PlankF b, PlankUL N)
	Applies the binary operator function pl_AddF() to an input vector and a scalar value.
static void	pl_VectorSubF_NNN (PlankF result, const PlankF a, const PlankF *b, PlankUL N)
	Applies the binary operator function pl_SubF() to each item in two input vectors.
static void	pl_VectorSubF_NN1 (PlankF result, const PlankF a, PlankF b, PlankUL N)
	Applies the binary operator function pl_SubF() to an input vector and a scalar value.
static void	pl_VectorSubF_N1N (PlankF result, PlankF a, const PlankF b, PlankUL N)
	Applies the binary operator function pl_SubF() to an input vector and a scalar value.
static void	pl_VectorMulF_NNN (PlankF result, const PlankF a, const PlankF *b, PlankUL N)
	Applies the binary operator function pl_MulF() to each item in two input vectors.
static void	pl_VectorMulF_NN1 (PlankF result, const PlankF a, PlankF b, PlankUL N)
	Applies the binary operator function pl_MulF() to an input vector and a scalar value.
static void	pl_VectorMulF_N1N (PlankF result, PlankF a, const PlankF b, PlankUL N)
	Applies the binary operator function pl_MulF() to an input vector and a scalar value.
static void	pl_VectorDivF_NNN (PlankF result, const PlankF a, const PlankF *b, PlankUL N)
	Applies the binary operator function pl_DivF() to each item in two input vectors.
static void	pl_VectorDivF_NN1 (PlankF result, const PlankF a, PlankF b, PlankUL N)
	Applies the binary operator function pl_DivF() to an input vector and a scalar value.
static void	pl_VectorDivF_N1N (PlankF result, PlankF a, const PlankF b, PlankUL N)
	Applies the binary operator function pl_DivF() to an input vector and a scalar value.
static void	pl_VectorModF_NNN (PlankF result, const PlankF a, const PlankF *b, PlankUL N)
	Applies the binary operator function pl_ModF() to each item in two input vectors.
static void	pl_VectorModF_NN1 (PlankF result, const PlankF a, PlankF b, PlankUL N)
	Applies the binary operator function pl_ModF() to an input vector and a scalar value.
static void	pl_VectorModF_N1N (PlankF result, PlankF a, const PlankF b, PlankUL N)
	Applies the binary operator function pl_ModF() to an input vector and a scalar value.
static void	pl_VectorMinF_NNN (PlankF result, const PlankF a, const PlankF *b, PlankUL N)
	Applies the binary operator function pl_MinF() to each item in two input vectors.
static void	pl_VectorMinF_NN1 (PlankF result, const PlankF a, PlankF b, PlankUL N)
	Applies the binary operator function pl_MinF() to an input vector and a scalar value.
static void	pl_VectorMinF_N1N (PlankF result, PlankF a, const PlankF b, PlankUL N)
	Applies the binary operator function pl_MinF() to an input vector and a scalar value.
static void	pl_VectorMaxF_NNN (PlankF result, const PlankF a, const PlankF *b, PlankUL N)
	Applies the binary operator function pl_MaxF() to each item in two input vectors.
static void	pl_VectorMaxF_NN1 (PlankF result, const PlankF a, PlankF b, PlankUL N)
	Applies the binary operator function pl_MaxF() to an input vector and a scalar value.
static void	pl_VectorMaxF_N1N (PlankF result, PlankF a, const PlankF b, PlankUL N)
	Applies the binary operator function pl_MaxF() to an input vector and a scalar value.
static void	pl_VectorIsEqualToF_NNN (PlankF result, const PlankF a, const PlankF *b, PlankUL N)
	Applies the binary operator function pl_IsEqualToF() to each item in two input vectors.
static void	pl_VectorIsEqualToF_NN1 (PlankF result, const PlankF a, PlankF b, PlankUL N)
	Applies the binary operator function pl_IsEqualToF() to an input vector and a scalar value.
static void	pl_VectorIsEqualToF_N1N (PlankF result, PlankF a, const PlankF b, PlankUL N)
	Applies the binary operator function pl_IsEqualToF() to an input vector and a scalar value.
static void	pl_VectorIsNotEqualToF_NNN (PlankF result, const PlankF a, const PlankF *b, PlankUL N)
	Applies the binary operator function pl_IsNotEqualToF() to each item in two input vectors.
static void	pl_VectorIsNotEqualToF_NN1 (PlankF result, const PlankF a, PlankF b, PlankUL N)
	Applies the binary operator function pl_IsNotEqualToF() to an input vector and a scalar value.
static void	pl_VectorIsNotEqualToF_N1N (PlankF result, PlankF a, const PlankF b, PlankUL N)
	Applies the binary operator function pl_IsNotEqualToF() to an input vector and a scalar value.
static void	pl_VectorIsGreaterThanF_NNN (PlankF result, const PlankF a, const PlankF *b, PlankUL N)
	Applies the binary operator function pl_IsGreaterThanF() to each item in two input vectors.
static void	pl_VectorIsGreaterThanF_NN1 (PlankF result, const PlankF a, PlankF b, PlankUL N)
	Applies the binary operator function pl_IsGreaterThanF() to an input vector and a scalar value.
static void	pl_VectorIsGreaterThanF_N1N (PlankF result, PlankF a, const PlankF b, PlankUL N)
	Applies the binary operator function pl_IsGreaterThanF() to an input vector and a scalar value.
static void	pl_VectorIsGreaterThanOrEqualToF_NNN (PlankF result, const PlankF a, const PlankF *b, PlankUL N)
	Applies the binary operator function pl_IsGreaterThanOrEqualToF() to each item in two input vectors.
static void	pl_VectorIsGreaterThanOrEqualToF_NN1 (PlankF result, const PlankF a, PlankF b, PlankUL N)
	Applies the binary operator function pl_IsGreaterThanOrEqualToF() to an input vector and a scalar value.
static void	pl_VectorIsGreaterThanOrEqualToF_N1N (PlankF result, PlankF a, const PlankF b, PlankUL N)
	Applies the binary operator function pl_IsGreaterThanOrEqualToF() to an input vector and a scalar value.
static void	pl_VectorIsLessThanF_NNN (PlankF result, const PlankF a, const PlankF *b, PlankUL N)
	Applies the binary operator function pl_IsLessThanF() to each item in two input vectors.
static void	pl_VectorIsLessThanF_NN1 (PlankF result, const PlankF a, PlankF b, PlankUL N)
	Applies the binary operator function pl_IsLessThanF() to an input vector and a scalar value.
static void	pl_VectorIsLessThanF_N1N (PlankF result, PlankF a, const PlankF b, PlankUL N)
	Applies the binary operator function pl_IsLessThanF() to an input vector and a scalar value.
static void	pl_VectorIsLessThanOrEqualToF_NNN (PlankF result, const PlankF a, const PlankF *b, PlankUL N)
	Applies the binary operator function pl_IsLessThanOrEqualToF() to each item in two input vectors.
static void	pl_VectorIsLessThanOrEqualToF_NN1 (PlankF result, const PlankF a, PlankF b, PlankUL N)
	Applies the binary operator function pl_IsLessThanOrEqualToF() to an input vector and a scalar value.
static void	pl_VectorIsLessThanOrEqualToF_N1N (PlankF result, PlankF a, const PlankF b, PlankUL N)
	Applies the binary operator function pl_IsLessThanOrEqualToF() to an input vector and a scalar value.
static void	pl_VectorSumSqrF_NNN (PlankF result, const PlankF a, const PlankF *b, PlankUL N)
	Applies the binary operator function pl_SumSqrF() to each item in two input vectors.
static void	pl_VectorSumSqrF_NN1 (PlankF result, const PlankF a, PlankF b, PlankUL N)
	Applies the binary operator function pl_SumSqrF() to an input vector and a scalar value.
static void	pl_VectorSumSqrF_N1N (PlankF result, PlankF a, const PlankF b, PlankUL N)
	Applies the binary operator function pl_SumSqrF() to an input vector and a scalar value.
static void	pl_VectorDifSqrF_NNN (PlankF result, const PlankF a, const PlankF *b, PlankUL N)
	Applies the binary operator function pl_DifSqrF() to each item in two input vectors.
static void	pl_VectorDifSqrF_NN1 (PlankF result, const PlankF a, PlankF b, PlankUL N)
	Applies the binary operator function pl_DifSqrF() to an input vector and a scalar value.
static void	pl_VectorDifSqrF_N1N (PlankF result, PlankF a, const PlankF b, PlankUL N)
	Applies the binary operator function pl_DifSqrF() to an input vector and a scalar value.
static void	pl_VectorSqrSumF_NNN (PlankF result, const PlankF a, const PlankF *b, PlankUL N)
	Applies the binary operator function pl_SqrSumF() to each item in two input vectors.
static void	pl_VectorSqrSumF_NN1 (PlankF result, const PlankF a, PlankF b, PlankUL N)
	Applies the binary operator function pl_SqrSumF() to an input vector and a scalar value.
static void	pl_VectorSqrSumF_N1N (PlankF result, PlankF a, const PlankF b, PlankUL N)
	Applies the binary operator function pl_SqrSumF() to an input vector and a scalar value.
static void	pl_VectorSqrDifF_NNN (PlankF result, const PlankF a, const PlankF *b, PlankUL N)
	Applies the binary operator function pl_SqrDifF() to each item in two input vectors.
static void	pl_VectorSqrDifF_NN1 (PlankF result, const PlankF a, PlankF b, PlankUL N)
	Applies the binary operator function pl_SqrDifF() to an input vector and a scalar value.
static void	pl_VectorSqrDifF_N1N (PlankF result, PlankF a, const PlankF b, PlankUL N)
	Applies the binary operator function pl_SqrDifF() to an input vector and a scalar value.
static void	pl_VectorAbsDifF_NNN (PlankF result, const PlankF a, const PlankF *b, PlankUL N)
	Applies the binary operator function pl_AbsDifF() to each item in two input vectors.
static void	pl_VectorAbsDifF_NN1 (PlankF result, const PlankF a, PlankF b, PlankUL N)
	Applies the binary operator function pl_AbsDifF() to an input vector and a scalar value.
static void	pl_VectorAbsDifF_N1N (PlankF result, PlankF a, const PlankF b, PlankUL N)
	Applies the binary operator function pl_AbsDifF() to an input vector and a scalar value.
static void	pl_VectorThreshF_NNN (PlankF result, const PlankF a, const PlankF *b, PlankUL N)
	Applies the binary operator function pl_ThreshF() to each item in two input vectors.
static void	pl_VectorThreshF_NN1 (PlankF result, const PlankF a, PlankF b, PlankUL N)
	Applies the binary operator function pl_ThreshF() to an input vector and a scalar value.
static void	pl_VectorThreshF_N1N (PlankF result, PlankF a, const PlankF b, PlankUL N)
	Applies the binary operator function pl_ThreshF() to an input vector and a scalar value.
static void	pl_VectorMulAddF_NNNN (PlankF result, const PlankF input, const PlankF mul, const PlankF add, PlankUL N)
	Applies the multiply and add operator to a set of vectors.
static void	pl_VectorMulAddF_NNN (PlankF io, const PlankF mul, const PlankF *add, PlankUL N)
	Applies the multiply and add operator to a set of vectors.
static void	pl_VectorMulAddF_NNN1 (PlankF result, const PlankF input, const PlankF *mul, PlankF add, PlankUL N)
	Applies the multiply and add operator to a set of vectors.
static void	pl_VectorMulAddF_NN11 (PlankF result, const PlankF input, PlankF mul, PlankF add, PlankUL N)
	Applies the multiply and add operator to a set of vectors.
static void	pl_VectorMulAddF_NN1N (PlankF result, const PlankF input, PlankF mul, const PlankF *add, PlankUL N)
	Applies the multiply and add operator to a set of vectors.
static void	pl_VectorLookupF_NnN (PlankF result, PlankF table, PlankUL n, PlankF *index, PlankUL N)
	Generate a vector by using another vector as the indices into a lookup table.
static void	pl_VectorLog2F_NN (PlankF result, const PlankF a, PlankUL N)
	Applies the function pl_Log2F() to each item in a vector.
static void	pl_VectorReciprocalF_NN (PlankF result, const PlankF a, PlankUL N)
	Applies the function pl_ReciprocalF() to each item in a vector.
static void	pl_VectorSinF_NN (PlankF result, const PlankF a, PlankUL N)
	Applies the function pl_SinF() to each item in a vector.
static void	pl_VectorCosF_NN (PlankF result, const PlankF a, PlankUL N)
	Applies the function pl_CosF() to each item in a vector.
static void	pl_VectorTanF_NN (PlankF result, const PlankF a, PlankUL N)
	Applies the function pl_TanF() to each item in a vector.
static void	pl_VectorAsinF_NN (PlankF result, const PlankF a, PlankUL N)
	Applies the function pl_AsinF() to each item in a vector.
static void	pl_VectorAcosF_NN (PlankF result, const PlankF a, PlankUL N)
	Applies the function pl_AcosF() to each item in a vector.
static void	pl_VectorAtanF_NN (PlankF result, const PlankF a, PlankUL N)
	Applies the function pl_AtanF() to each item in a vector.
static void	pl_VectorSinhF_NN (PlankF result, const PlankF a, PlankUL N)
	Applies the function pl_SinhF() to each item in a vector.
static void	pl_VectorCoshF_NN (PlankF result, const PlankF a, PlankUL N)
	Applies the function pl_CoshF() to each item in a vector.
static void	pl_VectorTanhF_NN (PlankF result, const PlankF a, PlankUL N)
	Applies the function pl_TanhF() to each item in a vector.
static void	pl_VectorSqrtF_NN (PlankF result, const PlankF a, PlankUL N)
	Applies the function pl_SqrtF() to each item in a vector.
static void	pl_VectorLogF_NN (PlankF result, const PlankF a, PlankUL N)
	Applies the function pl_LogF() to each item in a vector.
static void	pl_VectorLog10F_NN (PlankF result, const PlankF a, PlankUL N)
	Applies the function pl_Log10F() to each item in a vector.
static void	pl_VectorExpF_NN (PlankF result, const PlankF a, PlankUL N)
	Applies the function pl_ExpF() to each item in a vector.
static void	pl_VectorCeilF_NN (PlankF result, const PlankF a, PlankUL N)
	Applies the function pl_CeilF() to each item in a vector.
static void	pl_VectorFloorF_NN (PlankF result, const PlankF a, PlankUL N)
	Applies the function pl_FloorF() to each item in a vector.
static void	pl_VectorFracF_NN (PlankF result, const PlankF a, PlankUL N)
	Applies the function pl_FracF() to each item in a vector.
static void	pl_VectorM2FF_NN (PlankF result, const PlankF a, PlankUL N)
	Applies the function pl_M2FF() to each item in a vector.
static void	pl_VectorF2MF_NN (PlankF result, const PlankF a, PlankUL N)
	Applies the function pl_F2MF() to each item in a vector.
static void	pl_VectorA2dBF_NN (PlankF result, const PlankF a, PlankUL N)
	Applies the function pl_A2dBF() to each item in a vector.
static void	pl_VectordB2AF_NN (PlankF result, const PlankF a, PlankUL N)
	Applies the function pl_dB2AF() to each item in a vector.
static void	pl_VectorD2RF_NN (PlankF result, const PlankF a, PlankUL N)
	Applies the function pl_D2RF() to each item in a vector.
static void	pl_VectorR2DF_NN (PlankF result, const PlankF a, PlankUL N)
	Applies the function pl_R2DF() to each item in a vector.
static void	pl_VectorDistortF_NN (PlankF result, const PlankF a, PlankUL N)
	Applies the function pl_DistortF() to each item in a vector.
static void	pl_VectorZapF_NN (PlankF result, const PlankF a, PlankUL N)
	Applies the function pl_ZapF() to each item in a vector.
static void	pl_VectorPowF_NNN (PlankF result, const PlankF a, const PlankF *b, PlankUL N)
	Applies the binary operator function pl_PowF() to each item in two input vectors.
static void	pl_VectorPowF_NN1 (PlankF result, const PlankF a, PlankF b, PlankUL N)
	Applies the binary operator function pl_PowF() to an input vector and a scalar value.
static void	pl_VectorPowF_N1N (PlankF result, PlankF a, const PlankF b, PlankUL N)
	Applies the binary operator function pl_PowF() to an input vector and a scalar value.
static void	pl_VectorHypotF_NNN (PlankF result, const PlankF a, const PlankF *b, PlankUL N)
	Applies the binary operator function pl_HypotF() to each item in two input vectors.
static void	pl_VectorHypotF_NN1 (PlankF result, const PlankF a, PlankF b, PlankUL N)
	Applies the binary operator function pl_HypotF() to an input vector and a scalar value.
static void	pl_VectorHypotF_N1N (PlankF result, PlankF a, const PlankF b, PlankUL N)
	Applies the binary operator function pl_HypotF() to an input vector and a scalar value.
static void	pl_VectorAtan2F_NNN (PlankF result, const PlankF a, const PlankF *b, PlankUL N)
	Applies the binary operator function pl_Atan2F() to each item in two input vectors.
static void	pl_VectorAtan2F_NN1 (PlankF result, const PlankF a, PlankF b, PlankUL N)
	Applies the binary operator function pl_Atan2F() to an input vector and a scalar value.
static void	pl_VectorAtan2F_N1N (PlankF result, PlankF a, const PlankF b, PlankUL N)
	Applies the binary operator function pl_Atan2F() to an input vector and a scalar value.
static void	pl_VectorFillD_N1 (PlankD *result, PlankD value, PlankUL N)
	Fills a vector with a constant.
static void	pl_VectorClearD_N (PlankD *result, PlankUL N)
	Fills a vector with zeros.
static void	pl_VectorRampD_N11 (PlankD *result, PlankD a, PlankD b, PlankUL N)
	Fills a vector with a ramp.
static void	pl_VectorLineD_N11 (PlankD *result, PlankD a, PlankD b, PlankUL N)
	Fills a vector with a line.
static void	pl_VectorMoveD_NN (PlankD result, const PlankD a, PlankUL N)
	Applies the function pl_MoveD() to each item in a vector.
static void	pl_VectorIncD_NN (PlankD result, const PlankD a, PlankUL N)
	Applies the function pl_IncD() to each item in a vector.
static void	pl_VectorDecD_NN (PlankD result, const PlankD a, PlankUL N)
	Applies the function pl_DecD() to each item in a vector.
static void	pl_VectorNegD_NN (PlankD result, const PlankD a, PlankUL N)
	Applies the function pl_NegD() to each item in a vector.
static void	pl_VectorAbsD_NN (PlankD result, const PlankD a, PlankUL N)
	Applies the function pl_AbsD() to each item in a vector.
static void	pl_VectorSquaredD_NN (PlankD result, const PlankD a, PlankUL N)
	Applies the function pl_SquaredD() to each item in a vector.
static void	pl_VectorCubedD_NN (PlankD result, const PlankD a, PlankUL N)
	Applies the function pl_CubedD() to each item in a vector.
static void	pl_VectorSignD_NN (PlankD result, const PlankD a, PlankUL N)
	Applies the function pl_SignD() to each item in a vector.
static void	pl_VectorAddD_NNN (PlankD result, const PlankD a, const PlankD *b, PlankUL N)
	Applies the binary operator function pl_AddD() to each item in two input vectors.
static void	pl_VectorAddD_NN1 (PlankD result, const PlankD a, PlankD b, PlankUL N)
	Applies the binary operator function pl_AddD() to an input vector and a scalar value.
static void	pl_VectorAddD_N1N (PlankD result, PlankD a, const PlankD b, PlankUL N)
	Applies the binary operator function pl_AddD() to an input vector and a scalar value.
static void	pl_VectorSubD_NNN (PlankD result, const PlankD a, const PlankD *b, PlankUL N)
	Applies the binary operator function pl_SubD() to each item in two input vectors.
static void	pl_VectorSubD_NN1 (PlankD result, const PlankD a, PlankD b, PlankUL N)
	Applies the binary operator function pl_SubD() to an input vector and a scalar value.
static void	pl_VectorSubD_N1N (PlankD result, PlankD a, const PlankD b, PlankUL N)
	Applies the binary operator function pl_SubD() to an input vector and a scalar value.
static void	pl_VectorMulD_NNN (PlankD result, const PlankD a, const PlankD *b, PlankUL N)
	Applies the binary operator function pl_MulD() to each item in two input vectors.
static void	pl_VectorMulD_NN1 (PlankD result, const PlankD a, PlankD b, PlankUL N)
	Applies the binary operator function pl_MulD() to an input vector and a scalar value.
static void	pl_VectorMulD_N1N (PlankD result, PlankD a, const PlankD b, PlankUL N)
	Applies the binary operator function pl_MulD() to an input vector and a scalar value.
static void	pl_VectorDivD_NNN (PlankD result, const PlankD a, const PlankD *b, PlankUL N)
	Applies the binary operator function pl_DivD() to each item in two input vectors.
static void	pl_VectorDivD_NN1 (PlankD result, const PlankD a, PlankD b, PlankUL N)
	Applies the binary operator function pl_DivD() to an input vector and a scalar value.
static void	pl_VectorDivD_N1N (PlankD result, PlankD a, const PlankD b, PlankUL N)
	Applies the binary operator function pl_DivD() to an input vector and a scalar value.
static void	pl_VectorModD_NNN (PlankD result, const PlankD a, const PlankD *b, PlankUL N)
	Applies the binary operator function pl_ModD() to each item in two input vectors.
static void	pl_VectorModD_NN1 (PlankD result, const PlankD a, PlankD b, PlankUL N)
	Applies the binary operator function pl_ModD() to an input vector and a scalar value.
static void	pl_VectorModD_N1N (PlankD result, PlankD a, const PlankD b, PlankUL N)
	Applies the binary operator function pl_ModD() to an input vector and a scalar value.
static void	pl_VectorMinD_NNN (PlankD result, const PlankD a, const PlankD *b, PlankUL N)
	Applies the binary operator function pl_MinD() to each item in two input vectors.
static void	pl_VectorMinD_NN1 (PlankD result, const PlankD a, PlankD b, PlankUL N)
	Applies the binary operator function pl_MinD() to an input vector and a scalar value.
static void	pl_VectorMinD_N1N (PlankD result, PlankD a, const PlankD b, PlankUL N)
	Applies the binary operator function pl_MinD() to an input vector and a scalar value.
static void	pl_VectorMaxD_NNN (PlankD result, const PlankD a, const PlankD *b, PlankUL N)
	Applies the binary operator function pl_MaxD() to each item in two input vectors.
static void	pl_VectorMaxD_NN1 (PlankD result, const PlankD a, PlankD b, PlankUL N)
	Applies the binary operator function pl_MaxD() to an input vector and a scalar value.
static void	pl_VectorMaxD_N1N (PlankD result, PlankD a, const PlankD b, PlankUL N)
	Applies the binary operator function pl_MaxD() to an input vector and a scalar value.
static void	pl_VectorIsEqualToD_NNN (PlankD result, const PlankD a, const PlankD *b, PlankUL N)
	Applies the binary operator function pl_IsEqualToD() to each item in two input vectors.
static void	pl_VectorIsEqualToD_NN1 (PlankD result, const PlankD a, PlankD b, PlankUL N)
	Applies the binary operator function pl_IsEqualToD() to an input vector and a scalar value.
static void	pl_VectorIsEqualToD_N1N (PlankD result, PlankD a, const PlankD b, PlankUL N)
	Applies the binary operator function pl_IsEqualToD() to an input vector and a scalar value.
static void	pl_VectorIsNotEqualToD_NNN (PlankD result, const PlankD a, const PlankD *b, PlankUL N)
	Applies the binary operator function pl_IsNotEqualToD() to each item in two input vectors.
static void	pl_VectorIsNotEqualToD_NN1 (PlankD result, const PlankD a, PlankD b, PlankUL N)
	Applies the binary operator function pl_IsNotEqualToD() to an input vector and a scalar value.
static void	pl_VectorIsNotEqualToD_N1N (PlankD result, PlankD a, const PlankD b, PlankUL N)
	Applies the binary operator function pl_IsNotEqualToD() to an input vector and a scalar value.
static void	pl_VectorIsGreaterThanD_NNN (PlankD result, const PlankD a, const PlankD *b, PlankUL N)
	Applies the binary operator function pl_IsGreaterThanD() to each item in two input vectors.
static void	pl_VectorIsGreaterThanD_NN1 (PlankD result, const PlankD a, PlankD b, PlankUL N)
	Applies the binary operator function pl_IsGreaterThanD() to an input vector and a scalar value.
static void	pl_VectorIsGreaterThanD_N1N (PlankD result, PlankD a, const PlankD b, PlankUL N)
	Applies the binary operator function pl_IsGreaterThanD() to an input vector and a scalar value.
static void	pl_VectorIsGreaterThanOrEqualToD_NNN (PlankD result, const PlankD a, const PlankD *b, PlankUL N)
	Applies the binary operator function pl_IsGreaterThanOrEqualToD() to each item in two input vectors.
static void	pl_VectorIsGreaterThanOrEqualToD_NN1 (PlankD result, const PlankD a, PlankD b, PlankUL N)
	Applies the binary operator function pl_IsGreaterThanOrEqualToD() to an input vector and a scalar value.
static void	pl_VectorIsGreaterThanOrEqualToD_N1N (PlankD result, PlankD a, const PlankD b, PlankUL N)
	Applies the binary operator function pl_IsGreaterThanOrEqualToD() to an input vector and a scalar value.
static void	pl_VectorIsLessThanD_NNN (PlankD result, const PlankD a, const PlankD *b, PlankUL N)
	Applies the binary operator function pl_IsLessThanD() to each item in two input vectors.
static void	pl_VectorIsLessThanD_NN1 (PlankD result, const PlankD a, PlankD b, PlankUL N)
	Applies the binary operator function pl_IsLessThanD() to an input vector and a scalar value.
static void	pl_VectorIsLessThanD_N1N (PlankD result, PlankD a, const PlankD b, PlankUL N)
	Applies the binary operator function pl_IsLessThanD() to an input vector and a scalar value.
static void	pl_VectorIsLessThanOrEqualToD_NNN (PlankD result, const PlankD a, const PlankD *b, PlankUL N)
	Applies the binary operator function pl_IsLessThanOrEqualToD() to each item in two input vectors.
static void	pl_VectorIsLessThanOrEqualToD_NN1 (PlankD result, const PlankD a, PlankD b, PlankUL N)
	Applies the binary operator function pl_IsLessThanOrEqualToD() to an input vector and a scalar value.
static void	pl_VectorIsLessThanOrEqualToD_N1N (PlankD result, PlankD a, const PlankD b, PlankUL N)
	Applies the binary operator function pl_IsLessThanOrEqualToD() to an input vector and a scalar value.
static void	pl_VectorSumSqrD_NNN (PlankD result, const PlankD a, const PlankD *b, PlankUL N)
	Applies the binary operator function pl_SumSqrD() to each item in two input vectors.
static void	pl_VectorSumSqrD_NN1 (PlankD result, const PlankD a, PlankD b, PlankUL N)
	Applies the binary operator function pl_SumSqrD() to an input vector and a scalar value.
static void	pl_VectorSumSqrD_N1N (PlankD result, PlankD a, const PlankD b, PlankUL N)
	Applies the binary operator function pl_SumSqrD() to an input vector and a scalar value.
static void	pl_VectorDifSqrD_NNN (PlankD result, const PlankD a, const PlankD *b, PlankUL N)
	Applies the binary operator function pl_DifSqrD() to each item in two input vectors.
static void	pl_VectorDifSqrD_NN1 (PlankD result, const PlankD a, PlankD b, PlankUL N)
	Applies the binary operator function pl_DifSqrD() to an input vector and a scalar value.
static void	pl_VectorDifSqrD_N1N (PlankD result, PlankD a, const PlankD b, PlankUL N)
	Applies the binary operator function pl_DifSqrD() to an input vector and a scalar value.
static void	pl_VectorSqrSumD_NNN (PlankD result, const PlankD a, const PlankD *b, PlankUL N)
	Applies the binary operator function pl_SqrSumD() to each item in two input vectors.
static void	pl_VectorSqrSumD_NN1 (PlankD result, const PlankD a, PlankD b, PlankUL N)
	Applies the binary operator function pl_SqrSumD() to an input vector and a scalar value.
static void	pl_VectorSqrSumD_N1N (PlankD result, PlankD a, const PlankD b, PlankUL N)
	Applies the binary operator function pl_SqrSumD() to an input vector and a scalar value.
static void	pl_VectorSqrDifD_NNN (PlankD result, const PlankD a, const PlankD *b, PlankUL N)
	Applies the binary operator function pl_SqrDifD() to each item in two input vectors.
static void	pl_VectorSqrDifD_NN1 (PlankD result, const PlankD a, PlankD b, PlankUL N)
	Applies the binary operator function pl_SqrDifD() to an input vector and a scalar value.
static void	pl_VectorSqrDifD_N1N (PlankD result, PlankD a, const PlankD b, PlankUL N)
	Applies the binary operator function pl_SqrDifD() to an input vector and a scalar value.
static void	pl_VectorAbsDifD_NNN (PlankD result, const PlankD a, const PlankD *b, PlankUL N)
	Applies the binary operator function pl_AbsDifD() to each item in two input vectors.
static void	pl_VectorAbsDifD_NN1 (PlankD result, const PlankD a, PlankD b, PlankUL N)
	Applies the binary operator function pl_AbsDifD() to an input vector and a scalar value.
static void	pl_VectorAbsDifD_N1N (PlankD result, PlankD a, const PlankD b, PlankUL N)
	Applies the binary operator function pl_AbsDifD() to an input vector and a scalar value.
static void	pl_VectorThreshD_NNN (PlankD result, const PlankD a, const PlankD *b, PlankUL N)
	Applies the binary operator function pl_ThreshD() to each item in two input vectors.
static void	pl_VectorThreshD_NN1 (PlankD result, const PlankD a, PlankD b, PlankUL N)
	Applies the binary operator function pl_ThreshD() to an input vector and a scalar value.
static void	pl_VectorThreshD_N1N (PlankD result, PlankD a, const PlankD b, PlankUL N)
	Applies the binary operator function pl_ThreshD() to an input vector and a scalar value.
static void	pl_VectorMulAddD_NNNN (PlankD result, const PlankD input, const PlankD mul, const PlankD add, PlankUL N)
	Applies the multiply and add operator to a set of vectors.
static void	pl_VectorMulAddD_NNN (PlankD io, const PlankD mul, const PlankD *add, PlankUL N)
	Applies the multiply and add operator to a set of vectors.
static void	pl_VectorMulAddD_NNN1 (PlankD result, const PlankD input, const PlankD *mul, PlankD add, PlankUL N)
	Applies the multiply and add operator to a set of vectors.
static void	pl_VectorMulAddD_NN11 (PlankD result, const PlankD input, PlankD mul, PlankD add, PlankUL N)
	Applies the multiply and add operator to a set of vectors.
static void	pl_VectorMulAddD_NN1N (PlankD result, const PlankD input, PlankD mul, const PlankD *add, PlankUL N)
	Applies the multiply and add operator to a set of vectors.
static void	pl_VectorLookupD_NnN (PlankD result, PlankD table, PlankUL n, PlankD *index, PlankUL N)
	Generate a vector by using another vector as the indices into a lookup table.
static void	pl_VectorLog2D_NN (PlankD result, const PlankD a, PlankUL N)
	Applies the function pl_Log2D() to each item in a vector.
static void	pl_VectorReciprocalD_NN (PlankD result, const PlankD a, PlankUL N)
	Applies the function pl_ReciprocalD() to each item in a vector.
static void	pl_VectorSinD_NN (PlankD result, const PlankD a, PlankUL N)
	Applies the function pl_SinD() to each item in a vector.
static void	pl_VectorCosD_NN (PlankD result, const PlankD a, PlankUL N)
	Applies the function pl_CosD() to each item in a vector.
static void	pl_VectorTanD_NN (PlankD result, const PlankD a, PlankUL N)
	Applies the function pl_TanD() to each item in a vector.
static void	pl_VectorAsinD_NN (PlankD result, const PlankD a, PlankUL N)
	Applies the function pl_AsinD() to each item in a vector.
static void	pl_VectorAcosD_NN (PlankD result, const PlankD a, PlankUL N)
	Applies the function pl_AcosD() to each item in a vector.
static void	pl_VectorAtanD_NN (PlankD result, const PlankD a, PlankUL N)
	Applies the function pl_AtanD() to each item in a vector.
static void	pl_VectorSinhD_NN (PlankD result, const PlankD a, PlankUL N)
	Applies the function pl_SinhD() to each item in a vector.
static void	pl_VectorCoshD_NN (PlankD result, const PlankD a, PlankUL N)
	Applies the function pl_CoshD() to each item in a vector.
static void	pl_VectorTanhD_NN (PlankD result, const PlankD a, PlankUL N)
	Applies the function pl_TanhD() to each item in a vector.
static void	pl_VectorSqrtD_NN (PlankD result, const PlankD a, PlankUL N)
	Applies the function pl_SqrtD() to each item in a vector.
static void	pl_VectorLogD_NN (PlankD result, const PlankD a, PlankUL N)
	Applies the function pl_LogD() to each item in a vector.
static void	pl_VectorLog10D_NN (PlankD result, const PlankD a, PlankUL N)
	Applies the function pl_Log10D() to each item in a vector.
static void	pl_VectorExpD_NN (PlankD result, const PlankD a, PlankUL N)
	Applies the function pl_ExpD() to each item in a vector.
static void	pl_VectorCeilD_NN (PlankD result, const PlankD a, PlankUL N)
	Applies the function pl_CeilD() to each item in a vector.
static void	pl_VectorFloorD_NN (PlankD result, const PlankD a, PlankUL N)
	Applies the function pl_FloorD() to each item in a vector.
static void	pl_VectorFracD_NN (PlankD result, const PlankD a, PlankUL N)
	Applies the function pl_FracD() to each item in a vector.
static void	pl_VectorM2FD_NN (PlankD result, const PlankD a, PlankUL N)
	Applies the function pl_M2FD() to each item in a vector.
static void	pl_VectorF2MD_NN (PlankD result, const PlankD a, PlankUL N)
	Applies the function pl_F2MD() to each item in a vector.
static void	pl_VectorA2dBD_NN (PlankD result, const PlankD a, PlankUL N)
	Applies the function pl_A2dBD() to each item in a vector.
static void	pl_VectordB2AD_NN (PlankD result, const PlankD a, PlankUL N)
	Applies the function pl_dB2AD() to each item in a vector.
static void	pl_VectorD2RD_NN (PlankD result, const PlankD a, PlankUL N)
	Applies the function pl_D2RD() to each item in a vector.
static void	pl_VectorR2DD_NN (PlankD result, const PlankD a, PlankUL N)
	Applies the function pl_R2DD() to each item in a vector.
static void	pl_VectorDistortD_NN (PlankD result, const PlankD a, PlankUL N)
	Applies the function pl_DistortD() to each item in a vector.
static void	pl_VectorZapD_NN (PlankD result, const PlankD a, PlankUL N)
	Applies the function pl_ZapD() to each item in a vector.
static void	pl_VectorPowD_NNN (PlankD result, const PlankD a, const PlankD *b, PlankUL N)
	Applies the binary operator function pl_PowD() to each item in two input vectors.
static void	pl_VectorPowD_NN1 (PlankD result, const PlankD a, PlankD b, PlankUL N)
	Applies the binary operator function pl_PowD() to an input vector and a scalar value.
static void	pl_VectorPowD_N1N (PlankD result, PlankD a, const PlankD b, PlankUL N)
	Applies the binary operator function pl_PowD() to an input vector and a scalar value.
static void	pl_VectorHypotD_NNN (PlankD result, const PlankD a, const PlankD *b, PlankUL N)
	Applies the binary operator function pl_HypotD() to each item in two input vectors.
static void	pl_VectorHypotD_NN1 (PlankD result, const PlankD a, PlankD b, PlankUL N)
	Applies the binary operator function pl_HypotD() to an input vector and a scalar value.
static void	pl_VectorHypotD_N1N (PlankD result, PlankD a, const PlankD b, PlankUL N)
	Applies the binary operator function pl_HypotD() to an input vector and a scalar value.
static void	pl_VectorAtan2D_NNN (PlankD result, const PlankD a, const PlankD *b, PlankUL N)
	Applies the binary operator function pl_Atan2D() to each item in two input vectors.
static void	pl_VectorAtan2D_NN1 (PlankD result, const PlankD a, PlankD b, PlankUL N)
	Applies the binary operator function pl_Atan2D() to an input vector and a scalar value.
static void	pl_VectorAtan2D_N1N (PlankD result, PlankD a, const PlankD b, PlankUL N)
	Applies the binary operator function pl_Atan2D() to an input vector and a scalar value.
static void	pl_VectorFillS_N1 (PlankS *result, PlankS value, PlankUL N)
	Fills a vector with a constant.
static void	pl_VectorClearS_N (PlankS *result, PlankUL N)
	Fills a vector with zeros.
static void	pl_VectorRampS_N11 (PlankS *result, PlankS a, PlankS b, PlankUL N)
	Fills a vector with a ramp.
static void	pl_VectorLineS_N11 (PlankS *result, PlankS a, PlankS b, PlankUL N)
	Fills a vector with a line.
static void	pl_VectorMoveS_NN (PlankS result, const PlankS a, PlankUL N)
	Applies the function pl_MoveS() to each item in a vector.
static void	pl_VectorIncS_NN (PlankS result, const PlankS a, PlankUL N)
	Applies the function pl_IncS() to each item in a vector.
static void	pl_VectorDecS_NN (PlankS result, const PlankS a, PlankUL N)
	Applies the function pl_DecS() to each item in a vector.
static void	pl_VectorNegS_NN (PlankS result, const PlankS a, PlankUL N)
	Applies the function pl_NegS() to each item in a vector.
static void	pl_VectorAbsS_NN (PlankS result, const PlankS a, PlankUL N)
	Applies the function pl_AbsS() to each item in a vector.
static void	pl_VectorSquaredS_NN (PlankS result, const PlankS a, PlankUL N)
	Applies the function pl_SquaredS() to each item in a vector.
static void	pl_VectorCubedS_NN (PlankS result, const PlankS a, PlankUL N)
	Applies the function pl_CubedS() to each item in a vector.
static void	pl_VectorSignS_NN (PlankS result, const PlankS a, PlankUL N)
	Applies the function pl_SignS() to each item in a vector.
static void	pl_VectorAddS_NNN (PlankS result, const PlankS a, const PlankS *b, PlankUL N)
	Applies the binary operator function pl_AddS() to each item in two input vectors.
static void	pl_VectorAddS_NN1 (PlankS result, const PlankS a, PlankS b, PlankUL N)
	Applies the binary operator function pl_AddS() to an input vector and a scalar value.
static void	pl_VectorAddS_N1N (PlankS result, PlankS a, const PlankS b, PlankUL N)
	Applies the binary operator function pl_AddS() to an input vector and a scalar value.
static void	pl_VectorSubS_NNN (PlankS result, const PlankS a, const PlankS *b, PlankUL N)
	Applies the binary operator function pl_SubS() to each item in two input vectors.
static void	pl_VectorSubS_NN1 (PlankS result, const PlankS a, PlankS b, PlankUL N)
	Applies the binary operator function pl_SubS() to an input vector and a scalar value.
static void	pl_VectorSubS_N1N (PlankS result, PlankS a, const PlankS b, PlankUL N)
	Applies the binary operator function pl_SubS() to an input vector and a scalar value.
static void	pl_VectorMulS_NNN (PlankS result, const PlankS a, const PlankS *b, PlankUL N)
	Applies the binary operator function pl_MulS() to each item in two input vectors.
static void	pl_VectorMulS_NN1 (PlankS result, const PlankS a, PlankS b, PlankUL N)
	Applies the binary operator function pl_MulS() to an input vector and a scalar value.
static void	pl_VectorMulS_N1N (PlankS result, PlankS a, const PlankS b, PlankUL N)
	Applies the binary operator function pl_MulS() to an input vector and a scalar value.
static void	pl_VectorDivS_NNN (PlankS result, const PlankS a, const PlankS *b, PlankUL N)
	Applies the binary operator function pl_DivS() to each item in two input vectors.
static void	pl_VectorDivS_NN1 (PlankS result, const PlankS a, PlankS b, PlankUL N)
	Applies the binary operator function pl_DivS() to an input vector and a scalar value.
static void	pl_VectorDivS_N1N (PlankS result, PlankS a, const PlankS b, PlankUL N)
	Applies the binary operator function pl_DivS() to an input vector and a scalar value.
static void	pl_VectorModS_NNN (PlankS result, const PlankS a, const PlankS *b, PlankUL N)
	Applies the binary operator function pl_ModS() to each item in two input vectors.
static void	pl_VectorModS_NN1 (PlankS result, const PlankS a, PlankS b, PlankUL N)
	Applies the binary operator function pl_ModS() to an input vector and a scalar value.
static void	pl_VectorModS_N1N (PlankS result, PlankS a, const PlankS b, PlankUL N)
	Applies the binary operator function pl_ModS() to an input vector and a scalar value.
static void	pl_VectorMinS_NNN (PlankS result, const PlankS a, const PlankS *b, PlankUL N)
	Applies the binary operator function pl_MinS() to each item in two input vectors.
static void	pl_VectorMinS_NN1 (PlankS result, const PlankS a, PlankS b, PlankUL N)
	Applies the binary operator function pl_MinS() to an input vector and a scalar value.
static void	pl_VectorMinS_N1N (PlankS result, PlankS a, const PlankS b, PlankUL N)
	Applies the binary operator function pl_MinS() to an input vector and a scalar value.
static void	pl_VectorMaxS_NNN (PlankS result, const PlankS a, const PlankS *b, PlankUL N)
	Applies the binary operator function pl_MaxS() to each item in two input vectors.
static void	pl_VectorMaxS_NN1 (PlankS result, const PlankS a, PlankS b, PlankUL N)
	Applies the binary operator function pl_MaxS() to an input vector and a scalar value.
static void	pl_VectorMaxS_N1N (PlankS result, PlankS a, const PlankS b, PlankUL N)
	Applies the binary operator function pl_MaxS() to an input vector and a scalar value.
static void	pl_VectorIsEqualToS_NNN (PlankS result, const PlankS a, const PlankS *b, PlankUL N)
	Applies the binary operator function pl_IsEqualToS() to each item in two input vectors.
static void	pl_VectorIsEqualToS_NN1 (PlankS result, const PlankS a, PlankS b, PlankUL N)
	Applies the binary operator function pl_IsEqualToS() to an input vector and a scalar value.
static void	pl_VectorIsEqualToS_N1N (PlankS result, PlankS a, const PlankS b, PlankUL N)
	Applies the binary operator function pl_IsEqualToS() to an input vector and a scalar value.
static void	pl_VectorIsNotEqualToS_NNN (PlankS result, const PlankS a, const PlankS *b, PlankUL N)
	Applies the binary operator function pl_IsNotEqualToS() to each item in two input vectors.
static void	pl_VectorIsNotEqualToS_NN1 (PlankS result, const PlankS a, PlankS b, PlankUL N)
	Applies the binary operator function pl_IsNotEqualToS() to an input vector and a scalar value.
static void	pl_VectorIsNotEqualToS_N1N (PlankS result, PlankS a, const PlankS b, PlankUL N)
	Applies the binary operator function pl_IsNotEqualToS() to an input vector and a scalar value.
static void	pl_VectorIsGreaterThanS_NNN (PlankS result, const PlankS a, const PlankS *b, PlankUL N)
	Applies the binary operator function pl_IsGreaterThanS() to each item in two input vectors.
static void	pl_VectorIsGreaterThanS_NN1 (PlankS result, const PlankS a, PlankS b, PlankUL N)
	Applies the binary operator function pl_IsGreaterThanS() to an input vector and a scalar value.
static void	pl_VectorIsGreaterThanS_N1N (PlankS result, PlankS a, const PlankS b, PlankUL N)
	Applies the binary operator function pl_IsGreaterThanS() to an input vector and a scalar value.
static void	pl_VectorIsGreaterThanOrEqualToS_NNN (PlankS result, const PlankS a, const PlankS *b, PlankUL N)
	Applies the binary operator function pl_IsGreaterThanOrEqualToS() to each item in two input vectors.
static void	pl_VectorIsGreaterThanOrEqualToS_NN1 (PlankS result, const PlankS a, PlankS b, PlankUL N)
	Applies the binary operator function pl_IsGreaterThanOrEqualToS() to an input vector and a scalar value.
static void	pl_VectorIsGreaterThanOrEqualToS_N1N (PlankS result, PlankS a, const PlankS b, PlankUL N)
	Applies the binary operator function pl_IsGreaterThanOrEqualToS() to an input vector and a scalar value.
static void	pl_VectorIsLessThanS_NNN (PlankS result, const PlankS a, const PlankS *b, PlankUL N)
	Applies the binary operator function pl_IsLessThanS() to each item in two input vectors.
static void	pl_VectorIsLessThanS_NN1 (PlankS result, const PlankS a, PlankS b, PlankUL N)
	Applies the binary operator function pl_IsLessThanS() to an input vector and a scalar value.
static void	pl_VectorIsLessThanS_N1N (PlankS result, PlankS a, const PlankS b, PlankUL N)
	Applies the binary operator function pl_IsLessThanS() to an input vector and a scalar value.
static void	pl_VectorIsLessThanOrEqualToS_NNN (PlankS result, const PlankS a, const PlankS *b, PlankUL N)
	Applies the binary operator function pl_IsLessThanOrEqualToS() to each item in two input vectors.
static void	pl_VectorIsLessThanOrEqualToS_NN1 (PlankS result, const PlankS a, PlankS b, PlankUL N)
	Applies the binary operator function pl_IsLessThanOrEqualToS() to an input vector and a scalar value.
static void	pl_VectorIsLessThanOrEqualToS_N1N (PlankS result, PlankS a, const PlankS b, PlankUL N)
	Applies the binary operator function pl_IsLessThanOrEqualToS() to an input vector and a scalar value.
static void	pl_VectorSumSqrS_NNN (PlankS result, const PlankS a, const PlankS *b, PlankUL N)
	Applies the binary operator function pl_SumSqrS() to each item in two input vectors.
static void	pl_VectorSumSqrS_NN1 (PlankS result, const PlankS a, PlankS b, PlankUL N)
	Applies the binary operator function pl_SumSqrS() to an input vector and a scalar value.
static void	pl_VectorSumSqrS_N1N (PlankS result, PlankS a, const PlankS b, PlankUL N)
	Applies the binary operator function pl_SumSqrS() to an input vector and a scalar value.
static void	pl_VectorDifSqrS_NNN (PlankS result, const PlankS a, const PlankS *b, PlankUL N)
	Applies the binary operator function pl_DifSqrS() to each item in two input vectors.
static void	pl_VectorDifSqrS_NN1 (PlankS result, const PlankS a, PlankS b, PlankUL N)
	Applies the binary operator function pl_DifSqrS() to an input vector and a scalar value.
static void	pl_VectorDifSqrS_N1N (PlankS result, PlankS a, const PlankS b, PlankUL N)
	Applies the binary operator function pl_DifSqrS() to an input vector and a scalar value.
static void	pl_VectorSqrSumS_NNN (PlankS result, const PlankS a, const PlankS *b, PlankUL N)
	Applies the binary operator function pl_SqrSumS() to each item in two input vectors.
static void	pl_VectorSqrSumS_NN1 (PlankS result, const PlankS a, PlankS b, PlankUL N)
	Applies the binary operator function pl_SqrSumS() to an input vector and a scalar value.
static void	pl_VectorSqrSumS_N1N (PlankS result, PlankS a, const PlankS b, PlankUL N)
	Applies the binary operator function pl_SqrSumS() to an input vector and a scalar value.
static void	pl_VectorSqrDifS_NNN (PlankS result, const PlankS a, const PlankS *b, PlankUL N)
	Applies the binary operator function pl_SqrDifS() to each item in two input vectors.
static void	pl_VectorSqrDifS_NN1 (PlankS result, const PlankS a, PlankS b, PlankUL N)
	Applies the binary operator function pl_SqrDifS() to an input vector and a scalar value.
static void	pl_VectorSqrDifS_N1N (PlankS result, PlankS a, const PlankS b, PlankUL N)
	Applies the binary operator function pl_SqrDifS() to an input vector and a scalar value.
static void	pl_VectorAbsDifS_NNN (PlankS result, const PlankS a, const PlankS *b, PlankUL N)
	Applies the binary operator function pl_AbsDifS() to each item in two input vectors.
static void	pl_VectorAbsDifS_NN1 (PlankS result, const PlankS a, PlankS b, PlankUL N)
	Applies the binary operator function pl_AbsDifS() to an input vector and a scalar value.
static void	pl_VectorAbsDifS_N1N (PlankS result, PlankS a, const PlankS b, PlankUL N)
	Applies the binary operator function pl_AbsDifS() to an input vector and a scalar value.
static void	pl_VectorThreshS_NNN (PlankS result, const PlankS a, const PlankS *b, PlankUL N)
	Applies the binary operator function pl_ThreshS() to each item in two input vectors.
static void	pl_VectorThreshS_NN1 (PlankS result, const PlankS a, PlankS b, PlankUL N)
	Applies the binary operator function pl_ThreshS() to an input vector and a scalar value.
static void	pl_VectorThreshS_N1N (PlankS result, PlankS a, const PlankS b, PlankUL N)
	Applies the binary operator function pl_ThreshS() to an input vector and a scalar value.
static void	pl_VectorMulAddS_NNNN (PlankS result, const PlankS input, const PlankS mul, const PlankS add, PlankUL N)
	Applies the multiply and add operator to a set of vectors.
static void	pl_VectorMulAddS_NNN (PlankS io, const PlankS mul, const PlankS *add, PlankUL N)
	Applies the multiply and add operator to a set of vectors.
static void	pl_VectorMulAddS_NNN1 (PlankS result, const PlankS input, const PlankS *mul, PlankS add, PlankUL N)
	Applies the multiply and add operator to a set of vectors.
static void	pl_VectorMulAddS_NN11 (PlankS result, const PlankS input, PlankS mul, PlankS add, PlankUL N)
	Applies the multiply and add operator to a set of vectors.
static void	pl_VectorMulAddS_NN1N (PlankS result, const PlankS input, PlankS mul, const PlankS *add, PlankUL N)
	Applies the multiply and add operator to a set of vectors.
static void	pl_VectorLookupS_NnN (PlankS result, PlankS table, PlankUL n, PlankS *index, PlankUL N)
	Generate a vector by using another vector as the indices into a lookup table.
static void	pl_VectorFillI_N1 (PlankI *result, PlankI value, PlankUL N)
	Fills a vector with a constant.
static void	pl_VectorClearI_N (PlankI *result, PlankUL N)
	Fills a vector with zeros.
static void	pl_VectorRampI_N11 (PlankI *result, PlankI a, PlankI b, PlankUL N)
	Fills a vector with a ramp.
static void	pl_VectorLineI_N11 (PlankI *result, PlankI a, PlankI b, PlankUL N)
	Fills a vector with a line.
static void	pl_VectorMoveI_NN (PlankI result, const PlankI a, PlankUL N)
	Applies the function pl_MoveI() to each item in a vector.
static void	pl_VectorIncI_NN (PlankI result, const PlankI a, PlankUL N)
	Applies the function pl_IncI() to each item in a vector.
static void	pl_VectorDecI_NN (PlankI result, const PlankI a, PlankUL N)
	Applies the function pl_DecI() to each item in a vector.
static void	pl_VectorNegI_NN (PlankI result, const PlankI a, PlankUL N)
	Applies the function pl_NegI() to each item in a vector.
static void	pl_VectorAbsI_NN (PlankI result, const PlankI a, PlankUL N)
	Applies the function pl_AbsI() to each item in a vector.
static void	pl_VectorSquaredI_NN (PlankI result, const PlankI a, PlankUL N)
	Applies the function pl_SquaredI() to each item in a vector.
static void	pl_VectorCubedI_NN (PlankI result, const PlankI a, PlankUL N)
	Applies the function pl_CubedI() to each item in a vector.
static void	pl_VectorSignI_NN (PlankI result, const PlankI a, PlankUL N)
	Applies the function pl_SignI() to each item in a vector.
static void	pl_VectorAddI_NNN (PlankI result, const PlankI a, const PlankI *b, PlankUL N)
	Applies the binary operator function pl_AddI() to each item in two input vectors.
static void	pl_VectorAddI_NN1 (PlankI result, const PlankI a, PlankI b, PlankUL N)
	Applies the binary operator function pl_AddI() to an input vector and a scalar value.
static void	pl_VectorAddI_N1N (PlankI result, PlankI a, const PlankI b, PlankUL N)
	Applies the binary operator function pl_AddI() to an input vector and a scalar value.
static void	pl_VectorSubI_NNN (PlankI result, const PlankI a, const PlankI *b, PlankUL N)
	Applies the binary operator function pl_SubI() to each item in two input vectors.
static void	pl_VectorSubI_NN1 (PlankI result, const PlankI a, PlankI b, PlankUL N)
	Applies the binary operator function pl_SubI() to an input vector and a scalar value.
static void	pl_VectorSubI_N1N (PlankI result, PlankI a, const PlankI b, PlankUL N)
	Applies the binary operator function pl_SubI() to an input vector and a scalar value.
static void	pl_VectorMulI_NNN (PlankI result, const PlankI a, const PlankI *b, PlankUL N)
	Applies the binary operator function pl_MulI() to each item in two input vectors.
static void	pl_VectorMulI_NN1 (PlankI result, const PlankI a, PlankI b, PlankUL N)
	Applies the binary operator function pl_MulI() to an input vector and a scalar value.
static void	pl_VectorMulI_N1N (PlankI result, PlankI a, const PlankI b, PlankUL N)
	Applies the binary operator function pl_MulI() to an input vector and a scalar value.
static void	pl_VectorDivI_NNN (PlankI result, const PlankI a, const PlankI *b, PlankUL N)
	Applies the binary operator function pl_DivI() to each item in two input vectors.
static void	pl_VectorDivI_NN1 (PlankI result, const PlankI a, PlankI b, PlankUL N)
	Applies the binary operator function pl_DivI() to an input vector and a scalar value.
static void	pl_VectorDivI_N1N (PlankI result, PlankI a, const PlankI b, PlankUL N)
	Applies the binary operator function pl_DivI() to an input vector and a scalar value.
static void	pl_VectorModI_NNN (PlankI result, const PlankI a, const PlankI *b, PlankUL N)
	Applies the binary operator function pl_ModI() to each item in two input vectors.
static void	pl_VectorModI_NN1 (PlankI result, const PlankI a, PlankI b, PlankUL N)
	Applies the binary operator function pl_ModI() to an input vector and a scalar value.
static void	pl_VectorModI_N1N (PlankI result, PlankI a, const PlankI b, PlankUL N)
	Applies the binary operator function pl_ModI() to an input vector and a scalar value.
static void	pl_VectorMinI_NNN (PlankI result, const PlankI a, const PlankI *b, PlankUL N)
	Applies the binary operator function pl_MinI() to each item in two input vectors.
static void	pl_VectorMinI_NN1 (PlankI result, const PlankI a, PlankI b, PlankUL N)
	Applies the binary operator function pl_MinI() to an input vector and a scalar value.
static void	pl_VectorMinI_N1N (PlankI result, PlankI a, const PlankI b, PlankUL N)
	Applies the binary operator function pl_MinI() to an input vector and a scalar value.
static void	pl_VectorMaxI_NNN (PlankI result, const PlankI a, const PlankI *b, PlankUL N)
	Applies the binary operator function pl_MaxI() to each item in two input vectors.
static void	pl_VectorMaxI_NN1 (PlankI result, const PlankI a, PlankI b, PlankUL N)
	Applies the binary operator function pl_MaxI() to an input vector and a scalar value.
static void	pl_VectorMaxI_N1N (PlankI result, PlankI a, const PlankI b, PlankUL N)
	Applies the binary operator function pl_MaxI() to an input vector and a scalar value.
static void	pl_VectorIsEqualToI_NNN (PlankI result, const PlankI a, const PlankI *b, PlankUL N)
	Applies the binary operator function pl_IsEqualToI() to each item in two input vectors.
static void	pl_VectorIsEqualToI_NN1 (PlankI result, const PlankI a, PlankI b, PlankUL N)
	Applies the binary operator function pl_IsEqualToI() to an input vector and a scalar value.
static void	pl_VectorIsEqualToI_N1N (PlankI result, PlankI a, const PlankI b, PlankUL N)
	Applies the binary operator function pl_IsEqualToI() to an input vector and a scalar value.
static void	pl_VectorIsNotEqualToI_NNN (PlankI result, const PlankI a, const PlankI *b, PlankUL N)
	Applies the binary operator function pl_IsNotEqualToI() to each item in two input vectors.
static void	pl_VectorIsNotEqualToI_NN1 (PlankI result, const PlankI a, PlankI b, PlankUL N)
	Applies the binary operator function pl_IsNotEqualToI() to an input vector and a scalar value.
static void	pl_VectorIsNotEqualToI_N1N (PlankI result, PlankI a, const PlankI b, PlankUL N)
	Applies the binary operator function pl_IsNotEqualToI() to an input vector and a scalar value.
static void	pl_VectorIsGreaterThanI_NNN (PlankI result, const PlankI a, const PlankI *b, PlankUL N)
	Applies the binary operator function pl_IsGreaterThanI() to each item in two input vectors.
static void	pl_VectorIsGreaterThanI_NN1 (PlankI result, const PlankI a, PlankI b, PlankUL N)
	Applies the binary operator function pl_IsGreaterThanI() to an input vector and a scalar value.
static void	pl_VectorIsGreaterThanI_N1N (PlankI result, PlankI a, const PlankI b, PlankUL N)
	Applies the binary operator function pl_IsGreaterThanI() to an input vector and a scalar value.
static void	pl_VectorIsGreaterThanOrEqualToI_NNN (PlankI result, const PlankI a, const PlankI *b, PlankUL N)
	Applies the binary operator function pl_IsGreaterThanOrEqualToI() to each item in two input vectors.
static void	pl_VectorIsGreaterThanOrEqualToI_NN1 (PlankI result, const PlankI a, PlankI b, PlankUL N)
	Applies the binary operator function pl_IsGreaterThanOrEqualToI() to an input vector and a scalar value.
static void	pl_VectorIsGreaterThanOrEqualToI_N1N (PlankI result, PlankI a, const PlankI b, PlankUL N)
	Applies the binary operator function pl_IsGreaterThanOrEqualToI() to an input vector and a scalar value.
static void	pl_VectorIsLessThanI_NNN (PlankI result, const PlankI a, const PlankI *b, PlankUL N)
	Applies the binary operator function pl_IsLessThanI() to each item in two input vectors.
static void	pl_VectorIsLessThanI_NN1 (PlankI result, const PlankI a, PlankI b, PlankUL N)
	Applies the binary operator function pl_IsLessThanI() to an input vector and a scalar value.
static void	pl_VectorIsLessThanI_N1N (PlankI result, PlankI a, const PlankI b, PlankUL N)
	Applies the binary operator function pl_IsLessThanI() to an input vector and a scalar value.
static void	pl_VectorIsLessThanOrEqualToI_NNN (PlankI result, const PlankI a, const PlankI *b, PlankUL N)
	Applies the binary operator function pl_IsLessThanOrEqualToI() to each item in two input vectors.
static void	pl_VectorIsLessThanOrEqualToI_NN1 (PlankI result, const PlankI a, PlankI b, PlankUL N)
	Applies the binary operator function pl_IsLessThanOrEqualToI() to an input vector and a scalar value.
static void	pl_VectorIsLessThanOrEqualToI_N1N (PlankI result, PlankI a, const PlankI b, PlankUL N)
	Applies the binary operator function pl_IsLessThanOrEqualToI() to an input vector and a scalar value.
static void	pl_VectorSumSqrI_NNN (PlankI result, const PlankI a, const PlankI *b, PlankUL N)
	Applies the binary operator function pl_SumSqrI() to each item in two input vectors.
static void	pl_VectorSumSqrI_NN1 (PlankI result, const PlankI a, PlankI b, PlankUL N)
	Applies the binary operator function pl_SumSqrI() to an input vector and a scalar value.
static void	pl_VectorSumSqrI_N1N (PlankI result, PlankI a, const PlankI b, PlankUL N)
	Applies the binary operator function pl_SumSqrI() to an input vector and a scalar value.
static void	pl_VectorDifSqrI_NNN (PlankI result, const PlankI a, const PlankI *b, PlankUL N)
	Applies the binary operator function pl_DifSqrI() to each item in two input vectors.
static void	pl_VectorDifSqrI_NN1 (PlankI result, const PlankI a, PlankI b, PlankUL N)
	Applies the binary operator function pl_DifSqrI() to an input vector and a scalar value.
static void	pl_VectorDifSqrI_N1N (PlankI result, PlankI a, const PlankI b, PlankUL N)
	Applies the binary operator function pl_DifSqrI() to an input vector and a scalar value.
static void	pl_VectorSqrSumI_NNN (PlankI result, const PlankI a, const PlankI *b, PlankUL N)
	Applies the binary operator function pl_SqrSumI() to each item in two input vectors.
static void	pl_VectorSqrSumI_NN1 (PlankI result, const PlankI a, PlankI b, PlankUL N)
	Applies the binary operator function pl_SqrSumI() to an input vector and a scalar value.
static void	pl_VectorSqrSumI_N1N (PlankI result, PlankI a, const PlankI b, PlankUL N)
	Applies the binary operator function pl_SqrSumI() to an input vector and a scalar value.
static void	pl_VectorSqrDifI_NNN (PlankI result, const PlankI a, const PlankI *b, PlankUL N)
	Applies the binary operator function pl_SqrDifI() to each item in two input vectors.
static void	pl_VectorSqrDifI_NN1 (PlankI result, const PlankI a, PlankI b, PlankUL N)
	Applies the binary operator function pl_SqrDifI() to an input vector and a scalar value.
static void	pl_VectorSqrDifI_N1N (PlankI result, PlankI a, const PlankI b, PlankUL N)
	Applies the binary operator function pl_SqrDifI() to an input vector and a scalar value.
static void	pl_VectorAbsDifI_NNN (PlankI result, const PlankI a, const PlankI *b, PlankUL N)
	Applies the binary operator function pl_AbsDifI() to each item in two input vectors.
static void	pl_VectorAbsDifI_NN1 (PlankI result, const PlankI a, PlankI b, PlankUL N)
	Applies the binary operator function pl_AbsDifI() to an input vector and a scalar value.
static void	pl_VectorAbsDifI_N1N (PlankI result, PlankI a, const PlankI b, PlankUL N)
	Applies the binary operator function pl_AbsDifI() to an input vector and a scalar value.
static void	pl_VectorThreshI_NNN (PlankI result, const PlankI a, const PlankI *b, PlankUL N)
	Applies the binary operator function pl_ThreshI() to each item in two input vectors.
static void	pl_VectorThreshI_NN1 (PlankI result, const PlankI a, PlankI b, PlankUL N)
	Applies the binary operator function pl_ThreshI() to an input vector and a scalar value.
static void	pl_VectorThreshI_N1N (PlankI result, PlankI a, const PlankI b, PlankUL N)
	Applies the binary operator function pl_ThreshI() to an input vector and a scalar value.
static void	pl_VectorMulAddI_NNNN (PlankI result, const PlankI input, const PlankI mul, const PlankI add, PlankUL N)
	Applies the multiply and add operator to a set of vectors.
static void	pl_VectorMulAddI_NNN (PlankI io, const PlankI mul, const PlankI *add, PlankUL N)
	Applies the multiply and add operator to a set of vectors.
static void	pl_VectorMulAddI_NNN1 (PlankI result, const PlankI input, const PlankI *mul, PlankI add, PlankUL N)
	Applies the multiply and add operator to a set of vectors.
static void	pl_VectorMulAddI_NN11 (PlankI result, const PlankI input, PlankI mul, PlankI add, PlankUL N)
	Applies the multiply and add operator to a set of vectors.
static void	pl_VectorMulAddI_NN1N (PlankI result, const PlankI input, PlankI mul, const PlankI *add, PlankUL N)
	Applies the multiply and add operator to a set of vectors.
static void	pl_VectorLookupI_NnN (PlankI result, PlankI table, PlankUL n, PlankI *index, PlankUL N)
	Generate a vector by using another vector as the indices into a lookup table.
static void	pl_VectorFillLL_N1 (PlankLL *result, PlankLL value, PlankUL N)
	Fills a vector with a constant.
static void	pl_VectorClearLL_N (PlankLL *result, PlankUL N)
	Fills a vector with zeros.
static void	pl_VectorRampLL_N11 (PlankLL *result, PlankLL a, PlankLL b, PlankUL N)
	Fills a vector with a ramp.
static void	pl_VectorLineLL_N11 (PlankLL *result, PlankLL a, PlankLL b, PlankUL N)
	Fills a vector with a line.
static void	pl_VectorMoveLL_NN (PlankLL result, const PlankLL a, PlankUL N)
	Applies the function pl_MoveLL() to each item in a vector.
static void	pl_VectorIncLL_NN (PlankLL result, const PlankLL a, PlankUL N)
	Applies the function pl_IncLL() to each item in a vector.
static void	pl_VectorDecLL_NN (PlankLL result, const PlankLL a, PlankUL N)
	Applies the function pl_DecLL() to each item in a vector.
static void	pl_VectorNegLL_NN (PlankLL result, const PlankLL a, PlankUL N)
	Applies the function pl_NegLL() to each item in a vector.
static void	pl_VectorAbsLL_NN (PlankLL result, const PlankLL a, PlankUL N)
	Applies the function pl_AbsLL() to each item in a vector.
static void	pl_VectorSquaredLL_NN (PlankLL result, const PlankLL a, PlankUL N)
	Applies the function pl_SquaredLL() to each item in a vector.
static void	pl_VectorCubedLL_NN (PlankLL result, const PlankLL a, PlankUL N)
	Applies the function pl_CubedLL() to each item in a vector.
static void	pl_VectorSignLL_NN (PlankLL result, const PlankLL a, PlankUL N)
	Applies the function pl_SignLL() to each item in a vector.
static void	pl_VectorAddLL_NNN (PlankLL result, const PlankLL a, const PlankLL *b, PlankUL N)
	Applies the binary operator function pl_AddLL() to each item in two input vectors.
static void	pl_VectorAddLL_NN1 (PlankLL result, const PlankLL a, PlankLL b, PlankUL N)
	Applies the binary operator function pl_AddLL() to an input vector and a scalar value.
static void	pl_VectorAddLL_N1N (PlankLL result, PlankLL a, const PlankLL b, PlankUL N)
	Applies the binary operator function pl_AddLL() to an input vector and a scalar value.
static void	pl_VectorSubLL_NNN (PlankLL result, const PlankLL a, const PlankLL *b, PlankUL N)
	Applies the binary operator function pl_SubLL() to each item in two input vectors.
static void	pl_VectorSubLL_NN1 (PlankLL result, const PlankLL a, PlankLL b, PlankUL N)
	Applies the binary operator function pl_SubLL() to an input vector and a scalar value.
static void	pl_VectorSubLL_N1N (PlankLL result, PlankLL a, const PlankLL b, PlankUL N)
	Applies the binary operator function pl_SubLL() to an input vector and a scalar value.
static void	pl_VectorMulLL_NNN (PlankLL result, const PlankLL a, const PlankLL *b, PlankUL N)
	Applies the binary operator function pl_MulLL() to each item in two input vectors.
static void	pl_VectorMulLL_NN1 (PlankLL result, const PlankLL a, PlankLL b, PlankUL N)
	Applies the binary operator function pl_MulLL() to an input vector and a scalar value.
static void	pl_VectorMulLL_N1N (PlankLL result, PlankLL a, const PlankLL b, PlankUL N)
	Applies the binary operator function pl_MulLL() to an input vector and a scalar value.
static void	pl_VectorDivLL_NNN (PlankLL result, const PlankLL a, const PlankLL *b, PlankUL N)
	Applies the binary operator function pl_DivLL() to each item in two input vectors.
static void	pl_VectorDivLL_NN1 (PlankLL result, const PlankLL a, PlankLL b, PlankUL N)
	Applies the binary operator function pl_DivLL() to an input vector and a scalar value.
static void	pl_VectorDivLL_N1N (PlankLL result, PlankLL a, const PlankLL b, PlankUL N)
	Applies the binary operator function pl_DivLL() to an input vector and a scalar value.
static void	pl_VectorModLL_NNN (PlankLL result, const PlankLL a, const PlankLL *b, PlankUL N)
	Applies the binary operator function pl_ModLL() to each item in two input vectors.
static void	pl_VectorModLL_NN1 (PlankLL result, const PlankLL a, PlankLL b, PlankUL N)
	Applies the binary operator function pl_ModLL() to an input vector and a scalar value.
static void	pl_VectorModLL_N1N (PlankLL result, PlankLL a, const PlankLL b, PlankUL N)
	Applies the binary operator function pl_ModLL() to an input vector and a scalar value.
static void	pl_VectorMinLL_NNN (PlankLL result, const PlankLL a, const PlankLL *b, PlankUL N)
	Applies the binary operator function pl_MinLL() to each item in two input vectors.
static void	pl_VectorMinLL_NN1 (PlankLL result, const PlankLL a, PlankLL b, PlankUL N)
	Applies the binary operator function pl_MinLL() to an input vector and a scalar value.
static void	pl_VectorMinLL_N1N (PlankLL result, PlankLL a, const PlankLL b, PlankUL N)
	Applies the binary operator function pl_MinLL() to an input vector and a scalar value.
static void	pl_VectorMaxLL_NNN (PlankLL result, const PlankLL a, const PlankLL *b, PlankUL N)
	Applies the binary operator function pl_MaxLL() to each item in two input vectors.
static void	pl_VectorMaxLL_NN1 (PlankLL result, const PlankLL a, PlankLL b, PlankUL N)
	Applies the binary operator function pl_MaxLL() to an input vector and a scalar value.
static void	pl_VectorMaxLL_N1N (PlankLL result, PlankLL a, const PlankLL b, PlankUL N)
	Applies the binary operator function pl_MaxLL() to an input vector and a scalar value.
static void	pl_VectorIsEqualToLL_NNN (PlankLL result, const PlankLL a, const PlankLL *b, PlankUL N)
	Applies the binary operator function pl_IsEqualToLL() to each item in two input vectors.
static void	pl_VectorIsEqualToLL_NN1 (PlankLL result, const PlankLL a, PlankLL b, PlankUL N)
	Applies the binary operator function pl_IsEqualToLL() to an input vector and a scalar value.
static void	pl_VectorIsEqualToLL_N1N (PlankLL result, PlankLL a, const PlankLL b, PlankUL N)
	Applies the binary operator function pl_IsEqualToLL() to an input vector and a scalar value.
static void	pl_VectorIsNotEqualToLL_NNN (PlankLL result, const PlankLL a, const PlankLL *b, PlankUL N)
	Applies the binary operator function pl_IsNotEqualToLL() to each item in two input vectors.
static void	pl_VectorIsNotEqualToLL_NN1 (PlankLL result, const PlankLL a, PlankLL b, PlankUL N)
	Applies the binary operator function pl_IsNotEqualToLL() to an input vector and a scalar value.
static void	pl_VectorIsNotEqualToLL_N1N (PlankLL result, PlankLL a, const PlankLL b, PlankUL N)
	Applies the binary operator function pl_IsNotEqualToLL() to an input vector and a scalar value.
static void	pl_VectorIsGreaterThanLL_NNN (PlankLL result, const PlankLL a, const PlankLL *b, PlankUL N)
	Applies the binary operator function pl_IsGreaterThanLL() to each item in two input vectors.
static void	pl_VectorIsGreaterThanLL_NN1 (PlankLL result, const PlankLL a, PlankLL b, PlankUL N)
	Applies the binary operator function pl_IsGreaterThanLL() to an input vector and a scalar value.
static void	pl_VectorIsGreaterThanLL_N1N (PlankLL result, PlankLL a, const PlankLL b, PlankUL N)
	Applies the binary operator function pl_IsGreaterThanLL() to an input vector and a scalar value.
static void	pl_VectorIsGreaterThanOrEqualToLL_NNN (PlankLL result, const PlankLL a, const PlankLL *b, PlankUL N)
	Applies the binary operator function pl_IsGreaterThanOrEqualToLL() to each item in two input vectors.
static void	pl_VectorIsGreaterThanOrEqualToLL_NN1 (PlankLL result, const PlankLL a, PlankLL b, PlankUL N)
	Applies the binary operator function pl_IsGreaterThanOrEqualToLL() to an input vector and a scalar value.
static void	pl_VectorIsGreaterThanOrEqualToLL_N1N (PlankLL result, PlankLL a, const PlankLL b, PlankUL N)
	Applies the binary operator function pl_IsGreaterThanOrEqualToLL() to an input vector and a scalar value.
static void	pl_VectorIsLessThanLL_NNN (PlankLL result, const PlankLL a, const PlankLL *b, PlankUL N)
	Applies the binary operator function pl_IsLessThanLL() to each item in two input vectors.
static void	pl_VectorIsLessThanLL_NN1 (PlankLL result, const PlankLL a, PlankLL b, PlankUL N)
	Applies the binary operator function pl_IsLessThanLL() to an input vector and a scalar value.
static void	pl_VectorIsLessThanLL_N1N (PlankLL result, PlankLL a, const PlankLL b, PlankUL N)
	Applies the binary operator function pl_IsLessThanLL() to an input vector and a scalar value.
static void	pl_VectorIsLessThanOrEqualToLL_NNN (PlankLL result, const PlankLL a, const PlankLL *b, PlankUL N)
	Applies the binary operator function pl_IsLessThanOrEqualToLL() to each item in two input vectors.
static void	pl_VectorIsLessThanOrEqualToLL_NN1 (PlankLL result, const PlankLL a, PlankLL b, PlankUL N)
	Applies the binary operator function pl_IsLessThanOrEqualToLL() to an input vector and a scalar value.
static void	pl_VectorIsLessThanOrEqualToLL_N1N (PlankLL result, PlankLL a, const PlankLL b, PlankUL N)
	Applies the binary operator function pl_IsLessThanOrEqualToLL() to an input vector and a scalar value.
static void	pl_VectorSumSqrLL_NNN (PlankLL result, const PlankLL a, const PlankLL *b, PlankUL N)
	Applies the binary operator function pl_SumSqrLL() to each item in two input vectors.
static void	pl_VectorSumSqrLL_NN1 (PlankLL result, const PlankLL a, PlankLL b, PlankUL N)
	Applies the binary operator function pl_SumSqrLL() to an input vector and a scalar value.
static void	pl_VectorSumSqrLL_N1N (PlankLL result, PlankLL a, const PlankLL b, PlankUL N)
	Applies the binary operator function pl_SumSqrLL() to an input vector and a scalar value.
static void	pl_VectorDifSqrLL_NNN (PlankLL result, const PlankLL a, const PlankLL *b, PlankUL N)
	Applies the binary operator function pl_DifSqrLL() to each item in two input vectors.
static void	pl_VectorDifSqrLL_NN1 (PlankLL result, const PlankLL a, PlankLL b, PlankUL N)
	Applies the binary operator function pl_DifSqrLL() to an input vector and a scalar value.
static void	pl_VectorDifSqrLL_N1N (PlankLL result, PlankLL a, const PlankLL b, PlankUL N)
	Applies the binary operator function pl_DifSqrLL() to an input vector and a scalar value.
static void	pl_VectorSqrSumLL_NNN (PlankLL result, const PlankLL a, const PlankLL *b, PlankUL N)
	Applies the binary operator function pl_SqrSumLL() to each item in two input vectors.
static void	pl_VectorSqrSumLL_NN1 (PlankLL result, const PlankLL a, PlankLL b, PlankUL N)
	Applies the binary operator function pl_SqrSumLL() to an input vector and a scalar value.
static void	pl_VectorSqrSumLL_N1N (PlankLL result, PlankLL a, const PlankLL b, PlankUL N)
	Applies the binary operator function pl_SqrSumLL() to an input vector and a scalar value.
static void	pl_VectorSqrDifLL_NNN (PlankLL result, const PlankLL a, const PlankLL *b, PlankUL N)
	Applies the binary operator function pl_SqrDifLL() to each item in two input vectors.
static void	pl_VectorSqrDifLL_NN1 (PlankLL result, const PlankLL a, PlankLL b, PlankUL N)
	Applies the binary operator function pl_SqrDifLL() to an input vector and a scalar value.
static void	pl_VectorSqrDifLL_N1N (PlankLL result, PlankLL a, const PlankLL b, PlankUL N)
	Applies the binary operator function pl_SqrDifLL() to an input vector and a scalar value.
static void	pl_VectorAbsDifLL_NNN (PlankLL result, const PlankLL a, const PlankLL *b, PlankUL N)
	Applies the binary operator function pl_AbsDifLL() to each item in two input vectors.
static void	pl_VectorAbsDifLL_NN1 (PlankLL result, const PlankLL a, PlankLL b, PlankUL N)
	Applies the binary operator function pl_AbsDifLL() to an input vector and a scalar value.
static void	pl_VectorAbsDifLL_N1N (PlankLL result, PlankLL a, const PlankLL b, PlankUL N)
	Applies the binary operator function pl_AbsDifLL() to an input vector and a scalar value.
static void	pl_VectorThreshLL_NNN (PlankLL result, const PlankLL a, const PlankLL *b, PlankUL N)
	Applies the binary operator function pl_ThreshLL() to each item in two input vectors.
static void	pl_VectorThreshLL_NN1 (PlankLL result, const PlankLL a, PlankLL b, PlankUL N)
	Applies the binary operator function pl_ThreshLL() to an input vector and a scalar value.
static void	pl_VectorThreshLL_N1N (PlankLL result, PlankLL a, const PlankLL b, PlankUL N)
	Applies the binary operator function pl_ThreshLL() to an input vector and a scalar value.
static void	pl_VectorMulAddLL_NNNN (PlankLL result, const PlankLL input, const PlankLL mul, const PlankLL add, PlankUL N)
	Applies the multiply and add operator to a set of vectors.
static void	pl_VectorMulAddLL_NNN (PlankLL io, const PlankLL mul, const PlankLL *add, PlankUL N)
	Applies the multiply and add operator to a set of vectors.
static void	pl_VectorMulAddLL_NNN1 (PlankLL result, const PlankLL input, const PlankLL *mul, PlankLL add, PlankUL N)
	Applies the multiply and add operator to a set of vectors.
static void	pl_VectorMulAddLL_NN11 (PlankLL result, const PlankLL input, PlankLL mul, PlankLL add, PlankUL N)
	Applies the multiply and add operator to a set of vectors.
static void	pl_VectorMulAddLL_NN1N (PlankLL result, const PlankLL input, PlankLL mul, const PlankLL *add, PlankUL N)
	Applies the multiply and add operator to a set of vectors.
static void	pl_VectorLookupLL_NnN (PlankLL result, PlankLL table, PlankUL n, PlankLL *index, PlankUL N)
	Generate a vector by using another vector as the indices into a lookup table.

Detailed Description

Vector processing functions.

These process vectors (arrays) of data applying common maths functions to the inputs. The default is to use the scalar processing functions (implmented with a loop in C) but many of these operations can be performed with faster, optimised libraries on some platforms (e.g., vDSP on Mac OS X and iOS).

The naming convention is to prefix all functions with 'pl_Vector'. This is followed by the name of the operation which is commonly the name of an equivalent scalar function. Finally the name is suffixed with a code to identify the type of vectors and/or scalar values passed to the function. The code starts with the number of items in the output vector and is followed by codes for the sizes of the other input vectors. For example, all the unary operators are suffixed '_NN' so show the input and output vectors are the same size 'N' (which is the N argument passed the the function). Some binary operators are suffixed '_NNN', '_NN1' or '_N1N'. The first is where there are two input vectors and the output vector that are all the same size. '_NN1' has an input vector with the same size as the output and a scalar value '1' (i.e., a scalar) as the other operand.

Function Documentation

static void pl_VectorA2dBD_NN	(	PlankD *	result,
		const PlankD *	a,
		PlankUL	N
	)		`[inline, static]`

Applies the function pl_A2dBD() to each item in a vector.

This processes vector a applying the function pl_A2dBD() to each item and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	The input vector.
N	The number of items in the input/output vectors.

static void pl_VectorA2dBF_NN	(	PlankF *	result,
		const PlankF *	a,
		PlankUL	N
	)		`[inline, static]`

Applies the function pl_A2dBF() to each item in a vector.

This processes vector a applying the function pl_A2dBF() to each item and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	The input vector.
N	The number of items in the input/output vectors.

static void pl_VectorAbsD_NN	(	PlankD *	result,
		const PlankD *	a,
		PlankUL	N
	)		`[inline, static]`

Applies the function pl_AbsD() to each item in a vector.

This processes vector a applying the function pl_AbsD() to each item and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	The input vector.
N	The number of items in the input/output vectors.

static void pl_VectorAbsDifD_N1N	(	PlankD *	result,
		PlankD	a,
		const PlankD *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_AbsDifD() to an input vector and a scalar value.

This processes vector b and applies the function pl_AbsDifD() to each item and the scalar value a and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	A scalar value and the left operand of the operation.
b	Input vector b and the source of the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorAbsDifD_NN1	(	PlankD *	result,
		const PlankD *	a,
		PlankD	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_AbsDifD() to an input vector and a scalar value.

This processes vector a and applies the function pl_AbsDifD() to each item and the scalar value b and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a and the source of the left operand of the operation.
b	A scalar value and the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorAbsDifD_NNN	(	PlankD *	result,
		const PlankD *	a,
		const PlankD *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_AbsDifD() to each item in two input vectors.

This processes vectors a and b applying the function pl_AbsDifD() to each of their items in turn and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a.
b	Input vector b.
N	The number of items in the input/output vectors.

static void pl_VectorAbsDifF_N1N	(	PlankF *	result,
		PlankF	a,
		const PlankF *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_AbsDifF() to an input vector and a scalar value.

This processes vector b and applies the function pl_AbsDifF() to each item and the scalar value a and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	A scalar value and the left operand of the operation.
b	Input vector b and the source of the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorAbsDifF_NN1	(	PlankF *	result,
		const PlankF *	a,
		PlankF	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_AbsDifF() to an input vector and a scalar value.

This processes vector a and applies the function pl_AbsDifF() to each item and the scalar value b and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a and the source of the left operand of the operation.
b	A scalar value and the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorAbsDifF_NNN	(	PlankF *	result,
		const PlankF *	a,
		const PlankF *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_AbsDifF() to each item in two input vectors.

This processes vectors a and b applying the function pl_AbsDifF() to each of their items in turn and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a.
b	Input vector b.
N	The number of items in the input/output vectors.

static void pl_VectorAbsDifI_N1N	(	PlankI *	result,
		PlankI	a,
		const PlankI *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_AbsDifI() to an input vector and a scalar value.

This processes vector b and applies the function pl_AbsDifI() to each item and the scalar value a and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	A scalar value and the left operand of the operation.
b	Input vector b and the source of the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorAbsDifI_NN1	(	PlankI *	result,
		const PlankI *	a,
		PlankI	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_AbsDifI() to an input vector and a scalar value.

This processes vector a and applies the function pl_AbsDifI() to each item and the scalar value b and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a and the source of the left operand of the operation.
b	A scalar value and the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorAbsDifI_NNN	(	PlankI *	result,
		const PlankI *	a,
		const PlankI *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_AbsDifI() to each item in two input vectors.

This processes vectors a and b applying the function pl_AbsDifI() to each of their items in turn and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a.
b	Input vector b.
N	The number of items in the input/output vectors.

static void pl_VectorAbsDifLL_N1N	(	PlankLL *	result,
		PlankLL	a,
		const PlankLL *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_AbsDifLL() to an input vector and a scalar value.

This processes vector b and applies the function pl_AbsDifLL() to each item and the scalar value a and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	A scalar value and the left operand of the operation.
b	Input vector b and the source of the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorAbsDifLL_NN1	(	PlankLL *	result,
		const PlankLL *	a,
		PlankLL	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_AbsDifLL() to an input vector and a scalar value.

This processes vector a and applies the function pl_AbsDifLL() to each item and the scalar value b and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a and the source of the left operand of the operation.
b	A scalar value and the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorAbsDifLL_NNN	(	PlankLL *	result,
		const PlankLL *	a,
		const PlankLL *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_AbsDifLL() to each item in two input vectors.

This processes vectors a and b applying the function pl_AbsDifLL() to each of their items in turn and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a.
b	Input vector b.
N	The number of items in the input/output vectors.

static void pl_VectorAbsDifS_N1N	(	PlankS *	result,
		PlankS	a,
		const PlankS *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_AbsDifS() to an input vector and a scalar value.

This processes vector b and applies the function pl_AbsDifS() to each item and the scalar value a and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	A scalar value and the left operand of the operation.
b	Input vector b and the source of the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorAbsDifS_NN1	(	PlankS *	result,
		const PlankS *	a,
		PlankS	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_AbsDifS() to an input vector and a scalar value.

This processes vector a and applies the function pl_AbsDifS() to each item and the scalar value b and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a and the source of the left operand of the operation.
b	A scalar value and the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorAbsDifS_NNN	(	PlankS *	result,
		const PlankS *	a,
		const PlankS *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_AbsDifS() to each item in two input vectors.

This processes vectors a and b applying the function pl_AbsDifS() to each of their items in turn and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a.
b	Input vector b.
N	The number of items in the input/output vectors.

static void pl_VectorAbsF_NN	(	PlankF *	result,
		const PlankF *	a,
		PlankUL	N
	)		`[inline, static]`

Applies the function pl_AbsF() to each item in a vector.

This processes vector a applying the function pl_AbsF() to each item and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	The input vector.
N	The number of items in the input/output vectors.

static void pl_VectorAbsI_NN	(	PlankI *	result,
		const PlankI *	a,
		PlankUL	N
	)		`[inline, static]`

Applies the function pl_AbsI() to each item in a vector.

This processes vector a applying the function pl_AbsI() to each item and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	The input vector.
N	The number of items in the input/output vectors.

static void pl_VectorAbsLL_NN	(	PlankLL *	result,
		const PlankLL *	a,
		PlankUL	N
	)		`[inline, static]`

Applies the function pl_AbsLL() to each item in a vector.

This processes vector a applying the function pl_AbsLL() to each item and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	The input vector.
N	The number of items in the input/output vectors.

static void pl_VectorAbsS_NN	(	PlankS *	result,
		const PlankS *	a,
		PlankUL	N
	)		`[inline, static]`

Applies the function pl_AbsS() to each item in a vector.

This processes vector a applying the function pl_AbsS() to each item and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	The input vector.
N	The number of items in the input/output vectors.

static void pl_VectorAcosD_NN	(	PlankD *	result,
		const PlankD *	a,
		PlankUL	N
	)		`[inline, static]`

Applies the function pl_AcosD() to each item in a vector.

This processes vector a applying the function pl_AcosD() to each item and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	The input vector.
N	The number of items in the input/output vectors.

static void pl_VectorAcosF_NN	(	PlankF *	result,
		const PlankF *	a,
		PlankUL	N
	)		`[inline, static]`

Applies the function pl_AcosF() to each item in a vector.

This processes vector a applying the function pl_AcosF() to each item and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	The input vector.
N	The number of items in the input/output vectors.

static void pl_VectorAddD_N1N	(	PlankD *	result,
		PlankD	a,
		const PlankD *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_AddD() to an input vector and a scalar value.

This processes vector b and applies the function pl_AddD() to each item and the scalar value a and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	A scalar value and the left operand of the operation.
b	Input vector b and the source of the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorAddD_NN1	(	PlankD *	result,
		const PlankD *	a,
		PlankD	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_AddD() to an input vector and a scalar value.

This processes vector a and applies the function pl_AddD() to each item and the scalar value b and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a and the source of the left operand of the operation.
b	A scalar value and the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorAddD_NNN	(	PlankD *	result,
		const PlankD *	a,
		const PlankD *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_AddD() to each item in two input vectors.

This processes vectors a and b applying the function pl_AddD() to each of their items in turn and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a.
b	Input vector b.
N	The number of items in the input/output vectors.

static void pl_VectorAddF_N1N	(	PlankF *	result,
		PlankF	a,
		const PlankF *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_AddF() to an input vector and a scalar value.

This processes vector b and applies the function pl_AddF() to each item and the scalar value a and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	A scalar value and the left operand of the operation.
b	Input vector b and the source of the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorAddF_NN1	(	PlankF *	result,
		const PlankF *	a,
		PlankF	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_AddF() to an input vector and a scalar value.

This processes vector a and applies the function pl_AddF() to each item and the scalar value b and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a and the source of the left operand of the operation.
b	A scalar value and the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorAddF_NNN	(	PlankF *	result,
		const PlankF *	a,
		const PlankF *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_AddF() to each item in two input vectors.

This processes vectors a and b applying the function pl_AddF() to each of their items in turn and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a.
b	Input vector b.
N	The number of items in the input/output vectors.

static void pl_VectorAddI_N1N	(	PlankI *	result,
		PlankI	a,
		const PlankI *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_AddI() to an input vector and a scalar value.

This processes vector b and applies the function pl_AddI() to each item and the scalar value a and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	A scalar value and the left operand of the operation.
b	Input vector b and the source of the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorAddI_NN1	(	PlankI *	result,
		const PlankI *	a,
		PlankI	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_AddI() to an input vector and a scalar value.

This processes vector a and applies the function pl_AddI() to each item and the scalar value b and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a and the source of the left operand of the operation.
b	A scalar value and the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorAddI_NNN	(	PlankI *	result,
		const PlankI *	a,
		const PlankI *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_AddI() to each item in two input vectors.

This processes vectors a and b applying the function pl_AddI() to each of their items in turn and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a.
b	Input vector b.
N	The number of items in the input/output vectors.

static void pl_VectorAddLL_N1N	(	PlankLL *	result,
		PlankLL	a,
		const PlankLL *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_AddLL() to an input vector and a scalar value.

This processes vector b and applies the function pl_AddLL() to each item and the scalar value a and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	A scalar value and the left operand of the operation.
b	Input vector b and the source of the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorAddLL_NN1	(	PlankLL *	result,
		const PlankLL *	a,
		PlankLL	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_AddLL() to an input vector and a scalar value.

This processes vector a and applies the function pl_AddLL() to each item and the scalar value b and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a and the source of the left operand of the operation.
b	A scalar value and the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorAddLL_NNN	(	PlankLL *	result,
		const PlankLL *	a,
		const PlankLL *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_AddLL() to each item in two input vectors.

This processes vectors a and b applying the function pl_AddLL() to each of their items in turn and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a.
b	Input vector b.
N	The number of items in the input/output vectors.

static void pl_VectorAddS_N1N	(	PlankS *	result,
		PlankS	a,
		const PlankS *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_AddS() to an input vector and a scalar value.

This processes vector b and applies the function pl_AddS() to each item and the scalar value a and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	A scalar value and the left operand of the operation.
b	Input vector b and the source of the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorAddS_NN1	(	PlankS *	result,
		const PlankS *	a,
		PlankS	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_AddS() to an input vector and a scalar value.

This processes vector a and applies the function pl_AddS() to each item and the scalar value b and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a and the source of the left operand of the operation.
b	A scalar value and the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorAddS_NNN	(	PlankS *	result,
		const PlankS *	a,
		const PlankS *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_AddS() to each item in two input vectors.

This processes vectors a and b applying the function pl_AddS() to each of their items in turn and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a.
b	Input vector b.
N	The number of items in the input/output vectors.

static void pl_VectorAsinD_NN	(	PlankD *	result,
		const PlankD *	a,
		PlankUL	N
	)		`[inline, static]`

Applies the function pl_AsinD() to each item in a vector.

This processes vector a applying the function pl_AsinD() to each item and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	The input vector.
N	The number of items in the input/output vectors.

static void pl_VectorAsinF_NN	(	PlankF *	result,
		const PlankF *	a,
		PlankUL	N
	)		`[inline, static]`

Applies the function pl_AsinF() to each item in a vector.

This processes vector a applying the function pl_AsinF() to each item and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	The input vector.
N	The number of items in the input/output vectors.

static void pl_VectorAtan2D_N1N	(	PlankD *	result,
		PlankD	a,
		const PlankD *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_Atan2D() to an input vector and a scalar value.

This processes vector b and applies the function pl_Atan2D() to each item and the scalar value a and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	A scalar value and the left operand of the operation.
b	Input vector b and the source of the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorAtan2D_NN1	(	PlankD *	result,
		const PlankD *	a,
		PlankD	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_Atan2D() to an input vector and a scalar value.

This processes vector a and applies the function pl_Atan2D() to each item and the scalar value b and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a and the source of the left operand of the operation.
b	A scalar value and the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorAtan2D_NNN	(	PlankD *	result,
		const PlankD *	a,
		const PlankD *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_Atan2D() to each item in two input vectors.

This processes vectors a and b applying the function pl_Atan2D() to each of their items in turn and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a.
b	Input vector b.
N	The number of items in the input/output vectors.

static void pl_VectorAtan2F_N1N	(	PlankF *	result,
		PlankF	a,
		const PlankF *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_Atan2F() to an input vector and a scalar value.

This processes vector b and applies the function pl_Atan2F() to each item and the scalar value a and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	A scalar value and the left operand of the operation.
b	Input vector b and the source of the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorAtan2F_NN1	(	PlankF *	result,
		const PlankF *	a,
		PlankF	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_Atan2F() to an input vector and a scalar value.

This processes vector a and applies the function pl_Atan2F() to each item and the scalar value b and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a and the source of the left operand of the operation.
b	A scalar value and the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorAtan2F_NNN	(	PlankF *	result,
		const PlankF *	a,
		const PlankF *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_Atan2F() to each item in two input vectors.

This processes vectors a and b applying the function pl_Atan2F() to each of their items in turn and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a.
b	Input vector b.
N	The number of items in the input/output vectors.

static void pl_VectorAtanD_NN	(	PlankD *	result,
		const PlankD *	a,
		PlankUL	N
	)		`[inline, static]`

Applies the function pl_AtanD() to each item in a vector.

This processes vector a applying the function pl_AtanD() to each item and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	The input vector.
N	The number of items in the input/output vectors.

static void pl_VectorAtanF_NN	(	PlankF *	result,
		const PlankF *	a,
		PlankUL	N
	)		`[inline, static]`

Applies the function pl_AtanF() to each item in a vector.

This processes vector a applying the function pl_AtanF() to each item and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	The input vector.
N	The number of items in the input/output vectors.

static void pl_VectorCeilD_NN	(	PlankD *	result,
		const PlankD *	a,
		PlankUL	N
	)		`[inline, static]`

Applies the function pl_CeilD() to each item in a vector.

This processes vector a applying the function pl_CeilD() to each item and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	The input vector.
N	The number of items in the input/output vectors.

static void pl_VectorCeilF_NN	(	PlankF *	result,
		const PlankF *	a,
		PlankUL	N
	)		`[inline, static]`

Applies the function pl_CeilF() to each item in a vector.

This processes vector a applying the function pl_CeilF() to each item and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	The input vector.
N	The number of items in the input/output vectors.

static void pl_VectorClearD_N	(	PlankD *	result,
		PlankUL	N
	)		`[inline, static]`

Fills a vector with zeros.

static void pl_VectorClearF_N	(	PlankF *	result,
		PlankUL	N
	)		`[inline, static]`

Fills a vector with zeros.

static void pl_VectorClearI_N	(	PlankI *	result,
		PlankUL	N
	)		`[inline, static]`

Fills a vector with zeros.

static void pl_VectorClearLL_N	(	PlankLL *	result,
		PlankUL	N
	)		`[inline, static]`

Fills a vector with zeros.

static void pl_VectorClearS_N	(	PlankS *	result,
		PlankUL	N
	)		`[inline, static]`

Fills a vector with zeros.

static void pl_VectorCosD_NN	(	PlankD *	result,
		const PlankD *	a,
		PlankUL	N
	)		`[inline, static]`

Applies the function pl_CosD() to each item in a vector.

This processes vector a applying the function pl_CosD() to each item and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	The input vector.
N	The number of items in the input/output vectors.

static void pl_VectorCosF_NN	(	PlankF *	result,
		const PlankF *	a,
		PlankUL	N
	)		`[inline, static]`

Applies the function pl_CosF() to each item in a vector.

This processes vector a applying the function pl_CosF() to each item and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	The input vector.
N	The number of items in the input/output vectors.

static void pl_VectorCoshD_NN	(	PlankD *	result,
		const PlankD *	a,
		PlankUL	N
	)		`[inline, static]`

Applies the function pl_CoshD() to each item in a vector.

This processes vector a applying the function pl_CoshD() to each item and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	The input vector.
N	The number of items in the input/output vectors.

static void pl_VectorCoshF_NN	(	PlankF *	result,
		const PlankF *	a,
		PlankUL	N
	)		`[inline, static]`

Applies the function pl_CoshF() to each item in a vector.

This processes vector a applying the function pl_CoshF() to each item and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	The input vector.
N	The number of items in the input/output vectors.

static void pl_VectorCubedD_NN	(	PlankD *	result,
		const PlankD *	a,
		PlankUL	N
	)		`[inline, static]`

Applies the function pl_CubedD() to each item in a vector.

This processes vector a applying the function pl_CubedD() to each item and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	The input vector.
N	The number of items in the input/output vectors.

static void pl_VectorCubedF_NN	(	PlankF *	result,
		const PlankF *	a,
		PlankUL	N
	)		`[inline, static]`

Applies the function pl_CubedF() to each item in a vector.

This processes vector a applying the function pl_CubedF() to each item and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	The input vector.
N	The number of items in the input/output vectors.

static void pl_VectorCubedI_NN	(	PlankI *	result,
		const PlankI *	a,
		PlankUL	N
	)		`[inline, static]`

Applies the function pl_CubedI() to each item in a vector.

This processes vector a applying the function pl_CubedI() to each item and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	The input vector.
N	The number of items in the input/output vectors.

static void pl_VectorCubedLL_NN	(	PlankLL *	result,
		const PlankLL *	a,
		PlankUL	N
	)		`[inline, static]`

Applies the function pl_CubedLL() to each item in a vector.

This processes vector a applying the function pl_CubedLL() to each item and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	The input vector.
N	The number of items in the input/output vectors.

static void pl_VectorCubedS_NN	(	PlankS *	result,
		const PlankS *	a,
		PlankUL	N
	)		`[inline, static]`

Applies the function pl_CubedS() to each item in a vector.

This processes vector a applying the function pl_CubedS() to each item and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	The input vector.
N	The number of items in the input/output vectors.

static void pl_VectorD2RD_NN	(	PlankD *	result,
		const PlankD *	a,
		PlankUL	N
	)		`[inline, static]`

Applies the function pl_D2RD() to each item in a vector.

This processes vector a applying the function pl_D2RD() to each item and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	The input vector.
N	The number of items in the input/output vectors.

static void pl_VectorD2RF_NN	(	PlankF *	result,
		const PlankF *	a,
		PlankUL	N
	)		`[inline, static]`

Applies the function pl_D2RF() to each item in a vector.

This processes vector a applying the function pl_D2RF() to each item and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	The input vector.
N	The number of items in the input/output vectors.

static void pl_VectordB2AD_NN	(	PlankD *	result,
		const PlankD *	a,
		PlankUL	N
	)		`[inline, static]`

Applies the function pl_dB2AD() to each item in a vector.

This processes vector a applying the function pl_dB2AD() to each item and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	The input vector.
N	The number of items in the input/output vectors.

static void pl_VectordB2AF_NN	(	PlankF *	result,
		const PlankF *	a,
		PlankUL	N
	)		`[inline, static]`

Applies the function pl_dB2AF() to each item in a vector.

This processes vector a applying the function pl_dB2AF() to each item and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	The input vector.
N	The number of items in the input/output vectors.

static void pl_VectorDecD_NN	(	PlankD *	result,
		const PlankD *	a,
		PlankUL	N
	)		`[inline, static]`

Applies the function pl_DecD() to each item in a vector.

This processes vector a applying the function pl_DecD() to each item and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	The input vector.
N	The number of items in the input/output vectors.

static void pl_VectorDecF_NN	(	PlankF *	result,
		const PlankF *	a,
		PlankUL	N
	)		`[inline, static]`

Applies the function pl_DecF() to each item in a vector.

This processes vector a applying the function pl_DecF() to each item and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	The input vector.
N	The number of items in the input/output vectors.

static void pl_VectorDecI_NN	(	PlankI *	result,
		const PlankI *	a,
		PlankUL	N
	)		`[inline, static]`

Applies the function pl_DecI() to each item in a vector.

This processes vector a applying the function pl_DecI() to each item and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	The input vector.
N	The number of items in the input/output vectors.

static void pl_VectorDecLL_NN	(	PlankLL *	result,
		const PlankLL *	a,
		PlankUL	N
	)		`[inline, static]`

Applies the function pl_DecLL() to each item in a vector.

This processes vector a applying the function pl_DecLL() to each item and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	The input vector.
N	The number of items in the input/output vectors.

static void pl_VectorDecS_NN	(	PlankS *	result,
		const PlankS *	a,
		PlankUL	N
	)		`[inline, static]`

Applies the function pl_DecS() to each item in a vector.

This processes vector a applying the function pl_DecS() to each item and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	The input vector.
N	The number of items in the input/output vectors.

static void pl_VectorDifSqrD_N1N	(	PlankD *	result,
		PlankD	a,
		const PlankD *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_DifSqrD() to an input vector and a scalar value.

This processes vector b and applies the function pl_DifSqrD() to each item and the scalar value a and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	A scalar value and the left operand of the operation.
b	Input vector b and the source of the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorDifSqrD_NN1	(	PlankD *	result,
		const PlankD *	a,
		PlankD	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_DifSqrD() to an input vector and a scalar value.

This processes vector a and applies the function pl_DifSqrD() to each item and the scalar value b and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a and the source of the left operand of the operation.
b	A scalar value and the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorDifSqrD_NNN	(	PlankD *	result,
		const PlankD *	a,
		const PlankD *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_DifSqrD() to each item in two input vectors.

This processes vectors a and b applying the function pl_DifSqrD() to each of their items in turn and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a.
b	Input vector b.
N	The number of items in the input/output vectors.

static void pl_VectorDifSqrF_N1N	(	PlankF *	result,
		PlankF	a,
		const PlankF *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_DifSqrF() to an input vector and a scalar value.

This processes vector b and applies the function pl_DifSqrF() to each item and the scalar value a and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	A scalar value and the left operand of the operation.
b	Input vector b and the source of the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorDifSqrF_NN1	(	PlankF *	result,
		const PlankF *	a,
		PlankF	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_DifSqrF() to an input vector and a scalar value.

This processes vector a and applies the function pl_DifSqrF() to each item and the scalar value b and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a and the source of the left operand of the operation.
b	A scalar value and the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorDifSqrF_NNN	(	PlankF *	result,
		const PlankF *	a,
		const PlankF *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_DifSqrF() to each item in two input vectors.

This processes vectors a and b applying the function pl_DifSqrF() to each of their items in turn and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a.
b	Input vector b.
N	The number of items in the input/output vectors.

static void pl_VectorDifSqrI_N1N	(	PlankI *	result,
		PlankI	a,
		const PlankI *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_DifSqrI() to an input vector and a scalar value.

This processes vector b and applies the function pl_DifSqrI() to each item and the scalar value a and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	A scalar value and the left operand of the operation.
b	Input vector b and the source of the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorDifSqrI_NN1	(	PlankI *	result,
		const PlankI *	a,
		PlankI	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_DifSqrI() to an input vector and a scalar value.

This processes vector a and applies the function pl_DifSqrI() to each item and the scalar value b and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a and the source of the left operand of the operation.
b	A scalar value and the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorDifSqrI_NNN	(	PlankI *	result,
		const PlankI *	a,
		const PlankI *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_DifSqrI() to each item in two input vectors.

This processes vectors a and b applying the function pl_DifSqrI() to each of their items in turn and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a.
b	Input vector b.
N	The number of items in the input/output vectors.

static void pl_VectorDifSqrLL_N1N	(	PlankLL *	result,
		PlankLL	a,
		const PlankLL *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_DifSqrLL() to an input vector and a scalar value.

This processes vector b and applies the function pl_DifSqrLL() to each item and the scalar value a and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	A scalar value and the left operand of the operation.
b	Input vector b and the source of the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorDifSqrLL_NN1	(	PlankLL *	result,
		const PlankLL *	a,
		PlankLL	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_DifSqrLL() to an input vector and a scalar value.

This processes vector a and applies the function pl_DifSqrLL() to each item and the scalar value b and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a and the source of the left operand of the operation.
b	A scalar value and the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorDifSqrLL_NNN	(	PlankLL *	result,
		const PlankLL *	a,
		const PlankLL *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_DifSqrLL() to each item in two input vectors.

This processes vectors a and b applying the function pl_DifSqrLL() to each of their items in turn and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a.
b	Input vector b.
N	The number of items in the input/output vectors.

static void pl_VectorDifSqrS_N1N	(	PlankS *	result,
		PlankS	a,
		const PlankS *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_DifSqrS() to an input vector and a scalar value.

This processes vector b and applies the function pl_DifSqrS() to each item and the scalar value a and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	A scalar value and the left operand of the operation.
b	Input vector b and the source of the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorDifSqrS_NN1	(	PlankS *	result,
		const PlankS *	a,
		PlankS	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_DifSqrS() to an input vector and a scalar value.

This processes vector a and applies the function pl_DifSqrS() to each item and the scalar value b and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a and the source of the left operand of the operation.
b	A scalar value and the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorDifSqrS_NNN	(	PlankS *	result,
		const PlankS *	a,
		const PlankS *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_DifSqrS() to each item in two input vectors.

This processes vectors a and b applying the function pl_DifSqrS() to each of their items in turn and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a.
b	Input vector b.
N	The number of items in the input/output vectors.

static void pl_VectorDistortD_NN	(	PlankD *	result,
		const PlankD *	a,
		PlankUL	N
	)		`[inline, static]`

Applies the function pl_DistortD() to each item in a vector.

This processes vector a applying the function pl_DistortD() to each item and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	The input vector.
N	The number of items in the input/output vectors.

static void pl_VectorDistortF_NN	(	PlankF *	result,
		const PlankF *	a,
		PlankUL	N
	)		`[inline, static]`

Applies the function pl_DistortF() to each item in a vector.

This processes vector a applying the function pl_DistortF() to each item and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	The input vector.
N	The number of items in the input/output vectors.

static void pl_VectorDivD_N1N	(	PlankD *	result,
		PlankD	a,
		const PlankD *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_DivD() to an input vector and a scalar value.

This processes vector b and applies the function pl_DivD() to each item and the scalar value a and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	A scalar value and the left operand of the operation.
b	Input vector b and the source of the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorDivD_NN1	(	PlankD *	result,
		const PlankD *	a,
		PlankD	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_DivD() to an input vector and a scalar value.

This processes vector a and applies the function pl_DivD() to each item and the scalar value b and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a and the source of the left operand of the operation.
b	A scalar value and the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorDivD_NNN	(	PlankD *	result,
		const PlankD *	a,
		const PlankD *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_DivD() to each item in two input vectors.

This processes vectors a and b applying the function pl_DivD() to each of their items in turn and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a.
b	Input vector b.
N	The number of items in the input/output vectors.

static void pl_VectorDivF_N1N	(	PlankF *	result,
		PlankF	a,
		const PlankF *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_DivF() to an input vector and a scalar value.

This processes vector b and applies the function pl_DivF() to each item and the scalar value a and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	A scalar value and the left operand of the operation.
b	Input vector b and the source of the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorDivF_NN1	(	PlankF *	result,
		const PlankF *	a,
		PlankF	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_DivF() to an input vector and a scalar value.

This processes vector a and applies the function pl_DivF() to each item and the scalar value b and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a and the source of the left operand of the operation.
b	A scalar value and the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorDivF_NNN	(	PlankF *	result,
		const PlankF *	a,
		const PlankF *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_DivF() to each item in two input vectors.

This processes vectors a and b applying the function pl_DivF() to each of their items in turn and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a.
b	Input vector b.
N	The number of items in the input/output vectors.

static void pl_VectorDivI_N1N	(	PlankI *	result,
		PlankI	a,
		const PlankI *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_DivI() to an input vector and a scalar value.

This processes vector b and applies the function pl_DivI() to each item and the scalar value a and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	A scalar value and the left operand of the operation.
b	Input vector b and the source of the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorDivI_NN1	(	PlankI *	result,
		const PlankI *	a,
		PlankI	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_DivI() to an input vector and a scalar value.

This processes vector a and applies the function pl_DivI() to each item and the scalar value b and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a and the source of the left operand of the operation.
b	A scalar value and the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorDivI_NNN	(	PlankI *	result,
		const PlankI *	a,
		const PlankI *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_DivI() to each item in two input vectors.

This processes vectors a and b applying the function pl_DivI() to each of their items in turn and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a.
b	Input vector b.
N	The number of items in the input/output vectors.

static void pl_VectorDivLL_N1N	(	PlankLL *	result,
		PlankLL	a,
		const PlankLL *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_DivLL() to an input vector and a scalar value.

This processes vector b and applies the function pl_DivLL() to each item and the scalar value a and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	A scalar value and the left operand of the operation.
b	Input vector b and the source of the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorDivLL_NN1	(	PlankLL *	result,
		const PlankLL *	a,
		PlankLL	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_DivLL() to an input vector and a scalar value.

This processes vector a and applies the function pl_DivLL() to each item and the scalar value b and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a and the source of the left operand of the operation.
b	A scalar value and the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorDivLL_NNN	(	PlankLL *	result,
		const PlankLL *	a,
		const PlankLL *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_DivLL() to each item in two input vectors.

This processes vectors a and b applying the function pl_DivLL() to each of their items in turn and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a.
b	Input vector b.
N	The number of items in the input/output vectors.

static void pl_VectorDivS_N1N	(	PlankS *	result,
		PlankS	a,
		const PlankS *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_DivS() to an input vector and a scalar value.

This processes vector b and applies the function pl_DivS() to each item and the scalar value a and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	A scalar value and the left operand of the operation.
b	Input vector b and the source of the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorDivS_NN1	(	PlankS *	result,
		const PlankS *	a,
		PlankS	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_DivS() to an input vector and a scalar value.

This processes vector a and applies the function pl_DivS() to each item and the scalar value b and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a and the source of the left operand of the operation.
b	A scalar value and the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorDivS_NNN	(	PlankS *	result,
		const PlankS *	a,
		const PlankS *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_DivS() to each item in two input vectors.

This processes vectors a and b applying the function pl_DivS() to each of their items in turn and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a.
b	Input vector b.
N	The number of items in the input/output vectors.

static void pl_VectorExpD_NN	(	PlankD *	result,
		const PlankD *	a,
		PlankUL	N
	)		`[inline, static]`

Applies the function pl_ExpD() to each item in a vector.

This processes vector a applying the function pl_ExpD() to each item and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	The input vector.
N	The number of items in the input/output vectors.

static void pl_VectorExpF_NN	(	PlankF *	result,
		const PlankF *	a,
		PlankUL	N
	)		`[inline, static]`

Applies the function pl_ExpF() to each item in a vector.

This processes vector a applying the function pl_ExpF() to each item and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	The input vector.
N	The number of items in the input/output vectors.

static void pl_VectorF2MD_NN	(	PlankD *	result,
		const PlankD *	a,
		PlankUL	N
	)		`[inline, static]`

Applies the function pl_F2MD() to each item in a vector.

This processes vector a applying the function pl_F2MD() to each item and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	The input vector.
N	The number of items in the input/output vectors.

static void pl_VectorF2MF_NN	(	PlankF *	result,
		const PlankF *	a,
		PlankUL	N
	)		`[inline, static]`

Applies the function pl_F2MF() to each item in a vector.

This processes vector a applying the function pl_F2MF() to each item and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	The input vector.
N	The number of items in the input/output vectors.

static void pl_VectorFillD_N1	(	PlankD *	result,
		PlankD	value,
		PlankUL	N
	)		`[inline, static]`

Fills a vector with a constant.

static void pl_VectorFillF_N1	(	PlankF *	result,
		PlankF	value,
		PlankUL	N
	)		`[inline, static]`

Fills a vector with a constant.

static void pl_VectorFillI_N1	(	PlankI *	result,
		PlankI	value,
		PlankUL	N
	)		`[inline, static]`

Fills a vector with a constant.

static void pl_VectorFillLL_N1	(	PlankLL *	result,
		PlankLL	value,
		PlankUL	N
	)		`[inline, static]`

Fills a vector with a constant.

static void pl_VectorFillS_N1	(	PlankS *	result,
		PlankS	value,
		PlankUL	N
	)		`[inline, static]`

Fills a vector with a constant.

static void pl_VectorFloorD_NN	(	PlankD *	result,
		const PlankD *	a,
		PlankUL	N
	)		`[inline, static]`

Applies the function pl_FloorD() to each item in a vector.

This processes vector a applying the function pl_FloorD() to each item and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	The input vector.
N	The number of items in the input/output vectors.

static void pl_VectorFloorF_NN	(	PlankF *	result,
		const PlankF *	a,
		PlankUL	N
	)		`[inline, static]`

Applies the function pl_FloorF() to each item in a vector.

This processes vector a applying the function pl_FloorF() to each item and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	The input vector.
N	The number of items in the input/output vectors.

static void pl_VectorFracD_NN	(	PlankD *	result,
		const PlankD *	a,
		PlankUL	N
	)		`[inline, static]`

Applies the function pl_FracD() to each item in a vector.

This processes vector a applying the function pl_FracD() to each item and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	The input vector.
N	The number of items in the input/output vectors.

static void pl_VectorFracF_NN	(	PlankF *	result,
		const PlankF *	a,
		PlankUL	N
	)		`[inline, static]`

Applies the function pl_FracF() to each item in a vector.

This processes vector a applying the function pl_FracF() to each item and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	The input vector.
N	The number of items in the input/output vectors.

static void pl_VectorHypotD_N1N	(	PlankD *	result,
		PlankD	a,
		const PlankD *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_HypotD() to an input vector and a scalar value.

This processes vector b and applies the function pl_HypotD() to each item and the scalar value a and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	A scalar value and the left operand of the operation.
b	Input vector b and the source of the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorHypotD_NN1	(	PlankD *	result,
		const PlankD *	a,
		PlankD	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_HypotD() to an input vector and a scalar value.

This processes vector a and applies the function pl_HypotD() to each item and the scalar value b and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a and the source of the left operand of the operation.
b	A scalar value and the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorHypotD_NNN	(	PlankD *	result,
		const PlankD *	a,
		const PlankD *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_HypotD() to each item in two input vectors.

This processes vectors a and b applying the function pl_HypotD() to each of their items in turn and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a.
b	Input vector b.
N	The number of items in the input/output vectors.

static void pl_VectorHypotF_N1N	(	PlankF *	result,
		PlankF	a,
		const PlankF *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_HypotF() to an input vector and a scalar value.

This processes vector b and applies the function pl_HypotF() to each item and the scalar value a and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	A scalar value and the left operand of the operation.
b	Input vector b and the source of the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorHypotF_NN1	(	PlankF *	result,
		const PlankF *	a,
		PlankF	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_HypotF() to an input vector and a scalar value.

This processes vector a and applies the function pl_HypotF() to each item and the scalar value b and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a and the source of the left operand of the operation.
b	A scalar value and the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorHypotF_NNN	(	PlankF *	result,
		const PlankF *	a,
		const PlankF *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_HypotF() to each item in two input vectors.

This processes vectors a and b applying the function pl_HypotF() to each of their items in turn and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a.
b	Input vector b.
N	The number of items in the input/output vectors.

static void pl_VectorIncD_NN	(	PlankD *	result,
		const PlankD *	a,
		PlankUL	N
	)		`[inline, static]`

Applies the function pl_IncD() to each item in a vector.

This processes vector a applying the function pl_IncD() to each item and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	The input vector.
N	The number of items in the input/output vectors.

static void pl_VectorIncF_NN	(	PlankF *	result,
		const PlankF *	a,
		PlankUL	N
	)		`[inline, static]`

Applies the function pl_IncF() to each item in a vector.

This processes vector a applying the function pl_IncF() to each item and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	The input vector.
N	The number of items in the input/output vectors.

static void pl_VectorIncI_NN	(	PlankI *	result,
		const PlankI *	a,
		PlankUL	N
	)		`[inline, static]`

Applies the function pl_IncI() to each item in a vector.

This processes vector a applying the function pl_IncI() to each item and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	The input vector.
N	The number of items in the input/output vectors.

static void pl_VectorIncLL_NN	(	PlankLL *	result,
		const PlankLL *	a,
		PlankUL	N
	)		`[inline, static]`

Applies the function pl_IncLL() to each item in a vector.

This processes vector a applying the function pl_IncLL() to each item and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	The input vector.
N	The number of items in the input/output vectors.

static void pl_VectorIncS_NN	(	PlankS *	result,
		const PlankS *	a,
		PlankUL	N
	)		`[inline, static]`

Applies the function pl_IncS() to each item in a vector.

This processes vector a applying the function pl_IncS() to each item and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	The input vector.
N	The number of items in the input/output vectors.

static void pl_VectorIsEqualToD_N1N	(	PlankD *	result,
		PlankD	a,
		const PlankD *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsEqualToD() to an input vector and a scalar value.

This processes vector b and applies the function pl_IsEqualToD() to each item and the scalar value a and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	A scalar value and the left operand of the operation.
b	Input vector b and the source of the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorIsEqualToD_NN1	(	PlankD *	result,
		const PlankD *	a,
		PlankD	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsEqualToD() to an input vector and a scalar value.

This processes vector a and applies the function pl_IsEqualToD() to each item and the scalar value b and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a and the source of the left operand of the operation.
b	A scalar value and the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorIsEqualToD_NNN	(	PlankD *	result,
		const PlankD *	a,
		const PlankD *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsEqualToD() to each item in two input vectors.

This processes vectors a and b applying the function pl_IsEqualToD() to each of their items in turn and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a.
b	Input vector b.
N	The number of items in the input/output vectors.

static void pl_VectorIsEqualToF_N1N	(	PlankF *	result,
		PlankF	a,
		const PlankF *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsEqualToF() to an input vector and a scalar value.

This processes vector b and applies the function pl_IsEqualToF() to each item and the scalar value a and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	A scalar value and the left operand of the operation.
b	Input vector b and the source of the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorIsEqualToF_NN1	(	PlankF *	result,
		const PlankF *	a,
		PlankF	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsEqualToF() to an input vector and a scalar value.

This processes vector a and applies the function pl_IsEqualToF() to each item and the scalar value b and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a and the source of the left operand of the operation.
b	A scalar value and the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorIsEqualToF_NNN	(	PlankF *	result,
		const PlankF *	a,
		const PlankF *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsEqualToF() to each item in two input vectors.

This processes vectors a and b applying the function pl_IsEqualToF() to each of their items in turn and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a.
b	Input vector b.
N	The number of items in the input/output vectors.

static void pl_VectorIsEqualToI_N1N	(	PlankI *	result,
		PlankI	a,
		const PlankI *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsEqualToI() to an input vector and a scalar value.

This processes vector b and applies the function pl_IsEqualToI() to each item and the scalar value a and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	A scalar value and the left operand of the operation.
b	Input vector b and the source of the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorIsEqualToI_NN1	(	PlankI *	result,
		const PlankI *	a,
		PlankI	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsEqualToI() to an input vector and a scalar value.

This processes vector a and applies the function pl_IsEqualToI() to each item and the scalar value b and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a and the source of the left operand of the operation.
b	A scalar value and the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorIsEqualToI_NNN	(	PlankI *	result,
		const PlankI *	a,
		const PlankI *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsEqualToI() to each item in two input vectors.

This processes vectors a and b applying the function pl_IsEqualToI() to each of their items in turn and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a.
b	Input vector b.
N	The number of items in the input/output vectors.

static void pl_VectorIsEqualToLL_N1N	(	PlankLL *	result,
		PlankLL	a,
		const PlankLL *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsEqualToLL() to an input vector and a scalar value.

This processes vector b and applies the function pl_IsEqualToLL() to each item and the scalar value a and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	A scalar value and the left operand of the operation.
b	Input vector b and the source of the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorIsEqualToLL_NN1	(	PlankLL *	result,
		const PlankLL *	a,
		PlankLL	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsEqualToLL() to an input vector and a scalar value.

This processes vector a and applies the function pl_IsEqualToLL() to each item and the scalar value b and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a and the source of the left operand of the operation.
b	A scalar value and the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorIsEqualToLL_NNN	(	PlankLL *	result,
		const PlankLL *	a,
		const PlankLL *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsEqualToLL() to each item in two input vectors.

This processes vectors a and b applying the function pl_IsEqualToLL() to each of their items in turn and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a.
b	Input vector b.
N	The number of items in the input/output vectors.

static void pl_VectorIsEqualToS_N1N	(	PlankS *	result,
		PlankS	a,
		const PlankS *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsEqualToS() to an input vector and a scalar value.

This processes vector b and applies the function pl_IsEqualToS() to each item and the scalar value a and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	A scalar value and the left operand of the operation.
b	Input vector b and the source of the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorIsEqualToS_NN1	(	PlankS *	result,
		const PlankS *	a,
		PlankS	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsEqualToS() to an input vector and a scalar value.

This processes vector a and applies the function pl_IsEqualToS() to each item and the scalar value b and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a and the source of the left operand of the operation.
b	A scalar value and the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorIsEqualToS_NNN	(	PlankS *	result,
		const PlankS *	a,
		const PlankS *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsEqualToS() to each item in two input vectors.

This processes vectors a and b applying the function pl_IsEqualToS() to each of their items in turn and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a.
b	Input vector b.
N	The number of items in the input/output vectors.

static void pl_VectorIsGreaterThanD_N1N	(	PlankD *	result,
		PlankD	a,
		const PlankD *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsGreaterThanD() to an input vector and a scalar value.

This processes vector b and applies the function pl_IsGreaterThanD() to each item and the scalar value a and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	A scalar value and the left operand of the operation.
b	Input vector b and the source of the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorIsGreaterThanD_NN1	(	PlankD *	result,
		const PlankD *	a,
		PlankD	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsGreaterThanD() to an input vector and a scalar value.

This processes vector a and applies the function pl_IsGreaterThanD() to each item and the scalar value b and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a and the source of the left operand of the operation.
b	A scalar value and the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorIsGreaterThanD_NNN	(	PlankD *	result,
		const PlankD *	a,
		const PlankD *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsGreaterThanD() to each item in two input vectors.

This processes vectors a and b applying the function pl_IsGreaterThanD() to each of their items in turn and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a.
b	Input vector b.
N	The number of items in the input/output vectors.

static void pl_VectorIsGreaterThanF_N1N	(	PlankF *	result,
		PlankF	a,
		const PlankF *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsGreaterThanF() to an input vector and a scalar value.

This processes vector b and applies the function pl_IsGreaterThanF() to each item and the scalar value a and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	A scalar value and the left operand of the operation.
b	Input vector b and the source of the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorIsGreaterThanF_NN1	(	PlankF *	result,
		const PlankF *	a,
		PlankF	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsGreaterThanF() to an input vector and a scalar value.

This processes vector a and applies the function pl_IsGreaterThanF() to each item and the scalar value b and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a and the source of the left operand of the operation.
b	A scalar value and the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorIsGreaterThanF_NNN	(	PlankF *	result,
		const PlankF *	a,
		const PlankF *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsGreaterThanF() to each item in two input vectors.

This processes vectors a and b applying the function pl_IsGreaterThanF() to each of their items in turn and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a.
b	Input vector b.
N	The number of items in the input/output vectors.

static void pl_VectorIsGreaterThanI_N1N	(	PlankI *	result,
		PlankI	a,
		const PlankI *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsGreaterThanI() to an input vector and a scalar value.

This processes vector b and applies the function pl_IsGreaterThanI() to each item and the scalar value a and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	A scalar value and the left operand of the operation.
b	Input vector b and the source of the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorIsGreaterThanI_NN1	(	PlankI *	result,
		const PlankI *	a,
		PlankI	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsGreaterThanI() to an input vector and a scalar value.

This processes vector a and applies the function pl_IsGreaterThanI() to each item and the scalar value b and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a and the source of the left operand of the operation.
b	A scalar value and the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorIsGreaterThanI_NNN	(	PlankI *	result,
		const PlankI *	a,
		const PlankI *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsGreaterThanI() to each item in two input vectors.

This processes vectors a and b applying the function pl_IsGreaterThanI() to each of their items in turn and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a.
b	Input vector b.
N	The number of items in the input/output vectors.

static void pl_VectorIsGreaterThanLL_N1N	(	PlankLL *	result,
		PlankLL	a,
		const PlankLL *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsGreaterThanLL() to an input vector and a scalar value.

This processes vector b and applies the function pl_IsGreaterThanLL() to each item and the scalar value a and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	A scalar value and the left operand of the operation.
b	Input vector b and the source of the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorIsGreaterThanLL_NN1	(	PlankLL *	result,
		const PlankLL *	a,
		PlankLL	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsGreaterThanLL() to an input vector and a scalar value.

This processes vector a and applies the function pl_IsGreaterThanLL() to each item and the scalar value b and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a and the source of the left operand of the operation.
b	A scalar value and the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorIsGreaterThanLL_NNN	(	PlankLL *	result,
		const PlankLL *	a,
		const PlankLL *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsGreaterThanLL() to each item in two input vectors.

This processes vectors a and b applying the function pl_IsGreaterThanLL() to each of their items in turn and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a.
b	Input vector b.
N	The number of items in the input/output vectors.

static void pl_VectorIsGreaterThanOrEqualToD_N1N	(	PlankD *	result,
		PlankD	a,
		const PlankD *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsGreaterThanOrEqualToD() to an input vector and a scalar value.

This processes vector b and applies the function pl_IsGreaterThanOrEqualToD() to each item and the scalar value a and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	A scalar value and the left operand of the operation.
b	Input vector b and the source of the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorIsGreaterThanOrEqualToD_NN1	(	PlankD *	result,
		const PlankD *	a,
		PlankD	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsGreaterThanOrEqualToD() to an input vector and a scalar value.

This processes vector a and applies the function pl_IsGreaterThanOrEqualToD() to each item and the scalar value b and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a and the source of the left operand of the operation.
b	A scalar value and the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorIsGreaterThanOrEqualToD_NNN	(	PlankD *	result,
		const PlankD *	a,
		const PlankD *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsGreaterThanOrEqualToD() to each item in two input vectors.

This processes vectors a and b applying the function pl_IsGreaterThanOrEqualToD() to each of their items in turn and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a.
b	Input vector b.
N	The number of items in the input/output vectors.

static void pl_VectorIsGreaterThanOrEqualToF_N1N	(	PlankF *	result,
		PlankF	a,
		const PlankF *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsGreaterThanOrEqualToF() to an input vector and a scalar value.

This processes vector b and applies the function pl_IsGreaterThanOrEqualToF() to each item and the scalar value a and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	A scalar value and the left operand of the operation.
b	Input vector b and the source of the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorIsGreaterThanOrEqualToF_NN1	(	PlankF *	result,
		const PlankF *	a,
		PlankF	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsGreaterThanOrEqualToF() to an input vector and a scalar value.

This processes vector a and applies the function pl_IsGreaterThanOrEqualToF() to each item and the scalar value b and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a and the source of the left operand of the operation.
b	A scalar value and the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorIsGreaterThanOrEqualToF_NNN	(	PlankF *	result,
		const PlankF *	a,
		const PlankF *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsGreaterThanOrEqualToF() to each item in two input vectors.

This processes vectors a and b applying the function pl_IsGreaterThanOrEqualToF() to each of their items in turn and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a.
b	Input vector b.
N	The number of items in the input/output vectors.

static void pl_VectorIsGreaterThanOrEqualToI_N1N	(	PlankI *	result,
		PlankI	a,
		const PlankI *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsGreaterThanOrEqualToI() to an input vector and a scalar value.

This processes vector b and applies the function pl_IsGreaterThanOrEqualToI() to each item and the scalar value a and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	A scalar value and the left operand of the operation.
b	Input vector b and the source of the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorIsGreaterThanOrEqualToI_NN1	(	PlankI *	result,
		const PlankI *	a,
		PlankI	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsGreaterThanOrEqualToI() to an input vector and a scalar value.

This processes vector a and applies the function pl_IsGreaterThanOrEqualToI() to each item and the scalar value b and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a and the source of the left operand of the operation.
b	A scalar value and the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorIsGreaterThanOrEqualToI_NNN	(	PlankI *	result,
		const PlankI *	a,
		const PlankI *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsGreaterThanOrEqualToI() to each item in two input vectors.

This processes vectors a and b applying the function pl_IsGreaterThanOrEqualToI() to each of their items in turn and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a.
b	Input vector b.
N	The number of items in the input/output vectors.

static void pl_VectorIsGreaterThanOrEqualToLL_N1N	(	PlankLL *	result,
		PlankLL	a,
		const PlankLL *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsGreaterThanOrEqualToLL() to an input vector and a scalar value.

This processes vector b and applies the function pl_IsGreaterThanOrEqualToLL() to each item and the scalar value a and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	A scalar value and the left operand of the operation.
b	Input vector b and the source of the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorIsGreaterThanOrEqualToLL_NN1	(	PlankLL *	result,
		const PlankLL *	a,
		PlankLL	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsGreaterThanOrEqualToLL() to an input vector and a scalar value.

This processes vector a and applies the function pl_IsGreaterThanOrEqualToLL() to each item and the scalar value b and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a and the source of the left operand of the operation.
b	A scalar value and the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorIsGreaterThanOrEqualToLL_NNN	(	PlankLL *	result,
		const PlankLL *	a,
		const PlankLL *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsGreaterThanOrEqualToLL() to each item in two input vectors.

This processes vectors a and b applying the function pl_IsGreaterThanOrEqualToLL() to each of their items in turn and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a.
b	Input vector b.
N	The number of items in the input/output vectors.

static void pl_VectorIsGreaterThanOrEqualToS_N1N	(	PlankS *	result,
		PlankS	a,
		const PlankS *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsGreaterThanOrEqualToS() to an input vector and a scalar value.

This processes vector b and applies the function pl_IsGreaterThanOrEqualToS() to each item and the scalar value a and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	A scalar value and the left operand of the operation.
b	Input vector b and the source of the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorIsGreaterThanOrEqualToS_NN1	(	PlankS *	result,
		const PlankS *	a,
		PlankS	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsGreaterThanOrEqualToS() to an input vector and a scalar value.

This processes vector a and applies the function pl_IsGreaterThanOrEqualToS() to each item and the scalar value b and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a and the source of the left operand of the operation.
b	A scalar value and the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorIsGreaterThanOrEqualToS_NNN	(	PlankS *	result,
		const PlankS *	a,
		const PlankS *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsGreaterThanOrEqualToS() to each item in two input vectors.

This processes vectors a and b applying the function pl_IsGreaterThanOrEqualToS() to each of their items in turn and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a.
b	Input vector b.
N	The number of items in the input/output vectors.

static void pl_VectorIsGreaterThanS_N1N	(	PlankS *	result,
		PlankS	a,
		const PlankS *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsGreaterThanS() to an input vector and a scalar value.

This processes vector b and applies the function pl_IsGreaterThanS() to each item and the scalar value a and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	A scalar value and the left operand of the operation.
b	Input vector b and the source of the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorIsGreaterThanS_NN1	(	PlankS *	result,
		const PlankS *	a,
		PlankS	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsGreaterThanS() to an input vector and a scalar value.

This processes vector a and applies the function pl_IsGreaterThanS() to each item and the scalar value b and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a and the source of the left operand of the operation.
b	A scalar value and the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorIsGreaterThanS_NNN	(	PlankS *	result,
		const PlankS *	a,
		const PlankS *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsGreaterThanS() to each item in two input vectors.

This processes vectors a and b applying the function pl_IsGreaterThanS() to each of their items in turn and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a.
b	Input vector b.
N	The number of items in the input/output vectors.

static void pl_VectorIsLessThanD_N1N	(	PlankD *	result,
		PlankD	a,
		const PlankD *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsLessThanD() to an input vector and a scalar value.

This processes vector b and applies the function pl_IsLessThanD() to each item and the scalar value a and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	A scalar value and the left operand of the operation.
b	Input vector b and the source of the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorIsLessThanD_NN1	(	PlankD *	result,
		const PlankD *	a,
		PlankD	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsLessThanD() to an input vector and a scalar value.

This processes vector a and applies the function pl_IsLessThanD() to each item and the scalar value b and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a and the source of the left operand of the operation.
b	A scalar value and the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorIsLessThanD_NNN	(	PlankD *	result,
		const PlankD *	a,
		const PlankD *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsLessThanD() to each item in two input vectors.

This processes vectors a and b applying the function pl_IsLessThanD() to each of their items in turn and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a.
b	Input vector b.
N	The number of items in the input/output vectors.

static void pl_VectorIsLessThanF_N1N	(	PlankF *	result,
		PlankF	a,
		const PlankF *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsLessThanF() to an input vector and a scalar value.

This processes vector b and applies the function pl_IsLessThanF() to each item and the scalar value a and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	A scalar value and the left operand of the operation.
b	Input vector b and the source of the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorIsLessThanF_NN1	(	PlankF *	result,
		const PlankF *	a,
		PlankF	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsLessThanF() to an input vector and a scalar value.

This processes vector a and applies the function pl_IsLessThanF() to each item and the scalar value b and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a and the source of the left operand of the operation.
b	A scalar value and the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorIsLessThanF_NNN	(	PlankF *	result,
		const PlankF *	a,
		const PlankF *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsLessThanF() to each item in two input vectors.

This processes vectors a and b applying the function pl_IsLessThanF() to each of their items in turn and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a.
b	Input vector b.
N	The number of items in the input/output vectors.

static void pl_VectorIsLessThanI_N1N	(	PlankI *	result,
		PlankI	a,
		const PlankI *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsLessThanI() to an input vector and a scalar value.

This processes vector b and applies the function pl_IsLessThanI() to each item and the scalar value a and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	A scalar value and the left operand of the operation.
b	Input vector b and the source of the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorIsLessThanI_NN1	(	PlankI *	result,
		const PlankI *	a,
		PlankI	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsLessThanI() to an input vector and a scalar value.

This processes vector a and applies the function pl_IsLessThanI() to each item and the scalar value b and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a and the source of the left operand of the operation.
b	A scalar value and the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorIsLessThanI_NNN	(	PlankI *	result,
		const PlankI *	a,
		const PlankI *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsLessThanI() to each item in two input vectors.

This processes vectors a and b applying the function pl_IsLessThanI() to each of their items in turn and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a.
b	Input vector b.
N	The number of items in the input/output vectors.

static void pl_VectorIsLessThanLL_N1N	(	PlankLL *	result,
		PlankLL	a,
		const PlankLL *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsLessThanLL() to an input vector and a scalar value.

This processes vector b and applies the function pl_IsLessThanLL() to each item and the scalar value a and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	A scalar value and the left operand of the operation.
b	Input vector b and the source of the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorIsLessThanLL_NN1	(	PlankLL *	result,
		const PlankLL *	a,
		PlankLL	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsLessThanLL() to an input vector and a scalar value.

This processes vector a and applies the function pl_IsLessThanLL() to each item and the scalar value b and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a and the source of the left operand of the operation.
b	A scalar value and the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorIsLessThanLL_NNN	(	PlankLL *	result,
		const PlankLL *	a,
		const PlankLL *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsLessThanLL() to each item in two input vectors.

This processes vectors a and b applying the function pl_IsLessThanLL() to each of their items in turn and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a.
b	Input vector b.
N	The number of items in the input/output vectors.

static void pl_VectorIsLessThanOrEqualToD_N1N	(	PlankD *	result,
		PlankD	a,
		const PlankD *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsLessThanOrEqualToD() to an input vector and a scalar value.

This processes vector b and applies the function pl_IsLessThanOrEqualToD() to each item and the scalar value a and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	A scalar value and the left operand of the operation.
b	Input vector b and the source of the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorIsLessThanOrEqualToD_NN1	(	PlankD *	result,
		const PlankD *	a,
		PlankD	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsLessThanOrEqualToD() to an input vector and a scalar value.

This processes vector a and applies the function pl_IsLessThanOrEqualToD() to each item and the scalar value b and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a and the source of the left operand of the operation.
b	A scalar value and the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorIsLessThanOrEqualToD_NNN	(	PlankD *	result,
		const PlankD *	a,
		const PlankD *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsLessThanOrEqualToD() to each item in two input vectors.

This processes vectors a and b applying the function pl_IsLessThanOrEqualToD() to each of their items in turn and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a.
b	Input vector b.
N	The number of items in the input/output vectors.

static void pl_VectorIsLessThanOrEqualToF_N1N	(	PlankF *	result,
		PlankF	a,
		const PlankF *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsLessThanOrEqualToF() to an input vector and a scalar value.

This processes vector b and applies the function pl_IsLessThanOrEqualToF() to each item and the scalar value a and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	A scalar value and the left operand of the operation.
b	Input vector b and the source of the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorIsLessThanOrEqualToF_NN1	(	PlankF *	result,
		const PlankF *	a,
		PlankF	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsLessThanOrEqualToF() to an input vector and a scalar value.

This processes vector a and applies the function pl_IsLessThanOrEqualToF() to each item and the scalar value b and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a and the source of the left operand of the operation.
b	A scalar value and the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorIsLessThanOrEqualToF_NNN	(	PlankF *	result,
		const PlankF *	a,
		const PlankF *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsLessThanOrEqualToF() to each item in two input vectors.

This processes vectors a and b applying the function pl_IsLessThanOrEqualToF() to each of their items in turn and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a.
b	Input vector b.
N	The number of items in the input/output vectors.

static void pl_VectorIsLessThanOrEqualToI_N1N	(	PlankI *	result,
		PlankI	a,
		const PlankI *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsLessThanOrEqualToI() to an input vector and a scalar value.

This processes vector b and applies the function pl_IsLessThanOrEqualToI() to each item and the scalar value a and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	A scalar value and the left operand of the operation.
b	Input vector b and the source of the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorIsLessThanOrEqualToI_NN1	(	PlankI *	result,
		const PlankI *	a,
		PlankI	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsLessThanOrEqualToI() to an input vector and a scalar value.

This processes vector a and applies the function pl_IsLessThanOrEqualToI() to each item and the scalar value b and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a and the source of the left operand of the operation.
b	A scalar value and the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorIsLessThanOrEqualToI_NNN	(	PlankI *	result,
		const PlankI *	a,
		const PlankI *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsLessThanOrEqualToI() to each item in two input vectors.

This processes vectors a and b applying the function pl_IsLessThanOrEqualToI() to each of their items in turn and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a.
b	Input vector b.
N	The number of items in the input/output vectors.

static void pl_VectorIsLessThanOrEqualToLL_N1N	(	PlankLL *	result,
		PlankLL	a,
		const PlankLL *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsLessThanOrEqualToLL() to an input vector and a scalar value.

This processes vector b and applies the function pl_IsLessThanOrEqualToLL() to each item and the scalar value a and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	A scalar value and the left operand of the operation.
b	Input vector b and the source of the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorIsLessThanOrEqualToLL_NN1	(	PlankLL *	result,
		const PlankLL *	a,
		PlankLL	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsLessThanOrEqualToLL() to an input vector and a scalar value.

This processes vector a and applies the function pl_IsLessThanOrEqualToLL() to each item and the scalar value b and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a and the source of the left operand of the operation.
b	A scalar value and the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorIsLessThanOrEqualToLL_NNN	(	PlankLL *	result,
		const PlankLL *	a,
		const PlankLL *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsLessThanOrEqualToLL() to each item in two input vectors.

This processes vectors a and b applying the function pl_IsLessThanOrEqualToLL() to each of their items in turn and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a.
b	Input vector b.
N	The number of items in the input/output vectors.

static void pl_VectorIsLessThanOrEqualToS_N1N	(	PlankS *	result,
		PlankS	a,
		const PlankS *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsLessThanOrEqualToS() to an input vector and a scalar value.

This processes vector b and applies the function pl_IsLessThanOrEqualToS() to each item and the scalar value a and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	A scalar value and the left operand of the operation.
b	Input vector b and the source of the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorIsLessThanOrEqualToS_NN1	(	PlankS *	result,
		const PlankS *	a,
		PlankS	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsLessThanOrEqualToS() to an input vector and a scalar value.

This processes vector a and applies the function pl_IsLessThanOrEqualToS() to each item and the scalar value b and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a and the source of the left operand of the operation.
b	A scalar value and the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorIsLessThanOrEqualToS_NNN	(	PlankS *	result,
		const PlankS *	a,
		const PlankS *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsLessThanOrEqualToS() to each item in two input vectors.

This processes vectors a and b applying the function pl_IsLessThanOrEqualToS() to each of their items in turn and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a.
b	Input vector b.
N	The number of items in the input/output vectors.

static void pl_VectorIsLessThanS_N1N	(	PlankS *	result,
		PlankS	a,
		const PlankS *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsLessThanS() to an input vector and a scalar value.

This processes vector b and applies the function pl_IsLessThanS() to each item and the scalar value a and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	A scalar value and the left operand of the operation.
b	Input vector b and the source of the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorIsLessThanS_NN1	(	PlankS *	result,
		const PlankS *	a,
		PlankS	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsLessThanS() to an input vector and a scalar value.

This processes vector a and applies the function pl_IsLessThanS() to each item and the scalar value b and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a and the source of the left operand of the operation.
b	A scalar value and the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorIsLessThanS_NNN	(	PlankS *	result,
		const PlankS *	a,
		const PlankS *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsLessThanS() to each item in two input vectors.

This processes vectors a and b applying the function pl_IsLessThanS() to each of their items in turn and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a.
b	Input vector b.
N	The number of items in the input/output vectors.

static void pl_VectorIsNotEqualToD_N1N	(	PlankD *	result,
		PlankD	a,
		const PlankD *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsNotEqualToD() to an input vector and a scalar value.

This processes vector b and applies the function pl_IsNotEqualToD() to each item and the scalar value a and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	A scalar value and the left operand of the operation.
b	Input vector b and the source of the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorIsNotEqualToD_NN1	(	PlankD *	result,
		const PlankD *	a,
		PlankD	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsNotEqualToD() to an input vector and a scalar value.

This processes vector a and applies the function pl_IsNotEqualToD() to each item and the scalar value b and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a and the source of the left operand of the operation.
b	A scalar value and the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorIsNotEqualToD_NNN	(	PlankD *	result,
		const PlankD *	a,
		const PlankD *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsNotEqualToD() to each item in two input vectors.

This processes vectors a and b applying the function pl_IsNotEqualToD() to each of their items in turn and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a.
b	Input vector b.
N	The number of items in the input/output vectors.

static void pl_VectorIsNotEqualToF_N1N	(	PlankF *	result,
		PlankF	a,
		const PlankF *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsNotEqualToF() to an input vector and a scalar value.

This processes vector b and applies the function pl_IsNotEqualToF() to each item and the scalar value a and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	A scalar value and the left operand of the operation.
b	Input vector b and the source of the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorIsNotEqualToF_NN1	(	PlankF *	result,
		const PlankF *	a,
		PlankF	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsNotEqualToF() to an input vector and a scalar value.

This processes vector a and applies the function pl_IsNotEqualToF() to each item and the scalar value b and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a and the source of the left operand of the operation.
b	A scalar value and the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorIsNotEqualToF_NNN	(	PlankF *	result,
		const PlankF *	a,
		const PlankF *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsNotEqualToF() to each item in two input vectors.

This processes vectors a and b applying the function pl_IsNotEqualToF() to each of their items in turn and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a.
b	Input vector b.
N	The number of items in the input/output vectors.

static void pl_VectorIsNotEqualToI_N1N	(	PlankI *	result,
		PlankI	a,
		const PlankI *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsNotEqualToI() to an input vector and a scalar value.

This processes vector b and applies the function pl_IsNotEqualToI() to each item and the scalar value a and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	A scalar value and the left operand of the operation.
b	Input vector b and the source of the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorIsNotEqualToI_NN1	(	PlankI *	result,
		const PlankI *	a,
		PlankI	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsNotEqualToI() to an input vector and a scalar value.

This processes vector a and applies the function pl_IsNotEqualToI() to each item and the scalar value b and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a and the source of the left operand of the operation.
b	A scalar value and the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorIsNotEqualToI_NNN	(	PlankI *	result,
		const PlankI *	a,
		const PlankI *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsNotEqualToI() to each item in two input vectors.

This processes vectors a and b applying the function pl_IsNotEqualToI() to each of their items in turn and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a.
b	Input vector b.
N	The number of items in the input/output vectors.

static void pl_VectorIsNotEqualToLL_N1N	(	PlankLL *	result,
		PlankLL	a,
		const PlankLL *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsNotEqualToLL() to an input vector and a scalar value.

This processes vector b and applies the function pl_IsNotEqualToLL() to each item and the scalar value a and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	A scalar value and the left operand of the operation.
b	Input vector b and the source of the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorIsNotEqualToLL_NN1	(	PlankLL *	result,
		const PlankLL *	a,
		PlankLL	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsNotEqualToLL() to an input vector and a scalar value.

This processes vector a and applies the function pl_IsNotEqualToLL() to each item and the scalar value b and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a and the source of the left operand of the operation.
b	A scalar value and the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorIsNotEqualToLL_NNN	(	PlankLL *	result,
		const PlankLL *	a,
		const PlankLL *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsNotEqualToLL() to each item in two input vectors.

This processes vectors a and b applying the function pl_IsNotEqualToLL() to each of their items in turn and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a.
b	Input vector b.
N	The number of items in the input/output vectors.

static void pl_VectorIsNotEqualToS_N1N	(	PlankS *	result,
		PlankS	a,
		const PlankS *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsNotEqualToS() to an input vector and a scalar value.

This processes vector b and applies the function pl_IsNotEqualToS() to each item and the scalar value a and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	A scalar value and the left operand of the operation.
b	Input vector b and the source of the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorIsNotEqualToS_NN1	(	PlankS *	result,
		const PlankS *	a,
		PlankS	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsNotEqualToS() to an input vector and a scalar value.

This processes vector a and applies the function pl_IsNotEqualToS() to each item and the scalar value b and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a and the source of the left operand of the operation.
b	A scalar value and the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorIsNotEqualToS_NNN	(	PlankS *	result,
		const PlankS *	a,
		const PlankS *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_IsNotEqualToS() to each item in two input vectors.

This processes vectors a and b applying the function pl_IsNotEqualToS() to each of their items in turn and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a.
b	Input vector b.
N	The number of items in the input/output vectors.

static void pl_VectorLineD_N11	(	PlankD *	result,
		PlankD	a,
		PlankD	b,
		PlankUL	N
	)		`[inline, static]`

Fills a vector with a line.

The vector will start at value a and end at b.

static void pl_VectorLineF_N11	(	PlankF *	result,
		PlankF	a,
		PlankF	b,
		PlankUL	N
	)		`[inline, static]`

Fills a vector with a line.

The vector will start at value a and end at b.

static void pl_VectorLineI_N11	(	PlankI *	result,
		PlankI	a,
		PlankI	b,
		PlankUL	N
	)		`[inline, static]`

Fills a vector with a line.

The vector will start at value a and end at b.

static void pl_VectorLineLL_N11	(	PlankLL *	result,
		PlankLL	a,
		PlankLL	b,
		PlankUL	N
	)		`[inline, static]`

Fills a vector with a line.

The vector will start at value a and end at b.

static void pl_VectorLineS_N11	(	PlankS *	result,
		PlankS	a,
		PlankS	b,
		PlankUL	N
	)		`[inline, static]`

Fills a vector with a line.

The vector will start at value a and end at b.

static void pl_VectorLog10D_NN	(	PlankD *	result,
		const PlankD *	a,
		PlankUL	N
	)		`[inline, static]`

Applies the function pl_Log10D() to each item in a vector.

This processes vector a applying the function pl_Log10D() to each item and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	The input vector.
N	The number of items in the input/output vectors.

static void pl_VectorLog10F_NN	(	PlankF *	result,
		const PlankF *	a,
		PlankUL	N
	)		`[inline, static]`

Applies the function pl_Log10F() to each item in a vector.

This processes vector a applying the function pl_Log10F() to each item and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	The input vector.
N	The number of items in the input/output vectors.

static void pl_VectorLog2D_NN	(	PlankD *	result,
		const PlankD *	a,
		PlankUL	N
	)		`[inline, static]`

Applies the function pl_Log2D() to each item in a vector.

This processes vector a applying the function pl_Log2D() to each item and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	The input vector.
N	The number of items in the input/output vectors.

static void pl_VectorLog2F_NN	(	PlankF *	result,
		const PlankF *	a,
		PlankUL	N
	)		`[inline, static]`

Applies the function pl_Log2F() to each item in a vector.

This processes vector a applying the function pl_Log2F() to each item and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	The input vector.
N	The number of items in the input/output vectors.

static void pl_VectorLogD_NN	(	PlankD *	result,
		const PlankD *	a,
		PlankUL	N
	)		`[inline, static]`

Applies the function pl_LogD() to each item in a vector.

This processes vector a applying the function pl_LogD() to each item and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	The input vector.
N	The number of items in the input/output vectors.

static void pl_VectorLogF_NN	(	PlankF *	result,
		const PlankF *	a,
		PlankUL	N
	)		`[inline, static]`

Applies the function pl_LogF() to each item in a vector.

This processes vector a applying the function pl_LogF() to each item and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	The input vector.
N	The number of items in the input/output vectors.

static void pl_VectorLookupD_NnN	(	PlankD *	result,
		PlankD *	table,
		PlankUL	n,
		PlankD *	index,
		PlankUL	N
	)		`[inline, static]`

Generate a vector by using another vector as the indices into a lookup table.

Fractional indices are used to interpolate between value in the lookup table.

Parameters:

result	The output vectir
table	A look up table.
n	The size of the lookup table.
index	A vector containing the indices.
N	The size of the output and index vectors.

static void pl_VectorLookupF_NnN	(	PlankF *	result,
		PlankF *	table,
		PlankUL	n,
		PlankF *	index,
		PlankUL	N
	)		`[inline, static]`

Generate a vector by using another vector as the indices into a lookup table.

Fractional indices are used to interpolate between value in the lookup table.

Parameters:

result	The output vectir
table	A look up table.
n	The size of the lookup table.
index	A vector containing the indices.
N	The size of the output and index vectors.

static void pl_VectorLookupI_NnN	(	PlankI *	result,
		PlankI *	table,
		PlankUL	n,
		PlankI *	index,
		PlankUL	N
	)		`[inline, static]`

Generate a vector by using another vector as the indices into a lookup table.

Fractional indices are used to interpolate between value in the lookup table.

Parameters:

result	The output vectir
table	A look up table.
n	The size of the lookup table.
index	A vector containing the indices.
N	The size of the output and index vectors.

static void pl_VectorLookupLL_NnN	(	PlankLL *	result,
		PlankLL *	table,
		PlankUL	n,
		PlankLL *	index,
		PlankUL	N
	)		`[inline, static]`

Generate a vector by using another vector as the indices into a lookup table.

Fractional indices are used to interpolate between value in the lookup table.

Parameters:

result	The output vectir
table	A look up table.
n	The size of the lookup table.
index	A vector containing the indices.
N	The size of the output and index vectors.

static void pl_VectorLookupS_NnN	(	PlankS *	result,
		PlankS *	table,
		PlankUL	n,
		PlankS *	index,
		PlankUL	N
	)		`[inline, static]`

Generate a vector by using another vector as the indices into a lookup table.

Fractional indices are used to interpolate between value in the lookup table.

Parameters:

result	The output vectir
table	A look up table.
n	The size of the lookup table.
index	A vector containing the indices.
N	The size of the output and index vectors.

static void pl_VectorM2FD_NN	(	PlankD *	result,
		const PlankD *	a,
		PlankUL	N
	)		`[inline, static]`

Applies the function pl_M2FD() to each item in a vector.

This processes vector a applying the function pl_M2FD() to each item and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	The input vector.
N	The number of items in the input/output vectors.

static void pl_VectorM2FF_NN	(	PlankF *	result,
		const PlankF *	a,
		PlankUL	N
	)		`[inline, static]`

Applies the function pl_M2FF() to each item in a vector.

This processes vector a applying the function pl_M2FF() to each item and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	The input vector.
N	The number of items in the input/output vectors.

static void pl_VectorMaxD_N1N	(	PlankD *	result,
		PlankD	a,
		const PlankD *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_MaxD() to an input vector and a scalar value.

This processes vector b and applies the function pl_MaxD() to each item and the scalar value a and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	A scalar value and the left operand of the operation.
b	Input vector b and the source of the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorMaxD_NN1	(	PlankD *	result,
		const PlankD *	a,
		PlankD	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_MaxD() to an input vector and a scalar value.

This processes vector a and applies the function pl_MaxD() to each item and the scalar value b and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a and the source of the left operand of the operation.
b	A scalar value and the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorMaxD_NNN	(	PlankD *	result,
		const PlankD *	a,
		const PlankD *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_MaxD() to each item in two input vectors.

This processes vectors a and b applying the function pl_MaxD() to each of their items in turn and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a.
b	Input vector b.
N	The number of items in the input/output vectors.

static void pl_VectorMaxF_N1N	(	PlankF *	result,
		PlankF	a,
		const PlankF *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_MaxF() to an input vector and a scalar value.

This processes vector b and applies the function pl_MaxF() to each item and the scalar value a and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	A scalar value and the left operand of the operation.
b	Input vector b and the source of the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorMaxF_NN1	(	PlankF *	result,
		const PlankF *	a,
		PlankF	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_MaxF() to an input vector and a scalar value.

This processes vector a and applies the function pl_MaxF() to each item and the scalar value b and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a and the source of the left operand of the operation.
b	A scalar value and the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorMaxF_NNN	(	PlankF *	result,
		const PlankF *	a,
		const PlankF *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_MaxF() to each item in two input vectors.

This processes vectors a and b applying the function pl_MaxF() to each of their items in turn and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a.
b	Input vector b.
N	The number of items in the input/output vectors.

static void pl_VectorMaxI_N1N	(	PlankI *	result,
		PlankI	a,
		const PlankI *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_MaxI() to an input vector and a scalar value.

This processes vector b and applies the function pl_MaxI() to each item and the scalar value a and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	A scalar value and the left operand of the operation.
b	Input vector b and the source of the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorMaxI_NN1	(	PlankI *	result,
		const PlankI *	a,
		PlankI	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_MaxI() to an input vector and a scalar value.

This processes vector a and applies the function pl_MaxI() to each item and the scalar value b and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a and the source of the left operand of the operation.
b	A scalar value and the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorMaxI_NNN	(	PlankI *	result,
		const PlankI *	a,
		const PlankI *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_MaxI() to each item in two input vectors.

This processes vectors a and b applying the function pl_MaxI() to each of their items in turn and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a.
b	Input vector b.
N	The number of items in the input/output vectors.

static void pl_VectorMaxLL_N1N	(	PlankLL *	result,
		PlankLL	a,
		const PlankLL *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_MaxLL() to an input vector and a scalar value.

This processes vector b and applies the function pl_MaxLL() to each item and the scalar value a and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	A scalar value and the left operand of the operation.
b	Input vector b and the source of the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorMaxLL_NN1	(	PlankLL *	result,
		const PlankLL *	a,
		PlankLL	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_MaxLL() to an input vector and a scalar value.

This processes vector a and applies the function pl_MaxLL() to each item and the scalar value b and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a and the source of the left operand of the operation.
b	A scalar value and the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorMaxLL_NNN	(	PlankLL *	result,
		const PlankLL *	a,
		const PlankLL *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_MaxLL() to each item in two input vectors.

This processes vectors a and b applying the function pl_MaxLL() to each of their items in turn and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a.
b	Input vector b.
N	The number of items in the input/output vectors.

static void pl_VectorMaxS_N1N	(	PlankS *	result,
		PlankS	a,
		const PlankS *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_MaxS() to an input vector and a scalar value.

This processes vector b and applies the function pl_MaxS() to each item and the scalar value a and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	A scalar value and the left operand of the operation.
b	Input vector b and the source of the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorMaxS_NN1	(	PlankS *	result,
		const PlankS *	a,
		PlankS	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_MaxS() to an input vector and a scalar value.

This processes vector a and applies the function pl_MaxS() to each item and the scalar value b and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a and the source of the left operand of the operation.
b	A scalar value and the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorMaxS_NNN	(	PlankS *	result,
		const PlankS *	a,
		const PlankS *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_MaxS() to each item in two input vectors.

This processes vectors a and b applying the function pl_MaxS() to each of their items in turn and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a.
b	Input vector b.
N	The number of items in the input/output vectors.

static void pl_VectorMinD_N1N	(	PlankD *	result,
		PlankD	a,
		const PlankD *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_MinD() to an input vector and a scalar value.

This processes vector b and applies the function pl_MinD() to each item and the scalar value a and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	A scalar value and the left operand of the operation.
b	Input vector b and the source of the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorMinD_NN1	(	PlankD *	result,
		const PlankD *	a,
		PlankD	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_MinD() to an input vector and a scalar value.

This processes vector a and applies the function pl_MinD() to each item and the scalar value b and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a and the source of the left operand of the operation.
b	A scalar value and the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorMinD_NNN	(	PlankD *	result,
		const PlankD *	a,
		const PlankD *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_MinD() to each item in two input vectors.

This processes vectors a and b applying the function pl_MinD() to each of their items in turn and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a.
b	Input vector b.
N	The number of items in the input/output vectors.

static void pl_VectorMinF_N1N	(	PlankF *	result,
		PlankF	a,
		const PlankF *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_MinF() to an input vector and a scalar value.

This processes vector b and applies the function pl_MinF() to each item and the scalar value a and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	A scalar value and the left operand of the operation.
b	Input vector b and the source of the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorMinF_NN1	(	PlankF *	result,
		const PlankF *	a,
		PlankF	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_MinF() to an input vector and a scalar value.

This processes vector a and applies the function pl_MinF() to each item and the scalar value b and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a and the source of the left operand of the operation.
b	A scalar value and the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorMinF_NNN	(	PlankF *	result,
		const PlankF *	a,
		const PlankF *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_MinF() to each item in two input vectors.

This processes vectors a and b applying the function pl_MinF() to each of their items in turn and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a.
b	Input vector b.
N	The number of items in the input/output vectors.

static void pl_VectorMinI_N1N	(	PlankI *	result,
		PlankI	a,
		const PlankI *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_MinI() to an input vector and a scalar value.

This processes vector b and applies the function pl_MinI() to each item and the scalar value a and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	A scalar value and the left operand of the operation.
b	Input vector b and the source of the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorMinI_NN1	(	PlankI *	result,
		const PlankI *	a,
		PlankI	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_MinI() to an input vector and a scalar value.

This processes vector a and applies the function pl_MinI() to each item and the scalar value b and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a and the source of the left operand of the operation.
b	A scalar value and the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorMinI_NNN	(	PlankI *	result,
		const PlankI *	a,
		const PlankI *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_MinI() to each item in two input vectors.

This processes vectors a and b applying the function pl_MinI() to each of their items in turn and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a.
b	Input vector b.
N	The number of items in the input/output vectors.

static void pl_VectorMinLL_N1N	(	PlankLL *	result,
		PlankLL	a,
		const PlankLL *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_MinLL() to an input vector and a scalar value.

This processes vector b and applies the function pl_MinLL() to each item and the scalar value a and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	A scalar value and the left operand of the operation.
b	Input vector b and the source of the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorMinLL_NN1	(	PlankLL *	result,
		const PlankLL *	a,
		PlankLL	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_MinLL() to an input vector and a scalar value.

This processes vector a and applies the function pl_MinLL() to each item and the scalar value b and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a and the source of the left operand of the operation.
b	A scalar value and the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorMinLL_NNN	(	PlankLL *	result,
		const PlankLL *	a,
		const PlankLL *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_MinLL() to each item in two input vectors.

This processes vectors a and b applying the function pl_MinLL() to each of their items in turn and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a.
b	Input vector b.
N	The number of items in the input/output vectors.

static void pl_VectorMinS_N1N	(	PlankS *	result,
		PlankS	a,
		const PlankS *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_MinS() to an input vector and a scalar value.

This processes vector b and applies the function pl_MinS() to each item and the scalar value a and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	A scalar value and the left operand of the operation.
b	Input vector b and the source of the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorMinS_NN1	(	PlankS *	result,
		const PlankS *	a,
		PlankS	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_MinS() to an input vector and a scalar value.

This processes vector a and applies the function pl_MinS() to each item and the scalar value b and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a and the source of the left operand of the operation.
b	A scalar value and the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorMinS_NNN	(	PlankS *	result,
		const PlankS *	a,
		const PlankS *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_MinS() to each item in two input vectors.

This processes vectors a and b applying the function pl_MinS() to each of their items in turn and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a.
b	Input vector b.
N	The number of items in the input/output vectors.

static void pl_VectorModD_N1N	(	PlankD *	result,
		PlankD	a,
		const PlankD *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_ModD() to an input vector and a scalar value.

This processes vector b and applies the function pl_ModD() to each item and the scalar value a and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	A scalar value and the left operand of the operation.
b	Input vector b and the source of the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorModD_NN1	(	PlankD *	result,
		const PlankD *	a,
		PlankD	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_ModD() to an input vector and a scalar value.

This processes vector a and applies the function pl_ModD() to each item and the scalar value b and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a and the source of the left operand of the operation.
b	A scalar value and the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorModD_NNN	(	PlankD *	result,
		const PlankD *	a,
		const PlankD *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_ModD() to each item in two input vectors.

This processes vectors a and b applying the function pl_ModD() to each of their items in turn and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a.
b	Input vector b.
N	The number of items in the input/output vectors.

static void pl_VectorModF_N1N	(	PlankF *	result,
		PlankF	a,
		const PlankF *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_ModF() to an input vector and a scalar value.

This processes vector b and applies the function pl_ModF() to each item and the scalar value a and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	A scalar value and the left operand of the operation.
b	Input vector b and the source of the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorModF_NN1	(	PlankF *	result,
		const PlankF *	a,
		PlankF	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_ModF() to an input vector and a scalar value.

This processes vector a and applies the function pl_ModF() to each item and the scalar value b and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a and the source of the left operand of the operation.
b	A scalar value and the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorModF_NNN	(	PlankF *	result,
		const PlankF *	a,
		const PlankF *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_ModF() to each item in two input vectors.

This processes vectors a and b applying the function pl_ModF() to each of their items in turn and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a.
b	Input vector b.
N	The number of items in the input/output vectors.

static void pl_VectorModI_N1N	(	PlankI *	result,
		PlankI	a,
		const PlankI *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_ModI() to an input vector and a scalar value.

This processes vector b and applies the function pl_ModI() to each item and the scalar value a and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	A scalar value and the left operand of the operation.
b	Input vector b and the source of the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorModI_NN1	(	PlankI *	result,
		const PlankI *	a,
		PlankI	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_ModI() to an input vector and a scalar value.

This processes vector a and applies the function pl_ModI() to each item and the scalar value b and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a and the source of the left operand of the operation.
b	A scalar value and the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorModI_NNN	(	PlankI *	result,
		const PlankI *	a,
		const PlankI *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_ModI() to each item in two input vectors.

This processes vectors a and b applying the function pl_ModI() to each of their items in turn and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a.
b	Input vector b.
N	The number of items in the input/output vectors.

static void pl_VectorModLL_N1N	(	PlankLL *	result,
		PlankLL	a,
		const PlankLL *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_ModLL() to an input vector and a scalar value.

This processes vector b and applies the function pl_ModLL() to each item and the scalar value a and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	A scalar value and the left operand of the operation.
b	Input vector b and the source of the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorModLL_NN1	(	PlankLL *	result,
		const PlankLL *	a,
		PlankLL	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_ModLL() to an input vector and a scalar value.

This processes vector a and applies the function pl_ModLL() to each item and the scalar value b and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a and the source of the left operand of the operation.
b	A scalar value and the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorModLL_NNN	(	PlankLL *	result,
		const PlankLL *	a,
		const PlankLL *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_ModLL() to each item in two input vectors.

This processes vectors a and b applying the function pl_ModLL() to each of their items in turn and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a.
b	Input vector b.
N	The number of items in the input/output vectors.

static void pl_VectorModS_N1N	(	PlankS *	result,
		PlankS	a,
		const PlankS *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_ModS() to an input vector and a scalar value.

This processes vector b and applies the function pl_ModS() to each item and the scalar value a and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	A scalar value and the left operand of the operation.
b	Input vector b and the source of the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorModS_NN1	(	PlankS *	result,
		const PlankS *	a,
		PlankS	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_ModS() to an input vector and a scalar value.

This processes vector a and applies the function pl_ModS() to each item and the scalar value b and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a and the source of the left operand of the operation.
b	A scalar value and the right operand of the operation.
N	The number of items in the input/output vectors.

static void pl_VectorModS_NNN	(	PlankS *	result,
		const PlankS *	a,
		const PlankS *	b,
		PlankUL	N
	)		`[inline, static]`

Applies the binary operator function pl_ModS() to each item in two input vectors.

This processes vectors a and b applying the function pl_ModS() to each of their items in turn and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	Input vector a.
b	Input vector b.
N	The number of items in the input/output vectors.

static void pl_VectorMoveD_NN	(	PlankD *	result,
		const PlankD *	a,
		PlankUL	N
	)		`[inline, static]`

Applies the function pl_MoveD() to each item in a vector.

This processes vector a applying the function pl_MoveD() to each item and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	The input vector.
N	The number of items in the input/output vectors.

static void pl_VectorMoveF_NN	(	PlankF *	result,
		const PlankF *	a,
		PlankUL	N
	)		`[inline, static]`

Applies the function pl_MoveF() to each item in a vector.

This processes vector a applying the function pl_MoveF() to each item and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	The input vector.
N	The number of items in the input/output vectors.

static void pl_VectorMoveI_NN	(	PlankI *	result,
		const PlankI *	a,
		PlankUL	N
	)		`[inline, static]`

Applies the function pl_MoveI() to each item in a vector.

This processes vector a applying the function pl_MoveI() to each item and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	The input vector.
N	The number of items in the input/output vectors.

static void pl_VectorMoveLL_NN	(	PlankLL *	result,
		const PlankLL *	a,
		PlankUL	N
	)		`[inline, static]`

Applies the function pl_MoveLL() to each item in a vector.

This processes vector a applying the function pl_MoveLL() to each item and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	The input vector.
N	The number of items in the input/output vectors.

static void pl_VectorMoveS_NN	(	PlankS *	result,
		const PlankS *	a,
		PlankUL	N
	)		`[inline, static]`

Applies the function pl_MoveS() to each item in a vector.

This processes vector a applying the function pl_MoveS() to each item and returns the result in the vector result.

Parameters:

result	The output vector is placed here.
a	The input vector.
N	The number of items in the input/output vectors.

static void pl_VectorMulAddD_NN11	(	PlankD *	result,
		const PlankD *	input,
		PlankD	mul,
		PlankD	add,
		PlankUL	N
	)		`[inline, static]`