libcm/src/vop/cmVectOpsTemplateHdr.h

//( { label:misc desc:"Miscellaneous vector operations." kw:[vop] }

// Compute the cummulative sum of sbp[dn]. Equivalent to Matlab cumsum().
VECT_OP_TYPE* VECT_OP_FUNC(CumSum)(VECT_OP_TYPE* dbp, unsigned dn, const VECT_OP_TYPE* sbp ); 

// Returns true if all values in each vector are equal.
bool          VECT_OP_FUNC(Equal)(    const VECT_OP_TYPE* s0p, const VECT_OP_TYPE* s1p, unsigned sn );

// Same as Matlab linspace() v[i] = i * (limit-1)/n
VECT_OP_TYPE*  VECT_OP_FUNC(LinSpace)( VECT_OP_TYPE* dbp, unsigned dn, VECT_OP_TYPE base, VECT_OP_TYPE limit );

//======================================================================================================================
//)


//( { label:Print desc:"Vector printing functions." kw:[vop] }
// Setting fieldWidth or decPltCnt to to negative values result in fieldWidth == 10 or decPlCnt == 4
//
void          VECT_OP_FUNC(Printf)( cmRpt_t* rpt, unsigned rn, unsigned cn, const VECT_OP_TYPE* dbp, int fieldWidth, int decPlCnt, const char* fmt, unsigned flags );
void          VECT_OP_FUNC(Print)(  cmRpt_t* rpt, unsigned rn, unsigned cn, const VECT_OP_TYPE* dbp );
void          VECT_OP_FUNC(PrintE)( cmRpt_t* rpt, unsigned rn, unsigned cn, const VECT_OP_TYPE* dbp );

void          VECT_OP_FUNC(PrintLf)( const char* label, cmRpt_t* rpt, unsigned rn, unsigned cn, const VECT_OP_TYPE* dbp, unsigned fieldWidth, unsigned decPlCnt, const char* fmt );
void          VECT_OP_FUNC(PrintL)(  const char* label, cmRpt_t* rpt, unsigned rn, unsigned cn, const VECT_OP_TYPE* dbp );
void          VECT_OP_FUNC(PrintLE)( const char* label, cmRpt_t* rpt, unsigned rn, unsigned cn, const VECT_OP_TYPE* dbp );
//======================================================================================================================
//)


//( { label:Normalization desc:"Normalization and standardization functions." kw:[vop] }

// Normalize the vector of proabilities by dividing through by the sum.
// This leaves the relative proportions of each value unchanged while producing a total probability of 1.0.
//
VECT_OP_TYPE* VECT_OP_FUNC(NormalizeProbabilityVV)(VECT_OP_TYPE* dbp, unsigned dn, const VECT_OP_TYPE* sbp);
VECT_OP_TYPE* VECT_OP_FUNC(NormalizeProbability)(VECT_OP_TYPE* dbp, unsigned dn);
VECT_OP_TYPE* VECT_OP_FUNC(NormalizeProbabilityN)(VECT_OP_TYPE* dbp, unsigned dn, unsigned stride);
//
// Standardize the columns of the matrix by subtracting the mean and dividing by the standard deviation.
// uV[dcn] returns the mean of the data and is optional.
// sdV[dcn] return the standard deviation of the data and is optional.
VECT_OP_TYPE* VECT_OP_FUNC(StandardizeRows)( VECT_OP_TYPE* dbp, unsigned drn, unsigned dcn, VECT_OP_TYPE* uV, VECT_OP_TYPE* sdV );
VECT_OP_TYPE* VECT_OP_FUNC(StandardizeCols)( VECT_OP_TYPE* dbp, unsigned drn, unsigned dcn, VECT_OP_TYPE* uV, VECT_OP_TYPE* sdV );
//
// Normalize by dividing through by the max. value.
// dp[] ./= max(dp). Returns the index of the max value.
unsigned  VECT_OP_FUNC(NormToMax)(    VECT_OP_TYPE* dp, unsigned dn );
//
// Normalize by dividing through by the max. absolute value.
// db[] .*= fact / abs(max(dp));
unsigned VECT_OP_FUNC(NormToAbsMax)(   VECT_OP_TYPE* dp, unsigned dn, VECT_OP_TYPE fact );
//======================================================================================================================
//)


//( { label:"Mean and variance" desc:"Compute mean and variance." kw:[vop] }

VECT_OP_TYPE  VECT_OP_FUNC(Mean)(     const VECT_OP_TYPE* sp, unsigned sn );
VECT_OP_TYPE  VECT_OP_FUNC(MeanN)(    const VECT_OP_TYPE* sp, unsigned sn, unsigned stride  );
//
// Take the mean of each column/row of a matrix.
// Set 'dim' to 0 to return mean of columns else return mean of rows.
VECT_OP_TYPE*  VECT_OP_FUNC(MeanM)(    VECT_OP_TYPE* dp, const VECT_OP_TYPE* sp, unsigned srn, unsigned scn, unsigned dim );
//
// Take the mean of the first 'cnt' element of each column/row of a matrix.
// Set 'dim' to 0 to return mean of columns else return mean of rows.
// If 'cnt' is greater than the number of elements in the column/row then 'cnt' is
// reduced to the number of elements in the column/row.
VECT_OP_TYPE*  VECT_OP_FUNC(MeanM2)(    VECT_OP_TYPE* dp, const VECT_OP_TYPE* sp, unsigned srn, unsigned scn, unsigned dim, unsigned cnt );
//
// Find the mean of the  data points returned by srcFuncPtr(argPtr,i) and return it in dp[dim].
// 'dim' is both the size of dp[] and the length of each data point returned by srcFuncPtr().
// srcFuncPtr() will be called 'cnt' times but it may return NULL on some calls if the associated
// data point should not be included in the mean calculation.
VECT_OP_TYPE*  VECT_OP_FUNC(Mean2)(   VECT_OP_TYPE* dp, const VECT_OP_TYPE* (*srcFuncPtr)(void* arg, unsigned idx ), unsigned dim, unsigned cnt, void* argPtr );
//
// avgPtr is optional - set to NULL to compute the average
VECT_OP_TYPE  VECT_OP_FUNC(Variance)( const VECT_OP_TYPE* sp, unsigned sn, const VECT_OP_TYPE* avgPtr );
VECT_OP_TYPE  VECT_OP_FUNC(VarianceN)(const VECT_OP_TYPE* sp, unsigned sn, unsigned stride, const VECT_OP_TYPE* avgPtr );
//
// Set dim=0 to return variance of columns otherwise return variance or rows.
VECT_OP_TYPE*  VECT_OP_FUNC(VarianceM)(VECT_OP_TYPE* dp,  const VECT_OP_TYPE* sp, unsigned srn, unsigned scn, const VECT_OP_TYPE* avgPtr, unsigned dim );
//======================================================================================================================
//)


//( { label:"Covariance" desc:"Matrix covariance" kw:[vop] }

// Calculate the sample covariance matrix from a set of Gaussian distributed multidimensional data.
// sp[dn,scn] is the data set.
// dn is the dimensionality of the data.
// scn is the count of data points
// up[dn] is an optional mean vector. If up == NULL then the mean of the data is calculated internally. 
// selIdxV[scn] can be used to select a subset of datapoints to process.
// If selIdxV[] is non-NULL then only columns where selIdxV[i]==selKey will be processed.
//
// dp[dn,dn] = covar( sp[dn,scn], u[dn] )
void  VECT_OP_FUNC(GaussCovariance)(VECT_OP_TYPE* dp, unsigned dn, const VECT_OP_TYPE* sp, unsigned scn, const VECT_OP_TYPE* up, const unsigned* selIdxV, unsigned selKey );

// Calculate the sample covariance matrix.
// dp[ dn*dn ] - output matrix
// dn - dimensionality of the data
// srcFuncPtr - User defined function which is called to return a pointer to a data vector at index 'idx'.
//          The returned data vector must contain 'dn' elements.  The function should return NULL
//          if the data point associated with 'idx' should not be included in the covariance calculation.
// sn - count of data vectors 
// userPtr - User arg. passed to srcFuncPtr.    
// uV[ dn ] - mean of the data set (optional)
// Note that this function computes the covariance matrix in 2 serial passes (1 if the mean vector is given)
// through the 'sn' data points.  
// The result of this function are identical to the octave cov() function.
void  VECT_OP_FUNC(GaussCovariance2)(VECT_OP_TYPE* dp, unsigned dn, const VECT_OP_TYPE* (*srcFuncPtr)(void* userPtr, unsigned idx), unsigned sn, void* userPtr, const VECT_OP_TYPE* uV, const unsigned* selIdxV, unsigned selKey );
//======================================================================================================================
//)

//( { label:"Float point normal" desc:"Evaluate the 'normalness of floating point values." kw:[vop] }

// Returns true if all values are 'normal' according the the C macro 'isnormal'.
// This function will return false if any of the values are zero.
bool          VECT_OP_FUNC(IsNormal)( const VECT_OP_TYPE* sp, unsigned sn );

// Returns true if all values are 'normal' or zero according the the C macro 'isnormal'.
// This function accepts zeros as normal.
bool          VECT_OP_FUNC(IsNormalZ)(const VECT_OP_TYPE* sp, unsigned sn );

// Set dp[dn] to the indexes of the non-normal numbers in sp[dn].
// Returns the count of indexes stored in dp[].
unsigned      VECT_OP_FUNC(FindNonNormal)( unsigned* dp, unsigned dn, const VECT_OP_TYPE* sp );
unsigned      VECT_OP_FUNC(FindNonNormalZ)( unsigned* dp, unsigned dn, const VECT_OP_TYPE* sp );
//======================================================================================================================
//)


//( { label:"Measure" desc:"Measure features of a vector." kw:[vop] }

// Successive call to to ZeroCrossCount should preserve the value pointed to by delaySmpPtr.
unsigned      VECT_OP_FUNC(ZeroCrossCount)( const VECT_OP_TYPE* sp, unsigned n, VECT_OP_TYPE* delaySmpPtr);

// Calculuate the sum of the squares of all elements in bp[bn]. 
VECT_OP_TYPE VECT_OP_FUNC(SquaredSum)( const VECT_OP_TYPE* bp, unsigned bn );

// sn must be <= wndSmpCnt. If sn < wndSmpCnt then sp[sn] is treated as a
// a partially filled buffer padded with wndSmpCnt-sn zeros.
// rms = sqrt( sum(sp[1:sn] .* sp[1:sn]) / wndSmpCnt )
VECT_OP_TYPE  VECT_OP_FUNC(RMS)( const VECT_OP_TYPE* sp, unsigned sn, unsigned wndSmpCnt );

// This function handles the case were sn is not an integer multiple of 
// wndSmpCnt or hopSmpCnt.  In this case the function computes zero 
// padded RMS values for windows which go past the end of sp[sn].
VECT_OP_TYPE* VECT_OP_FUNC(RmsV)( VECT_OP_TYPE* dp, unsigned dn, const VECT_OP_TYPE* sp, unsigned sn, unsigned wndSmpCnt, unsigned hopSmpCnt );

// Return the magnitude (Euclidean Norm) of a vector.
VECT_OP_TYPE  VECT_OP_FUNC(EuclidNorm)( const VECT_OP_TYPE* sp, unsigned sn );

VECT_OP_TYPE  VECT_OP_FUNC(AlphaNorm)(const VECT_OP_TYPE* sp, unsigned sn, VECT_OP_TYPE alpha );

//======================================================================================================================
//)



//( { label:"Distance" desc:"Calculate various vector distances." kw:[vop] }

// Return the Itakura-Saito distance between a modelled power spectrum (up) and another power spectrum (sp).
VECT_OP_TYPE VECT_OP_FUNC(ItakuraDistance)( const VECT_OP_TYPE* up, const VECT_OP_TYPE* sp, unsigned sn );

// Return the cosine distance between two vectors.
VECT_OP_TYPE  VECT_OP_FUNC(CosineDistance)( const VECT_OP_TYPE* s0P, const VECT_OP_TYPE* s1p, unsigned sn );

// Return the Euclidean distance between two vectors
VECT_OP_TYPE  VECT_OP_FUNC(EuclidDistance)( const VECT_OP_TYPE* s0p, const VECT_OP_TYPE* s1p, unsigned sn );

// Return the Manhattan distance between two vectors
VECT_OP_TYPE  VECT_OP_FUNC(L1Distance)( const VECT_OP_TYPE* s0p, const VECT_OP_TYPE* s1p, unsigned sn );

// Return the Mahalanobis distance between a vector and the mean of the distribution.
// The mean vector could be replaced with another vector drawn from the same distribution in which
// case the returned value would reflect the distance between the two vectors.
// 'sn' is the dimensionality of the data.
// up[D] and invCovM[sn,sn] are the mean and inverse of the covariance matrix of the distribution from 
// which sp[D] is drawn. 
VECT_OP_TYPE  VECT_OP_FUNC(MahalanobisDistance)( const VECT_OP_TYPE* sp, unsigned sn, const VECT_OP_TYPE* up, const VECT_OP_TYPE* invCovM );

// Return the KL distance between two probability distributions up[sn] and sp[sn].
// Since up[] and sp[] are probability distributions they must sum to 1.0.
VECT_OP_TYPE VECT_OP_FUNC(KL_Distance)( const VECT_OP_TYPE* up, const VECT_OP_TYPE* sp, unsigned sn );

// Return the KL distance between a prototype vector up[sn] and another vector sp[sn].
// This function first normalizes the two vectors to sum to 1.0 before calling
// VECT_OP_FUNC(KL_Distance)(up,sp,sn);
VECT_OP_TYPE VECT_OP_FUNC(KL_Distance2)( const VECT_OP_TYPE* up, const VECT_OP_TYPE* sp, unsigned sn );


// Measure the Euclidean distance between a vector and all the columns in a matrix.
// If dv[scn] is no NULL then return the Euclidean distance from sv[scn] to each column of sm[srn,scn].
// The function returns the index of the closest data point (column) in sm[].
unsigned VECT_OP_FUNC(EuclidDistanceVM)( VECT_OP_TYPE* dv, const VECT_OP_TYPE* sv, const VECT_OP_TYPE* sm, unsigned srn, unsigned scn );

// Measure the distance between each column in s0M[ rn, s0cn ] and 
// each column in s1M[rn, s1cn ]. If dM is non-NULL store the 
// result in dM[s1cn, s0cn]. The difference between s0M[:,0] and s1M[:,0] 
// is stored in dM[0,0], the diff. between s0M[:,1] and s1M[:,1] is stored 
// in dM[1,0], etc.  If mvV[s0cn] is non-NULL then  minV[i] is set with
// the distance from s0M[:,i] to the nearest column in s1M[]. If miV[s0cn]
// is non-NULL then it is set with the column index of s1M[] which is
// closest to s0M[:,i].  In other words mvV[i] gives the distance to column
// miV[i] from column s0M[:,i].
// In those cases where the distane from a prototype (centroid) to the data point
// is not the same as from the data point to the centroid then s1M[] is considered
// to hold the prototypes and s0M[] is considered to hold the data points.
// The distance function returns the distance from a prototype 'cV[dimN]' to
// an datapoint dV[dimN]. 'dimN' is the dimensionality of the data vector
// and is threfore equal to 'rn'.
void VECT_OP_FUNC(DistVMM)( 
  VECT_OP_TYPE*       dM,    // dM[s1cn,s0cn] return distance mtx (optional) 
  VECT_OP_TYPE*       mvV,   // mvV[s0cn] distance to closest data point in s0M[]. (optional)
  unsigned*           miV,   // miV[s0cn] column index into s1M[] of closest data point to s0M[:,i]. (optional)
  unsigned            rn,    // dimensionality of the data and the row count for s0M[] and s1M[] 
  const VECT_OP_TYPE* s0M,   // s0M[rn,s0cn] contains one data point per column
  unsigned            s0cn,  // count of data points (count of columns in s0M[]
  const VECT_OP_TYPE* s1M,   // s1M[rn,s1cn] contains one prototype per column
  unsigned            s1cn,  // count of prototypes (count of columns in s1m[]
  VECT_OP_TYPE (*distFunc)( void* userPtr, const VECT_OP_TYPE* cV, const VECT_OP_TYPE* dV, unsigned dimN ), 
  void*               userPtr );

//======================================================================================================================
//)

//( { label:"Select columns" desc:"Select columns based on distance." kw:[vop] }

// Select 'selIdxN' columns from sM[srn,scn].
// dM[srn,selIdxN] receives copies of the selected columns.
// selIdxV[selIdxN] receives the column indexes of the selected columns.
// Both dM[] and selIdxV[] are optional.
// In each case the first selected point is chosen at random.
// SelectRandom() then selects the following selIdxN-1 points at random.
// SelectMaxDist() selects the next selIdxN-1 points by selecting 
// the point whose combined distance to the previously selected points
// is greatest. SelectMaxAvgDist() selectes the points whose combined
// average distance is greatest relative the the previously selected
// points.
void VECT_OP_FUNC(SelectRandom)(     VECT_OP_TYPE* dM, unsigned* selIdxV, unsigned selIdxN, const VECT_OP_TYPE* sM, unsigned srn, unsigned scn );
void VECT_OP_FUNC(SelectMaxDist)(    VECT_OP_TYPE* dM, unsigned* selIdxV, unsigned selIdxN, const VECT_OP_TYPE* sM, unsigned srn, unsigned scn, VECT_OP_TYPE (*distFunc)( void* userPtr, const VECT_OP_TYPE* s0V, const VECT_OP_TYPE* s1V, unsigned sn ), void* distUserPtr );
void VECT_OP_FUNC(SelectMaxAvgDist)( VECT_OP_TYPE* dM, unsigned* selIdxV, unsigned selIdxN, const VECT_OP_TYPE* sM, unsigned srn, unsigned scn, VECT_OP_TYPE (*distFunc)( void* userPtr, const VECT_OP_TYPE* s0V, const VECT_OP_TYPE* s1V, unsigned sn ), void* distUserPtr ); 

//======================================================================================================================
//)

//( { label:"Matrix multiplication" desc:"Various matrix multiplication operations." kw:[vop] }

// Return the sum of the products (dot product)
VECT_OP_TYPE VECT_OP_FUNC(MultSumVV)(  const VECT_OP_TYPE* s0p, const VECT_OP_TYPE* s1p, unsigned sn  );
VECT_OP_TYPE VECT_OP_FUNC(MultSumVS)(  const VECT_OP_TYPE* s0p, unsigned sn, VECT_OP_TYPE s );

// Number of elements in the dest vector is expected to be the same 
// as the number of source matrix rows.
// mcn gives the number of columns in the source matrix which is 
//  expected to match the number of elements in the source vector.
// dbp[dn,1] = mp[dn,mcn] * vp[mcn,1] 
VECT_OP_TYPE* VECT_OP_FUNC(MultVMV)( VECT_OP_TYPE* dbp, unsigned dn, const VECT_OP_TYPE* mp, unsigned mcn, const VECT_OP_TYPE* vp ); 

// Multiply a row vector with a matrix to produce a row vector. 
// dbp[1,dn] = v[1,vn] * m[vn,dn]
VECT_OP_TYPE* VECT_OP_FUNC(MultVVM)( VECT_OP_TYPE* dbp, unsigned dn, const VECT_OP_TYPE* vp, unsigned vn, const VECT_OP_TYPE* mp ); 

// Same as MultVMtV() except M is transposed as part of the multiply.  
// mrn gives the number of rows in m[] and number of elements in vp[]
// dpb[dn] = mp[mrn,dn] * vp[mrn]
VECT_OP_TYPE* VECT_OP_FUNC(MultVMtV)( VECT_OP_TYPE* dbp, unsigned dn, const VECT_OP_TYPE* mp, unsigned mrn, const VECT_OP_TYPE* vp ); 

// Same as MultVMV() but where the matrix is diagonal.
VECT_OP_TYPE* VECT_OP_FUNC(MultDiagVMV)( VECT_OP_TYPE* dbp, unsigned dn, const VECT_OP_TYPE* mp, unsigned mcn, const VECT_OP_TYPE* vp ); 

// Generalized matrix multiply.
// If transposition is selected for M0 or M1 then the given dimension represent the size of the matrix 'after' the transposion. 
// d[drn,dcn] = alpha * op(m0[drn,m0cn_m1rn]) * op(m1[m0cn_m1rn,dcn]) + beta * d[drn,dcn]
/// See enum { kTranpsoseM0Fl=0x01, kTransposeM1Fl=0x02 } in cmVectOps for flags.
VECT_OP_TYPE* VECT_OP_FUNC(MultMMM1)(VECT_OP_TYPE* dbp, unsigned drn, unsigned dcn, VECT_OP_TYPE alpha, const VECT_OP_TYPE* m0, const VECT_OP_TYPE* m1, unsigned m0cn_m1rn, VECT_OP_TYPE beta, unsigned flags );

// Same a VECT_OP_FUNC(MultMMM1) except allows the operation on a sub-matrix by providing the physical (memory) row count rather than the logical (matrix) row count.
VECT_OP_TYPE* VECT_OP_FUNC(MultMMM2)(VECT_OP_TYPE* dbp, unsigned drn, unsigned dcn, VECT_OP_TYPE alpha, const VECT_OP_TYPE* m0, const VECT_OP_TYPE* m1, unsigned m0cn_m1rn, VECT_OP_TYPE beta, unsigned flags, unsigned dprn, unsigned m0prn, unsigned m1prn );

// d[drn,dcn] = m0[drn,m0cn] * m1[m1rn,dcn] 
VECT_OP_TYPE* VECT_OP_FUNC(MultMMM)( VECT_OP_TYPE* dbp, unsigned drn, unsigned dcn, const VECT_OP_TYPE* m0, const VECT_OP_TYPE* m1, unsigned m0cn_m1rn );

// same as MultMMM() except second source matrix is transposed prior to the multiply
VECT_OP_TYPE* VECT_OP_FUNC(MultMMMt)(VECT_OP_TYPE* dbp, unsigned drn, unsigned dcn, const VECT_OP_TYPE* m0, const VECT_OP_TYPE* m1, unsigned m0cn_m1rn );

//======================================================================================================================
//)

//( { label:"Linear algebra" desc:"Miscellaneous linear algebra operations. Determinant, Inversion, Cholesky decompostion. Linear system solver." kw:[vop] }

// Initialize dbp[dn,dn] as a square symetric positive definite matrix using values
// from a random uniform distribution. This is useful for initializing random 
// covariance matrices as used by multivariate Gaussian distributions
// If t is non-NULL it must point to a block of scratch memory of t[dn,dn].
// If t is NULL then scratch memory is internally allocated and deallocated.
VECT_OP_TYPE* VECT_OP_FUNC(RandSymPosDef)( VECT_OP_TYPE* dbp, unsigned dn, VECT_OP_TYPE* t );


// Compute the determinant of any square matrix.
VECT_OP_TYPE  VECT_OP_FUNC(DetM)(    const VECT_OP_TYPE* sp, unsigned srn );

// Compute the determinant of a diagonal matrix.
VECT_OP_TYPE  VECT_OP_FUNC(DetDiagM)(    const VECT_OP_TYPE* sp, unsigned srn);

// Compute the log determinant of any square matrix.
VECT_OP_TYPE  VECT_OP_FUNC(LogDetM)(    const VECT_OP_TYPE* sp, unsigned srn );

// Compute the log determinant of a diagonal matrix.
VECT_OP_TYPE  VECT_OP_FUNC(LogDetDiagM)(    const VECT_OP_TYPE* sp, unsigned srn);


// Compute the inverse of a square matrix.  Returns NULL if the matrix is not invertable.
// 'drn' is the dimensionality of the data.
VECT_OP_TYPE* VECT_OP_FUNC(InvM)(    VECT_OP_TYPE* dp, unsigned drn );

// Compute the inverse of a diagonal matrix. Returns NULL if the matrix is not invertable.
VECT_OP_TYPE* VECT_OP_FUNC(InvDiagM)(    VECT_OP_TYPE* dp, unsigned drn );

// Solve a linear system of the form AX=B where A[an,an] is square. 
// Since A is square B must have 'an' rows.
// Result is returned in B.
// Returns a pointer to B on success or NULL on fail.
// NOTE: Both A and B are overwritten by this operation.
VECT_OP_TYPE* VECT_OP_FUNC(SolveLS)( VECT_OP_TYPE* A, unsigned an, VECT_OP_TYPE* B, unsigned bcn ); 

// Perform a Cholesky decomposition of the square symetric matrix U[un,un].
// The factorization has the form: A=U'TU.
// If the factorization is successful A is set to U and a pointer to A is returned.
// Note that the lower triangle of A is not overwritten. See CholZ().
// If the factorization fails NULL is returned.
VECT_OP_TYPE* VECT_OP_FUNC(Chol)(VECT_OP_TYPE* A, unsigned an );

// Same as Chol() but sets the lower triangle of U to zero. 
// This is equivalent ot the Matlab version.
VECT_OP_TYPE* VECT_OP_FUNC(CholZ)(VECT_OP_TYPE* U, unsigned un );

// Calculate the best fit line: b0 + b1*x_i through the points x_i,y_i.
// Set x to NULL if it uses sequential integers [0,1,2,3...]
void VECT_OP_FUNC(Lsq1)(const VECT_OP_TYPE* x, const VECT_OP_TYPE* y, unsigned n, VECT_OP_TYPE* b0, VECT_OP_TYPE* b1 );


//======================================================================================================================
//)

//( { label:"Stretch/Shrink" desc:"Stretch or shrink a vector by resampling." kw:[vop] }

// Return the average value of the contents of sbp[] between two fractional indexes
VECT_OP_TYPE  VECT_OP_FUNC(FracAvg)( double bi, double ei, const VECT_OP_TYPE* sbp, unsigned sn );

// Shrinking function - Decrease the size of sbp[] by averaging blocks of values into single values in dbp[]
VECT_OP_TYPE* VECT_OP_FUNC(DownSampleAvg)( VECT_OP_TYPE* dbp, unsigned dn, const VECT_OP_TYPE* sbp, unsigned sn );

// Stretching function - linear interpolate between points in sbp[] to fill dbp[] ... where dn > sn
VECT_OP_TYPE* VECT_OP_FUNC(UpSampleInterp)( VECT_OP_TYPE* dbp, unsigned dn, const VECT_OP_TYPE* sbp, unsigned sn );

// Stretch or shrink the sbp[] to fit into dbp[]
VECT_OP_TYPE* VECT_OP_FUNC(FitToSize)( VECT_OP_TYPE* dbp, unsigned dn, const VECT_OP_TYPE* sbp, unsigned sn );

// Stretch or shrink sV[] to fit into dV[] using a simple linear mapping.
// When stretching (sn<dn) each source element is repeated dn/sn times
// and the last fraction position is interpolated.  When shrinking 
// (sn>dn) each dest value is formed by the average of sequential segments
// of sn/dn source elements. Fractional values are used at the beginning
// and end of each segment.
VECT_OP_TYPE* VECT_OP_FUNC(LinearMap)(VECT_OP_TYPE* dV, unsigned dn, VECT_OP_TYPE* sV, unsigned sn );

//======================================================================================================================
//)

//( { label:"Random number generation" desc:"Generate random numbers." kw:[vop] }

// Generate a vector of uniformly distributed random numbers in the range minVal to maxVal.
VECT_OP_TYPE* VECT_OP_FUNC(Random)( VECT_OP_TYPE* dbp, unsigned dn, VECT_OP_TYPE minVal, VECT_OP_TYPE maxVal );

// Generate dn random numbers integers between 0 and wn-1 based on a the relative 
// weights in wp[wn].  Note thtat the weights do not have to sum to 1.0.
unsigned*  VECT_OP_FUNC(WeightedRandInt)( unsigned* dbp, unsigned dn, const VECT_OP_TYPE* wp, unsigned wn );

// Generate a vector of normally distributed univariate random numbers 
VECT_OP_TYPE* VECT_OP_FUNC(RandomGauss)(  VECT_OP_TYPE* dbp, unsigned dn, VECT_OP_TYPE mean, VECT_OP_TYPE var );

// Generate a vector of normally distributed univariate random numbers where each value has been drawn from a 
// seperately parameterized Gaussian distribution. meanV[] and varV[] must both contain dn velues.
VECT_OP_TYPE* VECT_OP_FUNC(RandomGaussV)( VECT_OP_TYPE* dbp, unsigned dn, const VECT_OP_TYPE* meanV, const VECT_OP_TYPE* varV );

// Generate a matrix of multi-dimensional random values. Each column represents a single vector value and each row contains a dimension.
// meanV[] and varV[] must both contain drn elements where each meanV[i],varV[i] pair parameterize one dimensions Gaussian distribution.
VECT_OP_TYPE* VECT_OP_FUNC(RandomGaussM)( VECT_OP_TYPE* dbp, unsigned drn, unsigned dcn, const VECT_OP_TYPE* meanV, const VECT_OP_TYPE* varV );
VECT_OP_TYPE* VECT_OP_FUNC(RandomGaussDiagM)( VECT_OP_TYPE* dbp, unsigned drn, unsigned dcn, const VECT_OP_TYPE* meanV, const VECT_OP_TYPE* diagCovarM );

// Generate a matrix of multivariate random values drawn from a normal distribution.
// The dimensionality of the values are 'drn'.
// The count of returned values is 'dcn'.
// meanV[drn] and covarM[drn,drn] parameterize the normal distribution.
// The covariance matrix must be symetric and positive definite. 
// t[(drn*drn) ] points to scratch memory or is set to NULL if the function should
//   allocate the memory internally.
// Based on octave function mvrnd.m.
VECT_OP_TYPE* VECT_OP_FUNC(RandomGaussNonDiagM)( VECT_OP_TYPE* dbp, unsigned drn, unsigned dcn, const VECT_OP_TYPE* meanV, const VECT_OP_TYPE* covarM, VECT_OP_TYPE* t );

// Same as RandomGaussNonDiagM() except requires the upper trianglular 
// Cholesky factor of the covar matrix in 'uM'. 
VECT_OP_TYPE* VECT_OP_FUNC(RandomGaussNonDiagM2)( VECT_OP_TYPE* dbp, unsigned drn, unsigned dcn, const VECT_OP_TYPE* meanV, const VECT_OP_TYPE* uM );


// Generate a matrix of N*K multi-dimensional data points.
// Where D is the dimensionality of the data. (D == drn).
// K is the number of multi-dimensional PDF's (clusters).
// N is the number of data points to generate per cluster. 
// dbp[ D, N*K ] contains the returned data point. 
// The first N columns is associated with the cluster 0, 
// the next N columns is associated with cluster 1, ...
// meanM[ D, K ] and varM[D,K] parameterize the generating PDF.s for each cluster
VECT_OP_TYPE* VECT_OP_FUNC(RandomGaussMM)( VECT_OP_TYPE* dbp, unsigned drn, unsigned dcn, const VECT_OP_TYPE* meanM, const VECT_OP_TYPE* varM, unsigned K );


// Evaluate the univariate normal distribution defined by 'mean' and 'stdDev'.
VECT_OP_TYPE* VECT_OP_FUNC(GaussPDF)( VECT_OP_TYPE* dbp, unsigned dn, const VECT_OP_TYPE* sbp, VECT_OP_TYPE mean, VECT_OP_TYPE stdDev );

// Evaluate a multivariate normal distribution defined by meanV[D] and covarM[D,D]
// at the data points held in the columns of xM[D,N]. Return the evaluation
// results in the vector yV[N].  D is the dimensionality of the data. N is the number of
// data points to evaluate and values to return in yV[N]. 
// Set diagFl to true if covarM is diagonal.
// The function fails and returns false if the covariance matrix is singular.
bool VECT_OP_FUNC(MultVarGaussPDF)( VECT_OP_TYPE* yV, const VECT_OP_TYPE* xM, const VECT_OP_TYPE* meanV, const VECT_OP_TYPE* covarM, unsigned D, unsigned N, bool diagFl );

// Same as multVarGaussPDF[] except takes the inverse covar mtx invCovarM[D,D] 
// and log determinant of covar mtx. 
// Always returns yV[].
VECT_OP_TYPE* VECT_OP_FUNC(MultVarGaussPDF2)( VECT_OP_TYPE* yV, const VECT_OP_TYPE* xM, const VECT_OP_TYPE* meanV, const VECT_OP_TYPE* invCovarM, VECT_OP_TYPE logDet, unsigned D, unsigned N, bool diagFl );

// Same as multVarGaussPDF[] except uses a function to obtain the data vectors.
// srcFunc() can filter the data points by returning NULL if the data vector at frmIdx should
// not be evaluated against the PDF. In this case yV[frmIdx] will be set to 0.
VECT_OP_TYPE* VECT_OP_FUNC(MultVarGaussPDF3)( 
  VECT_OP_TYPE*       yV, 
  const VECT_OP_TYPE* (*srcFunc)(void* funcDataPtr, unsigned frmIdx ),
  void*               funcDataPtr,
  const VECT_OP_TYPE* meanV, 
  const VECT_OP_TYPE* invCovarM, 
  VECT_OP_TYPE        logDet, 
  unsigned            D, 
  unsigned            N, 
  bool                diagFl );


//======================================================================================================================
//)


//( { label:"Signal generators" desc:"Generate periodic signals." kw:[vop] }

// The following functions all return the phase of the next value. 
unsigned      VECT_OP_FUNC(SynthSine)(      VECT_OP_TYPE* dbp, unsigned dn, unsigned phase, double srate, double hz );
unsigned      VECT_OP_FUNC(SynthCosine)(    VECT_OP_TYPE* dbp, unsigned dn, unsigned phase, double srate, double hz );
unsigned      VECT_OP_FUNC(SynthSquare)(    VECT_OP_TYPE* dbp, unsigned dn, unsigned phase, double srate, double hz, unsigned otCnt );
unsigned      VECT_OP_FUNC(SynthTriangle)(  VECT_OP_TYPE* dbp, unsigned dn, unsigned phase, double srate, double hz, unsigned otCnt );
unsigned      VECT_OP_FUNC(SynthSawtooth)(  VECT_OP_TYPE* dbp, unsigned dn, unsigned phase, double srate, double hz, unsigned otCnt );
unsigned      VECT_OP_FUNC(SynthPulseCos)(  VECT_OP_TYPE* dbp, unsigned dn, unsigned phase, double srate, double hz, unsigned otCnt );
unsigned      VECT_OP_FUNC(SynthImpulse)(   VECT_OP_TYPE* dbp, unsigned dn, unsigned phase, double srate, double hz );
unsigned      VECT_OP_FUNC(SynthPhasor)(    VECT_OP_TYPE* dbp, unsigned dn, unsigned phase, double srate, double hz ); 


// Return value should be passed back via delaySmp on the next call.
VECT_OP_TYPE  VECT_OP_FUNC(SynthPinkNoise)( VECT_OP_TYPE* dbp, unsigned dn, VECT_OP_TYPE delaySmp );

//======================================================================================================================
//)

//( { label:"Exponential conversion" desc:"pow() and log() functions." kw:[vop] }

// Raise dbp[] to the power 'expon'
VECT_OP_TYPE* VECT_OP_FUNC(PowVS)(  VECT_OP_TYPE* dbp, unsigned dn, VECT_OP_TYPE expon );
VECT_OP_TYPE* VECT_OP_FUNC(PowVVS)( VECT_OP_TYPE* dbp, unsigned dn, const VECT_OP_TYPE* sp, VECT_OP_TYPE expon );

// Take the natural log of all values in sbp[dn]. It is allowable for sbp point to the same array as dbp=.
VECT_OP_TYPE* VECT_OP_FUNC(LogV)( VECT_OP_TYPE* dbp, unsigned dn, const VECT_OP_TYPE* sbp );

//======================================================================================================================
//)

//( { label:"dB Conversions" desc:"Convert vectors between dB,linear and power representations." kw:[vop] }

// Convert a magnitude (amplitude) spectrum to/from decibels. 
// It is allowable for dbp==sbp.
VECT_OP_TYPE* VECT_OP_FUNC(AmplToDbVV)( VECT_OP_TYPE* dbp, unsigned dn, const VECT_OP_TYPE* sbp, VECT_OP_TYPE minDb );
VECT_OP_TYPE* VECT_OP_FUNC(DbToAmplVV)( VECT_OP_TYPE* dbp, unsigned dn, const VECT_OP_TYPE* sbp);

VECT_OP_TYPE* VECT_OP_FUNC(PowToDbVV)( VECT_OP_TYPE* dbp, unsigned dn, const VECT_OP_TYPE* sbp, VECT_OP_TYPE minDb );
VECT_OP_TYPE* VECT_OP_FUNC(DbToPowVV)( VECT_OP_TYPE* dbp, unsigned dn, const VECT_OP_TYPE* sbp);

VECT_OP_TYPE* VECT_OP_FUNC(LinearToDb)(    VECT_OP_TYPE* dbp, unsigned dn, const VECT_OP_TYPE* sp, VECT_OP_TYPE mult );
VECT_OP_TYPE* VECT_OP_FUNC(dBToLinear)(    VECT_OP_TYPE* dbp, unsigned dn, const VECT_OP_TYPE* sp, VECT_OP_TYPE mult );
VECT_OP_TYPE* VECT_OP_FUNC(AmplitudeToDb)( VECT_OP_TYPE* dbp, unsigned dn, const VECT_OP_TYPE* sp );
VECT_OP_TYPE* VECT_OP_FUNC(PowerToDb)(     VECT_OP_TYPE* dbp, unsigned dn, const VECT_OP_TYPE* sp );
VECT_OP_TYPE* VECT_OP_FUNC(dBToAmplitude)( VECT_OP_TYPE* dbp, unsigned dn, const VECT_OP_TYPE* sp );
VECT_OP_TYPE* VECT_OP_FUNC(dBToPower)(     VECT_OP_TYPE* dbp, unsigned dn, const VECT_OP_TYPE* sp );
//======================================================================================================================
//)

//( { label:"DSP Windows" desc:"DSP windowing functions." kw:[vop] }

VECT_OP_TYPE  VECT_OP_FUNC(KaiserBetaFromSidelobeReject)(  double sidelobeRejectDb );
VECT_OP_TYPE  VECT_OP_FUNC(KaiserFreqResolutionFactor)( double sidelobeRejectDb );
VECT_OP_TYPE* VECT_OP_FUNC(Kaiser)(  VECT_OP_TYPE* dbp, unsigned dn, double beta );
VECT_OP_TYPE*	VECT_OP_FUNC(Gaussian)(VECT_OP_TYPE* dbp, unsigned dn, double mean, double variance );
VECT_OP_TYPE* VECT_OP_FUNC(Hamming)( VECT_OP_TYPE* dbp, unsigned dn );
VECT_OP_TYPE* VECT_OP_FUNC(Hann)(    VECT_OP_TYPE* dbp, unsigned dn );
VECT_OP_TYPE* VECT_OP_FUNC(Triangle)(VECT_OP_TYPE* dbp, unsigned dn );

// The MATLAB equivalent Hamming and Hann windows.
//VECT_OP_TYPE* VECT_OP_FUNC(HammingMatlab)(VECT_OP_TYPE* dbp, unsigned dn );
VECT_OP_TYPE* VECT_OP_FUNC(HannMatlab)(   VECT_OP_TYPE* dbp, unsigned dn );

// Simulates the MATLAB GaussWin function. Set arg to 2.5 to simulate the default arg
// as used by MATLAB.
VECT_OP_TYPE*	VECT_OP_FUNC(GaussWin)( VECT_OP_TYPE* dbp, unsigned dn, double arg );
//======================================================================================================================
//)

//( { label:"DSP Filters" desc:"DSP filtering functions." kw:[vop] }

// Direct form II algorithm based on the MATLAB implmentation
// http://www.mathworks.com/access/helpdesk/help/techdoc/ref/filter.html#f83-1015962
// The only difference between this function and the equivalent MATLAB filter() function
// is that the first feedforward coeff is given as a seperate value. The first  b coefficient
//  in this function is therefore the same as the second coefficient in the MATLAB function.
//  and the first a[] coefficient (which is generally set to 1.0) is skipped.
//  Example:
//  Matlab:         b=[.5 .4 .3]  a=[1 .2 .1]
//  Equiv:  b0 = .5 b=[   .4 .3]  a=[  .2 .1]; 
//
// y[yn] - output vector 
// x[xn] - input vector. xn must be <= yn. if xn < yn then the end of y[] is set to zero.
// b0 - signal scale. This can also be seen as b[0] (which is not included in b[])
// b[dn] - feedforward coeff's b[1..dn-1]
// a[dn] - feedback coeff's    a[1..dn-1]
// d[dn+1] - delay registers - note that this array must be one element longer than the coeff arrays.
// 
VECT_OP_TYPE* VECT_OP_FUNC(Filter)( VECT_OP_TYPE* y, unsigned yn, const VECT_OP_TYPE* x, unsigned xn, cmReal_t b0, const cmReal_t* b, const cmReal_t* a,  cmReal_t* d, unsigned dn );

struct cmFilter_str;
//typedef cmRC_t (*VECT_OP_FUNC(FiltExecFunc_t))( struct acFilter_str* f,  const VECT_OP_TYPE* x, unsigned xn, VECT_OP_TYPE* y, unsigned yn );
VECT_OP_TYPE* VECT_OP_FUNC(FilterFilter)(struct cmFilter_str* f, cmRC_t (*func)( struct cmFilter_str* f,  const VECT_OP_TYPE* x, unsigned xn, VECT_OP_TYPE* y, unsigned yn ), const cmReal_t bb[], unsigned bn, const cmReal_t aa[], unsigned an, const VECT_OP_TYPE* x, unsigned xn, VECT_OP_TYPE* y, unsigned yn );

// Compute the coefficients of a low/high pass FIR filter
// wndV[dn] gives the window function used to truncate the ideal low-pass impulse response.
// Set wndV to NULL to use a unity window.
// See enum { kHighPass_LPSincFl=0x01, kNormalize_LPSincFl=0x02 } in cmVectOps.h
VECT_OP_TYPE* VECT_OP_FUNC(LP_Sinc)(VECT_OP_TYPE* dp, unsigned dn, const VECT_OP_TYPE* wndV, double srate, double fcHz, unsigned flags );



//======================================================================================================================
//)

//( { label:"Spectral Masking" desc:"A collection of spectral masking functions." kw:[vop] }

// Compute a set of filterCnt mel filter masks for wieghting magnitude spectra consisting of binCnt bins.
// The spectrum is divided into bandCnt equal bands in the mel domain
// Each row of the matrix contains the mask for a single filter band consisting of binCnt elements.  
// See enum{ kShiftMelFl=0x01, kNormalizeMelFl=0x02 } in cmVectOps.h
// Set kShiftMelFl to shift the mel bands onto the nearest FFT bin.
// Set kNormalizeMelFl to normalize the combined filters for unity gain.
VECT_OP_TYPE* VECT_OP_FUNC(MelMask)( VECT_OP_TYPE* maskMtx, unsigned bandCnt, unsigned binCnt, double srate, unsigned flags );

// Fill binIdxV[bandCnt] and cntV[bandCnt] with a bin to band map.
// binIdx[] contains the first (minimum) bin index for a given band.
// cntV[]   contains the count of bins for each band.
// bandCnt is the number of bark bands to return 
// The function returns the actual number of bands mapped which will always be <= 23.
unsigned VECT_OP_FUNC(BarkMap)(unsigned* binIdxV, unsigned* cntV, unsigned bandCnt, unsigned binCnt, double srate );

// Calc a set of triangle fitler masks into each row of maskMtx.
// maskMtx[ bandCnt, binCnt ] - result matrix
// binHz - freq resolution of the output filters.
// stSpread - Semi-tone spread above and below each center frequency (stSpread*2) is the total bandwidth. 
//            (Only used if lowHzV or uprHzV are NULL)
// lowHz[ bandCnt ] - set of upper frequency limits for each band.
// ctrHz[ bandCnt ] set to the center value in Hz for each band
// uprHz[ bandCnt ] - set of lower frequency limits for each band.
// Note if lowHz[] and uprHz[] are set to NULL then stSpread is used to set the bandwidth of each band.
VECT_OP_TYPE* VECT_OP_FUNC(TriangleMask)(VECT_OP_TYPE* maskMtx, unsigned bandCnt, unsigned binCnt, const VECT_OP_TYPE* ctrHzV, VECT_OP_TYPE binHz, VECT_OP_TYPE stSpread, const VECT_OP_TYPE* lowHzV, const VECT_OP_TYPE* uprHzV );

// Calculate a set of Bark band triangle filters into maskMtx.
// Each row of maskMtx contains the filter for one band.
// maskMtx[ bandCnt, binCnt ]
// bandCnt - the number of triangle bankds. If bandCnt is > 24 it will be reduced to 24.
// binCnt - the number of bins in the filters.
// binHz - the width of each bin in Hz.
VECT_OP_TYPE* VECT_OP_FUNC(BarkMask)(VECT_OP_TYPE* maskMtx, unsigned bandCnt, unsigned binCnt, double binHz );

// Terhardt 1979 (Calculating virtual pitch, Hearing Research #1, pp 155-182)
// See enum { kNoTtmFlags=0, kModifiedTtmFl=0x01 } in cmVectOps.h
VECT_OP_TYPE* VECT_OP_FUNC(TerhardtThresholdMask)(VECT_OP_TYPE* maskV, unsigned binCnt,  double srate, unsigned flags);

//Schroeder et al., 1979, JASA, Optimizing digital speech coders by exploiting masking properties of the human ear
VECT_OP_TYPE* VECT_OP_FUNC(ShroederSpreadingFunc)(VECT_OP_TYPE* m, unsigned bandCnt, double srate);

//======================================================================================================================
//)

//( { label:"Machine learning" desc:"K-means clustering and Viterbi algorithms." kw:[vop] }

// Assign each data point to one of k clusters using an expectation-maximization algorithm.
// k gives the number of clusters to identify
// Each column of sp[ srn, scn ] contains a multidimensional data point. 
// srn therefore defines the dimensionality of the data.
// Each column of centroidV[ srn, k ] is set to the centroid of each of k clusters.
// classIdxV[ scn ] assigns the index (0 to k-1) of a cluster to each soure data point
// The function returns the number of iterations required for the EM process to converge.
// selIdxV[ scn ] is optional and contains a list of id's assoc'd with each column of sM.
// selKey is a integer value.
// If selIdxV is non-NULL then only columns of sM[] where selIdxV[] == selKey will be clustered.
// All columns of sM[] where the associated column in selIdxV[] do not match will be ignored.
// Set 'initFromCentroidFl' to true if the initial centroids should be taken from centroidM[].
// otherwise the initial centroids are selected from 'k' random data points in sp[].
// The distance function distFunc(cV,dV,dN) is called to determine the distance from a 
// centroid the centroid 'cV[dN]' to a data point 'dV[dN]'. 'dN' is the dimensionality of the
// feature vector and is therefore equal to 'srn'.
unsigned VECT_OP_FUNC(Kmeans)( 
  unsigned*           classIdxV, 
  VECT_OP_TYPE*       centroidM, 
  unsigned            k, 
  const VECT_OP_TYPE* sp, 
  unsigned            srn, 
  unsigned            scn, 
  const unsigned*     selIdxV, 
  unsigned            selKey, 
  bool                initFromCentroidFl,  
  VECT_OP_TYPE (*distFunc)( void* userPtr, const VECT_OP_TYPE* cV, const VECT_OP_TYPE* dV, unsigned dN ), 
  void*               userDistPtr ); 

// 'srcFunc() should return NULL if the data point located at 'frmIdx' should not be included in the clustering.
// Clustering is considered to be complete after 'maxIterCnt' iterations or when
// 'deltaStopCnt' or fewer data points change class on a single iteration
unsigned VECT_OP_FUNC(Kmeans2)( 
  unsigned*           classIdxV,         // classIdxV[scn] - data point class assignments
  VECT_OP_TYPE*       centroidM,         // centroidM[srn,K] - cluster centroids
  unsigned            K,                 // count of clusters
  const VECT_OP_TYPE* (*srcFunc)(void* userPtr, unsigned frmIdx ),
  unsigned            srn,               // dimensionality of each data point
  unsigned            scn,               // count of data points
  void*               userSrcPtr,        // callback data for srcFunc
  VECT_OP_TYPE (*distFunc)( void* userPtr, const VECT_OP_TYPE* cV, const VECT_OP_TYPE* dV, unsigned dN ), 
  void*              userDistPtr,        // arg. to distFunc()
  int                iterCnt,            // max. number of iterations (-1 to ignore)
  int                deltaStopCnt);      // if less than deltaStopCnt data points change classes on a given iteration then convergence occurs.

// Determine the most likely state sequece stateV[timeN] given a 
// transition matrix a[stateN,stateN], 
// observation probability matrix b[stateN,timeN] and 
// initial state probability vector phi[stateN].  
// a[i,j] is the probability of transitioning from state i to state j.
// b[i,t] is the probability of state i emitting the obj t.
void VECT_OP_FUNC(DiscreteViterbi)(unsigned* stateV, unsigned timeN, unsigned stateN, const VECT_OP_TYPE* phi, const VECT_OP_TYPE* a, const VECT_OP_TYPE* b );


//======================================================================================================================
//)

//( { label:"Graphics" desc:"Graphics related algorithms." kw:[vop] }

// Generate the set of coordinates which describe a circle with a center at x,y.
// dbp[dn,2] must contain 2*dn elements.  The first column holds the x coord and and the second holds the y coord.
VECT_OP_TYPE* VECT_OP_FUNC(CircleCoords)( VECT_OP_TYPE* dbp, unsigned dn, VECT_OP_TYPE x, VECT_OP_TYPE y, VECT_OP_TYPE varX, VECT_OP_TYPE varY );

// Clip the line defined by x0,y0 to x1,y1 into the rect defined by xMin,yMin xMax,yMax.
bool VECT_OP_FUNC(ClipLine)( VECT_OP_TYPE* x0, VECT_OP_TYPE* y0, VECT_OP_TYPE* x1, VECT_OP_TYPE* y1, VECT_OP_TYPE xMin, VECT_OP_TYPE yMin, VECT_OP_TYPE xMax, VECT_OP_TYPE yMax );

// Return true if the line defined by x0,y0 to x1,y1 intersects with
// the rectangle formed by xMin,yMin - xMax,yMax
bool VECT_OP_FUNC(IsLineInRect)( VECT_OP_TYPE x0, VECT_OP_TYPE y0, VECT_OP_TYPE x1, VECT_OP_TYPE y1, VECT_OP_TYPE xMin, VECT_OP_TYPE yMin, VECT_OP_TYPE xMax, VECT_OP_TYPE yMax );


// Return the perpendicular distance from the line formed by x0,y0 and x1,y1
// and the point px,py
VECT_OP_TYPE VECT_OP_FUNC(PtToLineDistance)( VECT_OP_TYPE x0, VECT_OP_TYPE y0, VECT_OP_TYPE x1, VECT_OP_TYPE y1, VECT_OP_TYPE px, VECT_OP_TYPE py);                              

//======================================================================================================================
//)

//( { label:"Miscellaneous DSP" desc:"Common DSP algorithms." kw:[vop] }

// Compute the complex transient detection function from successive spectral frames.
// The spectral magntidue mag0V precedes mag1V and the phase (radians) spectrum phs0V precedes the phs1V which precedes phs2V.  
// binCnt gives the length of each of the spectral vectors.
VECT_OP_TYPE  VECT_OP_FUNC(ComplexDetect)(const VECT_OP_TYPE* mag0V, const VECT_OP_TYPE* mag1V, const VECT_OP_TYPE* phs0V, const VECT_OP_TYPE* phs1V, const VECT_OP_TYPE* phs2V, unsigned binCnt );

// Compute a set of DCT-II coefficients. Result dp[ coeffCnt, filtCnt ]
VECT_OP_TYPE* VECT_OP_FUNC(DctMatrix)( VECT_OP_TYPE* dp, unsigned coeffCnt, unsigned filtCnt );


// Set the indexes of local peaks greater than threshold in dbp[].
// Returns the number of peaks in dbp[]
// The maximum number of peaks from n source values is max(0,floor((n-1)/2)).
// Note that peaks will never be found at index 0 or index sn-1.
unsigned VECT_OP_FUNC(PeakIndexes)( unsigned* dbp, unsigned dn, const VECT_OP_TYPE* sbp, unsigned sn, VECT_OP_TYPE threshold );

// Return the index of the bin containing v otherwise return kInvalidIdx if v is below sbp[0] or above sbp[ n-1 ]
// The bin limits are contained in sbp[].
// The value in spb[] are therefore expected to be in increasing order.
// The value returned will be in the range 0:sn-1.
unsigned VECT_OP_FUNC(BinIndex)( const VECT_OP_TYPE* sbp, unsigned sn, VECT_OP_TYPE v );


// Given the points x0[xy0N],y0[xy0N] fill y1[i] with the interpolated value of y0[] at
// x1[i].  Note that x0[] and x1[] must be increasing monotonic.
// This function is similar to the octave interp1() function.
void VECT_OP_FUNC(Interp1)(VECT_OP_TYPE* y1, const VECT_OP_TYPE* x1, unsigned xy1N, const VECT_OP_TYPE* x0, const VECT_OP_TYPE* y0, unsigned xy0N );
 
//======================================================================================================================
//)