libcm is a C development framework with an emphasis on audio signal processing applications.
Du kan inte välja fler än 25 ämnen Ämnen måste starta med en bokstav eller siffra, kan innehålla bindestreck ('-') och vara max 35 tecken långa.

cmVectOpsTemplateHdr.h 40KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620
  1. // \file cmVectOpsTemplateHdr.h
  2. /// Vector operations interface.
  3. /// Setting fieldWidth or decPltCnt to to negative values result in fieldWidth == 10 or decPlCnt == 4
  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 );
  5. void VECT_OP_FUNC(Print)( cmRpt_t* rpt, unsigned rn, unsigned cn, const VECT_OP_TYPE* dbp );
  6. void VECT_OP_FUNC(PrintE)( cmRpt_t* rpt, unsigned rn, unsigned cn, const VECT_OP_TYPE* dbp );
  7. 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 );
  8. void VECT_OP_FUNC(PrintL)( const char* label, cmRpt_t* rpt, unsigned rn, unsigned cn, const VECT_OP_TYPE* dbp );
  9. void VECT_OP_FUNC(PrintLE)( const char* label, cmRpt_t* rpt, unsigned rn, unsigned cn, const VECT_OP_TYPE* dbp );
  10. /// Normalize the vector of proabilities by dividing through by the sum.
  11. /// This leaves the relative proportions of each value unchanged while producing a total probability of 1.0.
  12. VECT_OP_TYPE* VECT_OP_FUNC(NormalizeProbabilityVV)(VECT_OP_TYPE* dbp, unsigned dn, const VECT_OP_TYPE* sbp);
  13. VECT_OP_TYPE* VECT_OP_FUNC(NormalizeProbability)(VECT_OP_TYPE* dbp, unsigned dn);
  14. VECT_OP_TYPE* VECT_OP_FUNC(NormalizeProbabilityN)(VECT_OP_TYPE* dbp, unsigned dn, unsigned stride);
  15. /// Standardize the columns of the matrix by subtracting the mean and dividing by the standard deviation.
  16. /// uV[dcn] returns the mean of the data and is optional.
  17. /// sdV[dcn] return the standard deviation of the data and is optional.
  18. VECT_OP_TYPE* VECT_OP_FUNC(StandardizeRows)( VECT_OP_TYPE* dbp, unsigned drn, unsigned dcn, VECT_OP_TYPE* uV, VECT_OP_TYPE* sdV );
  19. VECT_OP_TYPE* VECT_OP_FUNC(StandardizeCols)( VECT_OP_TYPE* dbp, unsigned drn, unsigned dcn, VECT_OP_TYPE* uV, VECT_OP_TYPE* sdV );
  20. /// dbp[] = sbp<0 .* sbp
  21. /// Overlapping the source and dest is allowable as long as dbp <= sbp.
  22. VECT_OP_TYPE* VECT_OP_FUNC(HalfWaveRectify)(VECT_OP_TYPE* dbp, unsigned dn, const VECT_OP_TYPE* sp );
  23. /// Compute the cummulative sum of sbp[dn]. Equivalent to Matlab cumsum().
  24. VECT_OP_TYPE* VECT_OP_FUNC(CumSum)(VECT_OP_TYPE* dbp, unsigned dn, const VECT_OP_TYPE* sbp );
  25. VECT_OP_TYPE VECT_OP_FUNC(Mean)( const VECT_OP_TYPE* sp, unsigned sn );
  26. VECT_OP_TYPE VECT_OP_FUNC(MeanN)( const VECT_OP_TYPE* sp, unsigned sn, unsigned stride );
  27. // Take the mean of each column/row of a matrix.
  28. // Set 'dim' to 0 to return mean of columns else return mean of rows.
  29. VECT_OP_TYPE* VECT_OP_FUNC(MeanM)( VECT_OP_TYPE* dp, const VECT_OP_TYPE* sp, unsigned srn, unsigned scn, unsigned dim );
  30. // Take the mean of the first 'cnt' element of each column/row of a matrix.
  31. // Set 'dim' to 0 to return mean of columns else return mean of rows.
  32. // If 'cnt' is greater than the number of elements in the column/row then 'cnt' is
  33. // reduced to the number of elements in the column/row.
  34. VECT_OP_TYPE* VECT_OP_FUNC(MeanM2)( VECT_OP_TYPE* dp, const VECT_OP_TYPE* sp, unsigned srn, unsigned scn, unsigned dim, unsigned cnt );
  35. // Find the mean of the data points returned by srcFuncPtr(argPtr,i) and return it in dp[dim].
  36. // 'dim' is both the size of dp[] and the length of each data point returned by srcFuncPtr().
  37. // srcFuncPtr() will be called 'cnt' times but it may return NULL on some calls if the associated
  38. // data point should not be included in the mean calculation.
  39. 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 );
  40. // avgPtr is optional - set to NULL to compute the average
  41. VECT_OP_TYPE VECT_OP_FUNC(Variance)( const VECT_OP_TYPE* sp, unsigned sn, const VECT_OP_TYPE* avgPtr );
  42. VECT_OP_TYPE VECT_OP_FUNC(VarianceN)(const VECT_OP_TYPE* sp, unsigned sn, unsigned stride, const VECT_OP_TYPE* avgPtr );
  43. // Set dim=0 to return variance of columns otherwise return variance or rows.
  44. 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 );
  45. // dp[] ./= max(dp). Returns the index of the max value.
  46. unsigned VECT_OP_FUNC(NormToMax)( VECT_OP_TYPE* dp, unsigned dn );
  47. // db[] .*= fact / abs(max(dp));
  48. unsigned VECT_OP_FUNC(NormToAbsMax)( VECT_OP_TYPE* dp, unsigned dn, VECT_OP_TYPE fact );
  49. VECT_OP_TYPE VECT_OP_FUNC(AlphaNorm)(const VECT_OP_TYPE* sp, unsigned sn, VECT_OP_TYPE alpha );
  50. // Calculate the sample covariance matrix from a set of Gaussian distributed multidimensional data.
  51. // sp[dn,scn] is the data set.
  52. // dn is the dimensionality of the data.
  53. // scn is the count of data points
  54. // up[dn] is an optional mean vector. If up == NULL then the mean of the data is calculated internally.
  55. // selIdxV[scn] can be used to select a subset of datapoints to process.
  56. // If selIdxV[] is non-NULL then only columns where selIdxV[i]==selKey will be processed.
  57. //
  58. // dp[dn,dn] = covar( sp[dn,scn], u[dn] )
  59. 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 );
  60. // Calculate the sample covariance matrix.
  61. // dp[ dn*dn ] - output matrix
  62. // dn - dimensionality of the data
  63. // srcFuncPtr - User defined function which is called to return a pointer to a data vector at index 'idx'.
  64. // The returned data vector must contain 'dn' elements. The function should return NULL
  65. // if the data point associated with 'idx' should not be included in the covariance calculation.
  66. // sn - count of data vectors
  67. // userPtr - User arg. passed to srcFuncPtr.
  68. // uV[ dn ] - mean of the data set (optional)
  69. // Note that this function computes the covariance matrix in 2 serial passes (1 if the mean vector is given)
  70. // through the 'sn' data points.
  71. // The result of this function are identical to the octave cov() function.
  72. 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 );
  73. bool VECT_OP_FUNC(Equal)( const VECT_OP_TYPE* s0p, const VECT_OP_TYPE* s1p, unsigned sn );
  74. // Returns true if all values are 'normal' according the the C macro 'isnormal'.
  75. // This function will return false if any of the values are zero.
  76. bool VECT_OP_FUNC(IsNormal)( const VECT_OP_TYPE* sp, unsigned sn );
  77. // Returns true if all values are 'normal' or zero according the the C macro 'isnormal'.
  78. // This function accepts zeros as normal.
  79. bool VECT_OP_FUNC(IsNormalZ)(const VECT_OP_TYPE* sp, unsigned sn );
  80. // Set dp[dn] to the indexes of the non-normal numbers in sp[dn].
  81. // Returns the count of indexes stored in dp[].
  82. unsigned VECT_OP_FUNC(FindNonNormal)( unsigned* dp, unsigned dn, const VECT_OP_TYPE* sp );
  83. unsigned VECT_OP_FUNC(FindNonNormalZ)( unsigned* dp, unsigned dn, const VECT_OP_TYPE* sp );
  84. /// Successive call to to ZeroCrossCount should preserve the value pointed to by delaySmpPtr.
  85. unsigned VECT_OP_FUNC(ZeroCrossCount)( const VECT_OP_TYPE* sp, unsigned n, VECT_OP_TYPE* delaySmpPtr);
  86. // Calculuate the sum of the squares of all elements in bp[bn].
  87. VECT_OP_TYPE VECT_OP_FUNC(SquaredSum)( const VECT_OP_TYPE* bp, unsigned bn );
  88. /// sn must be <= wndSmpCnt. If sn < wndSmpCnt then sp[sn] is treated as a
  89. /// a partially filled buffer padded with wndSmpCnt-sn zeros.
  90. /// rms = sqrt( sum(sp[1:sn] .* sp[1:sn]) / wndSmpCnt )
  91. VECT_OP_TYPE VECT_OP_FUNC(RMS)( const VECT_OP_TYPE* sp, unsigned sn, unsigned wndSmpCnt );
  92. /// This function handles the case were sn is not an integer multiple of
  93. /// wndSmpCnt or hopSmpCnt. In this case the function computes zero
  94. /// padded RMS values for windows which go past the end of sp[sn].
  95. VECT_OP_TYPE* VECT_OP_FUNC(RmsV)( VECT_OP_TYPE* dp, unsigned dn, const VECT_OP_TYPE* sp, unsigned sn, unsigned wndSmpCnt, unsigned hopSmpCnt );
  96. /// Return the magnitude (Euclidean Norm) of a vector.
  97. VECT_OP_TYPE VECT_OP_FUNC(EuclidNorm)( const VECT_OP_TYPE* sp, unsigned sn );
  98. // Return the Itakura-Saito distance between a modelled power spectrum (up) and another power spectrum (sp).
  99. VECT_OP_TYPE VECT_OP_FUNC(ItakuraDistance)( const VECT_OP_TYPE* up, const VECT_OP_TYPE* sp, unsigned sn );
  100. /// Return the cosine distance between two vectors.
  101. VECT_OP_TYPE VECT_OP_FUNC(CosineDistance)( const VECT_OP_TYPE* s0P, const VECT_OP_TYPE* s1p, unsigned sn );
  102. /// Return the Euclidean distance between two vectors
  103. VECT_OP_TYPE VECT_OP_FUNC(EuclidDistance)( const VECT_OP_TYPE* s0p, const VECT_OP_TYPE* s1p, unsigned sn );
  104. /// Return the Manhattan distance between two vectors
  105. VECT_OP_TYPE VECT_OP_FUNC(L1Distance)( const VECT_OP_TYPE* s0p, const VECT_OP_TYPE* s1p, unsigned sn );
  106. /// Return the Mahalanobis distance between a vector and the mean of the distribution.
  107. /// The mean vector could be replaced with another vector drawn from the same distribution in which
  108. /// case the returned value would reflect the distance between the two vectors.
  109. /// 'sn' is the dimensionality of the data.
  110. /// up[D] and invCovM[sn,sn] are the mean and inverse of the covariance matrix of the distribution from
  111. /// which sp[D] is drawn.
  112. VECT_OP_TYPE VECT_OP_FUNC(MahalanobisDistance)( const VECT_OP_TYPE* sp, unsigned sn, const VECT_OP_TYPE* up, const VECT_OP_TYPE* invCovM );
  113. /// Return the KL distance between two probability distributions up[sn] and sp[sn].
  114. /// Since up[] and sp[] are probability distributions they must sum to 1.0.
  115. VECT_OP_TYPE VECT_OP_FUNC(KL_Distance)( const VECT_OP_TYPE* up, const VECT_OP_TYPE* sp, unsigned sn );
  116. /// Return the KL distance between a prototype vector up[sn] and another vector sp[sn].
  117. /// This function first normalizes the two vectors to sum to 1.0 before calling
  118. // VECT_OP_FUNC(KL_Distance)(up,sp,sn);
  119. VECT_OP_TYPE VECT_OP_FUNC(KL_Distance2)( const VECT_OP_TYPE* up, const VECT_OP_TYPE* sp, unsigned sn );
  120. /// Measure the Euclidean distance between a vector and all the columns in a matrix.
  121. /// If dv[scn] is no NULL then return the Euclidean distance from sv[scn] to each column of sm[srn,scn].
  122. /// The function returns the index of the closest data point (column) in sm[].
  123. unsigned VECT_OP_FUNC(EuclidDistanceVM)( VECT_OP_TYPE* dv, const VECT_OP_TYPE* sv, const VECT_OP_TYPE* sm, unsigned srn, unsigned scn );
  124. /// Measure the distance between each column in s0M[ rn, s0cn ] and
  125. /// each column in s1M[rn, s1cn ]. If dM is non-NULL store the
  126. /// result in dM[s1cn, s0cn]. The difference between s0M[:,0] and s1M[:,0]
  127. /// is stored in dM[0,0], the diff. between s0M[:,1] and s1M[:,1] is stored
  128. /// in dM[1,0], etc. If mvV[s0cn] is non-NULL then minV[i] is set with
  129. /// the distance from s0M[:,i] to the nearest column in s1M[]. If miV[s0cn]
  130. /// is non-NULL then it is set with the column index of s1M[] which is
  131. /// closest to s0M[:,i]. In other words mvV[i] gives the distance to column
  132. /// miV[i] from column s0M[:,i].
  133. /// In those cases where the distane from a prototype (centroid) to the data point
  134. /// is not the same as from the data point to the centroid then s1M[] is considered
  135. /// to hold the prototypes and s0M[] is considered to hold the data points.
  136. /// The distance function returns the distance from a prototype 'cV[dimN]' to
  137. /// an datapoint dV[dimN]. 'dimN' is the dimensionality of the data vector
  138. /// and is threfore equal to 'rn'.
  139. void VECT_OP_FUNC(DistVMM)(
  140. VECT_OP_TYPE* dM, // dM[s1cn,s0cn] return distance mtx (optional)
  141. VECT_OP_TYPE* mvV, // mvV[s0cn] distance to closest data point in s0M[]. (optional)
  142. unsigned* miV, // miV[s0cn] column index into s1M[] of closest data point to s0M[:,i]. (optional)
  143. unsigned rn, // dimensionality of the data and the row count for s0M[] and s1M[]
  144. const VECT_OP_TYPE* s0M, // s0M[rn,s0cn] contains one data point per column
  145. unsigned s0cn, // count of data points (count of columns in s0M[]
  146. const VECT_OP_TYPE* s1M, // s1M[rn,s1cn] contains one prototype per column
  147. unsigned s1cn, // count of prototypes (count of columns in s1m[]
  148. VECT_OP_TYPE (*distFunc)( void* userPtr, const VECT_OP_TYPE* cV, const VECT_OP_TYPE* dV, unsigned dimN ),
  149. void* userPtr );
  150. /// Select 'selIdxN' columns from sM[srn,scn].
  151. /// dM[srn,selIdxN] receives copies of the selected columns.
  152. /// selIdxV[selIdxN] receives the column indexes of the selected columns.
  153. /// Both dM[] and selIdxV[] are optional.
  154. /// In each case the first selected point is chosen at random.
  155. /// SelectRandom() then selects the following selIdxN-1 points at random.
  156. /// SelectMaxDist() selects the next selIdxN-1 points by selecting
  157. /// the point whose combined distance to the previously selected points
  158. /// is greatest. SelectMaxAvgDist() selectes the points whose combined
  159. /// average distance is greatest relative the the previously selected
  160. /// points.
  161. void VECT_OP_FUNC(SelectRandom)( VECT_OP_TYPE* dM, unsigned* selIdxV, unsigned selIdxN, const VECT_OP_TYPE* sM, unsigned srn, unsigned scn );
  162. 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 );
  163. 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 );
  164. /// Return the sum of the products (dot product)
  165. VECT_OP_TYPE VECT_OP_FUNC(MultSumVV)( const VECT_OP_TYPE* s0p, const VECT_OP_TYPE* s1p, unsigned sn );
  166. VECT_OP_TYPE VECT_OP_FUNC(MultSumVS)( const VECT_OP_TYPE* s0p, unsigned sn, VECT_OP_TYPE s );
  167. /// Number of elements in the dest vector is expected to be the same
  168. /// as the number of source matrix rows.
  169. /// mcn gives the number of columns in the source matrix which is
  170. // expected to match the number of elements in the source vector.
  171. /// dbp[dn,1] = mp[dn,mcn] * vp[mcn,1]
  172. 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 );
  173. /// Multiply a row vector with a matrix to produce a row vector.
  174. /// dbp[1,dn] = v[1,vn] * m[vn,dn]
  175. 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 );
  176. /// Same as MultVMtV() except M is transposed as part of the multiply.
  177. /// mrn gives the number of rows in m[] and number of elements in vp[]
  178. /// dpb[dn] = mp[mrn,dn] * vp[mrn]
  179. 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 );
  180. /// Same as MultVMV() but where the matrix is diagonal.
  181. 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 );
  182. /// Generalized matrix multiply.
  183. /// If transposition is selected for M0 or M1 then the given dimension represent the size of the matrix 'after' the transposion.
  184. /// d[drn,dcn] = alpha * op(m0[drn,m0cn_m1rn]) * op(m1[m0cn_m1rn,dcn]) + beta * d[drn,dcn]
  185. //// See enum { kTranpsoseM0Fl=0x01, kTransposeM1Fl=0x02 } in cmVectOps for flags.
  186. 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 );
  187. /// 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.
  188. 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 );
  189. /// d[drn,dcn] = m0[drn,m0cn] * m1[m1rn,dcn]
  190. 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 );
  191. /// same as MultMMM() except second source matrix is transposed prior to the multiply
  192. 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 );
  193. // Raise dbp[] to the power 'expon'
  194. VECT_OP_TYPE* VECT_OP_FUNC(PowVS)( VECT_OP_TYPE* dbp, unsigned dn, VECT_OP_TYPE expon );
  195. VECT_OP_TYPE* VECT_OP_FUNC(PowVVS)( VECT_OP_TYPE* dbp, unsigned dn, const VECT_OP_TYPE* sp, VECT_OP_TYPE expon );
  196. // Take the natural log of all values in sbp[dn]. It is allowable for sbp point to the same array as dbp=.
  197. VECT_OP_TYPE* VECT_OP_FUNC(LogV)( VECT_OP_TYPE* dbp, unsigned dn, const VECT_OP_TYPE* sbp );
  198. // Convert a magnitude (amplitude) spectrum to/from decibels.
  199. // It is allowable for dbp==sbp.
  200. VECT_OP_TYPE* VECT_OP_FUNC(AmplToDbVV)( VECT_OP_TYPE* dbp, unsigned dn, const VECT_OP_TYPE* sbp, VECT_OP_TYPE minDb );
  201. VECT_OP_TYPE* VECT_OP_FUNC(DbToAmplVV)( VECT_OP_TYPE* dbp, unsigned dn, const VECT_OP_TYPE* sbp);
  202. VECT_OP_TYPE* VECT_OP_FUNC(PowToDbVV)( VECT_OP_TYPE* dbp, unsigned dn, const VECT_OP_TYPE* sbp, VECT_OP_TYPE minDb );
  203. VECT_OP_TYPE* VECT_OP_FUNC(DbToPowVV)( VECT_OP_TYPE* dbp, unsigned dn, const VECT_OP_TYPE* sbp);
  204. /// Initialize dbp[dn,dn] as a square symetric positive definite matrix using values
  205. /// from a random uniform distribution. This is useful for initializing random
  206. /// covariance matrices as used by multivariate Gaussian distributions
  207. /// If t is non-NULL it must point to a block of scratch memory of t[dn,dn].
  208. /// If t is NULL then scratch memory is internally allocated and deallocated.
  209. VECT_OP_TYPE* VECT_OP_FUNC(RandSymPosDef)( VECT_OP_TYPE* dbp, unsigned dn, VECT_OP_TYPE* t );
  210. /// Compute the determinant of any square matrix.
  211. VECT_OP_TYPE VECT_OP_FUNC(DetM)( const VECT_OP_TYPE* sp, unsigned srn );
  212. /// Compute the determinant of a diagonal matrix.
  213. VECT_OP_TYPE VECT_OP_FUNC(DetDiagM)( const VECT_OP_TYPE* sp, unsigned srn);
  214. /// Compute the log determinant of any square matrix.
  215. VECT_OP_TYPE VECT_OP_FUNC(LogDetM)( const VECT_OP_TYPE* sp, unsigned srn );
  216. /// Compute the log determinant of a diagonal matrix.
  217. VECT_OP_TYPE VECT_OP_FUNC(LogDetDiagM)( const VECT_OP_TYPE* sp, unsigned srn);
  218. /// Compute the inverse of a square matrix. Returns NULL if the matrix is not invertable.
  219. /// 'drn' is the dimensionality of the data.
  220. VECT_OP_TYPE* VECT_OP_FUNC(InvM)( VECT_OP_TYPE* dp, unsigned drn );
  221. /// Compute the inverse of a diagonal matrix. Returns NULL if the matrix is not invertable.
  222. VECT_OP_TYPE* VECT_OP_FUNC(InvDiagM)( VECT_OP_TYPE* dp, unsigned drn );
  223. /// Solve a linear system of the form AX=B where A[an,an] is square.
  224. /// Since A is square B must have 'an' rows.
  225. /// Result is returned in B.
  226. /// Returns a pointer to B on success or NULL on fail.
  227. /// NOTE: Both A and B are overwritten by this operation.
  228. VECT_OP_TYPE* VECT_OP_FUNC(SolveLS)( VECT_OP_TYPE* A, unsigned an, VECT_OP_TYPE* B, unsigned bcn );
  229. /// Perform a Cholesky decomposition of the square symetric matrix U[un,un].
  230. /// The factorization has the form: A=U'TU.
  231. /// If the factorization is successful A is set to U and a pointer to A is returned.
  232. /// Note that the lower triangle of A is not overwritten. See CholZ().
  233. /// If the factorization fails NULL is returned.
  234. VECT_OP_TYPE* VECT_OP_FUNC(Chol)(VECT_OP_TYPE* A, unsigned an );
  235. /// Same as Chol() but sets the lower triangle of U to zero.
  236. /// This is equivalent ot the Matlab version.
  237. VECT_OP_TYPE* VECT_OP_FUNC(CholZ)(VECT_OP_TYPE* U, unsigned un );
  238. /// Return the average value of the contents of sbp[] between two fractional indexes
  239. VECT_OP_TYPE VECT_OP_FUNC(FracAvg)( double bi, double ei, const VECT_OP_TYPE* sbp, unsigned sn );
  240. /// Shrinking function - Decrease the size of sbp[] by averaging blocks of values into single values in dbp[]
  241. VECT_OP_TYPE* VECT_OP_FUNC(DownSampleAvg)( VECT_OP_TYPE* dbp, unsigned dn, const VECT_OP_TYPE* sbp, unsigned sn );
  242. /// Stretching function - linear interpolate between points in sbp[] to fill dbp[] ... where dn > sn
  243. VECT_OP_TYPE* VECT_OP_FUNC(UpSampleInterp)( VECT_OP_TYPE* dbp, unsigned dn, const VECT_OP_TYPE* sbp, unsigned sn );
  244. /// Stretch or shrink the sbp[] to fit into dbp[]
  245. VECT_OP_TYPE* VECT_OP_FUNC(FitToSize)( VECT_OP_TYPE* dbp, unsigned dn, const VECT_OP_TYPE* sbp, unsigned sn );
  246. /// Stretch or shrink sV[] to fit into dV[] using a simple linear mapping.
  247. /// When stretching (sn<dn) each source element is repeated dn/sn times
  248. /// and the last fraction position is interpolated. When shrinking
  249. /// (sn>dn) each dest value is formed by the average of sequential segments
  250. /// of sn/dn source elements. Fractional values are used at the beginning
  251. /// and end of each segment.
  252. VECT_OP_TYPE* VECT_OP_FUNC(LinearMap)(VECT_OP_TYPE* dV, unsigned dn, VECT_OP_TYPE* sV, unsigned sn );
  253. /// Generate a vector of uniformly distributed random numbers in the range minVal to maxVal.
  254. VECT_OP_TYPE* VECT_OP_FUNC(Random)( VECT_OP_TYPE* dbp, unsigned dn, VECT_OP_TYPE minVal, VECT_OP_TYPE maxVal );
  255. /// Generate dn random numbers integers between 0 and wn-1 based on a the relative
  256. /// weights in wp[wn]. Note thtat the weights do not have to sum to 1.0.
  257. unsigned* VECT_OP_FUNC(WeightedRandInt)( unsigned* dbp, unsigned dn, const VECT_OP_TYPE* wp, unsigned wn );
  258. /// Generate a vector of normally distributed univariate random numbers
  259. VECT_OP_TYPE* VECT_OP_FUNC(RandomGauss)( VECT_OP_TYPE* dbp, unsigned dn, VECT_OP_TYPE mean, VECT_OP_TYPE var );
  260. /// Generate a vector of normally distributed univariate random numbers where each value has been drawn from a
  261. /// seperately parameterized Gaussian distribution. meanV[] and varV[] must both contain dn velues.
  262. VECT_OP_TYPE* VECT_OP_FUNC(RandomGaussV)( VECT_OP_TYPE* dbp, unsigned dn, const VECT_OP_TYPE* meanV, const VECT_OP_TYPE* varV );
  263. /// Generate a matrix of multi-dimensional random values. Each column represents a single vector value and each row contains a dimension.
  264. /// meanV[] and varV[] must both contain drn elements where each meanV[i],varV[i] pair parameterize one dimensions Gaussian distribution.
  265. 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 );
  266. 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 );
  267. /// Generate a matrix of multivariate random values drawn from a normal distribution.
  268. /// The dimensionality of the values are 'drn'.
  269. /// The count of returned values is 'dcn'.
  270. /// meanV[drn] and covarM[drn,drn] parameterize the normal distribution.
  271. /// The covariance matrix must be symetric and positive definite.
  272. /// t[(drn*drn) ] points to scratch memory or is set to NULL if the function should
  273. /// allocate the memory internally.
  274. /// Based on octave function mvrnd.m.
  275. 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 );
  276. /// Same as RandomGaussNonDiagM() except requires the upper trianglular
  277. /// Cholesky factor of the covar matrix in 'uM'.
  278. 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 );
  279. /// Generate a matrix of N*K multi-dimensional data points.
  280. /// Where D is the dimensionality of the data. (D == drn).
  281. /// K is the number of multi-dimensional PDF's (clusters).
  282. /// N is the number of data points to generate per cluster.
  283. /// dbp[ D, N*K ] contains the returned data point.
  284. /// The first N columns is associated with the cluster 0,
  285. /// the next N columns is associated with cluster 1, ...
  286. /// meanM[ D, K ] and varM[D,K] parameterize the generating PDF.s for each cluster
  287. 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 );
  288. /// Generate the set of coordinates which describe a circle with a center at x,y.
  289. /// dbp[dn,2] must contain 2*dn elements. The first column holds the x coord and and the second holds the y coord.
  290. 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 );
  291. /// The following functions all return the phase of the next value.
  292. unsigned VECT_OP_FUNC(SynthSine)( VECT_OP_TYPE* dbp, unsigned dn, unsigned phase, double srate, double hz );
  293. unsigned VECT_OP_FUNC(SynthCosine)( VECT_OP_TYPE* dbp, unsigned dn, unsigned phase, double srate, double hz );
  294. unsigned VECT_OP_FUNC(SynthSquare)( VECT_OP_TYPE* dbp, unsigned dn, unsigned phase, double srate, double hz, unsigned otCnt );
  295. unsigned VECT_OP_FUNC(SynthTriangle)( VECT_OP_TYPE* dbp, unsigned dn, unsigned phase, double srate, double hz, unsigned otCnt );
  296. unsigned VECT_OP_FUNC(SynthSawtooth)( VECT_OP_TYPE* dbp, unsigned dn, unsigned phase, double srate, double hz, unsigned otCnt );
  297. unsigned VECT_OP_FUNC(SynthPulseCos)( VECT_OP_TYPE* dbp, unsigned dn, unsigned phase, double srate, double hz, unsigned otCnt );
  298. unsigned VECT_OP_FUNC(SynthImpulse)( VECT_OP_TYPE* dbp, unsigned dn, unsigned phase, double srate, double hz );
  299. unsigned VECT_OP_FUNC(SynthPhasor)( VECT_OP_TYPE* dbp, unsigned dn, unsigned phase, double srate, double hz );
  300. /// Return value should be passed back via delaySmp on the next call.
  301. VECT_OP_TYPE VECT_OP_FUNC(SynthPinkNoise)( VECT_OP_TYPE* dbp, unsigned dn, VECT_OP_TYPE delaySmp );
  302. /// Same as Matlab linspace() v[i] = i * (limit-1)/n
  303. VECT_OP_TYPE* VECT_OP_FUNC(LinSpace)( VECT_OP_TYPE* dbp, unsigned dn, VECT_OP_TYPE base, VECT_OP_TYPE limit );
  304. VECT_OP_TYPE* VECT_OP_FUNC(LinearToDb)( VECT_OP_TYPE* dbp, unsigned dn, const VECT_OP_TYPE* sp, VECT_OP_TYPE mult );
  305. VECT_OP_TYPE* VECT_OP_FUNC(dBToLinear)( VECT_OP_TYPE* dbp, unsigned dn, const VECT_OP_TYPE* sp, VECT_OP_TYPE mult );
  306. VECT_OP_TYPE* VECT_OP_FUNC(AmplitudeToDb)( VECT_OP_TYPE* dbp, unsigned dn, const VECT_OP_TYPE* sp );
  307. VECT_OP_TYPE* VECT_OP_FUNC(PowerToDb)( VECT_OP_TYPE* dbp, unsigned dn, const VECT_OP_TYPE* sp );
  308. VECT_OP_TYPE* VECT_OP_FUNC(dBToAmplitude)( VECT_OP_TYPE* dbp, unsigned dn, const VECT_OP_TYPE* sp );
  309. VECT_OP_TYPE* VECT_OP_FUNC(dBToPower)( VECT_OP_TYPE* dbp, unsigned dn, const VECT_OP_TYPE* sp );
  310. VECT_OP_TYPE VECT_OP_FUNC(KaiserBetaFromSidelobeReject)( double sidelobeRejectDb );
  311. VECT_OP_TYPE VECT_OP_FUNC(KaiserFreqResolutionFactor)( double sidelobeRejectDb );
  312. VECT_OP_TYPE* VECT_OP_FUNC(Kaiser)( VECT_OP_TYPE* dbp, unsigned dn, double beta );
  313. VECT_OP_TYPE* VECT_OP_FUNC(Gaussian)(VECT_OP_TYPE* dbp, unsigned dn, double mean, double variance );
  314. VECT_OP_TYPE* VECT_OP_FUNC(Hamming)( VECT_OP_TYPE* dbp, unsigned dn );
  315. VECT_OP_TYPE* VECT_OP_FUNC(Hann)( VECT_OP_TYPE* dbp, unsigned dn );
  316. VECT_OP_TYPE* VECT_OP_FUNC(Triangle)(VECT_OP_TYPE* dbp, unsigned dn );
  317. /// The MATLAB equivalent Hamming and Hann windows.
  318. //VECT_OP_TYPE* VECT_OP_FUNC(HammingMatlab)(VECT_OP_TYPE* dbp, unsigned dn );
  319. VECT_OP_TYPE* VECT_OP_FUNC(HannMatlab)( VECT_OP_TYPE* dbp, unsigned dn );
  320. /// Simulates the MATLAB GaussWin function. Set arg to 2.5 to simulate the default arg
  321. /// as used by MATLAB.
  322. VECT_OP_TYPE* VECT_OP_FUNC(GaussWin)( VECT_OP_TYPE* dbp, unsigned dn, double arg );
  323. /// Direct form II algorithm based on the MATLAB implmentation
  324. /// http://www.mathworks.com/access/helpdesk/help/techdoc/ref/filter.html#f83-1015962
  325. /// The only difference between this function and the equivalent MATLAB filter() function
  326. /// is that the first feedforward coeff is given as a seperate value. The first b coefficient
  327. /// in this function is therefore the same as the second coefficient in the MATLAB function.
  328. /// and the first a[] coefficient (which is generally set to 1.0) is skipped.
  329. /// Example:
  330. /// Matlab: b=[.5 .4 .3] a=[1 .2 .1]
  331. /// Equiv: b0 = .5 b=[ .4 .3] a=[ .2 .1];
  332. ///
  333. /// y[yn] - output vector
  334. /// x[xn] - input vector. xn must be <= yn. if xn < yn then the end of y[] is set to zero.
  335. /// b0 - signal scale. This can also be seen as b[0] (which is not included in b[])
  336. /// b[dn] - feedforward coeff's b[1..dn-1]
  337. /// a[dn] - feedback coeff's a[1..dn-1]
  338. /// d[dn+1] - delay registers - note that this array must be one element longer than the coeff arrays.
  339. ///
  340. 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 );
  341. struct cmFilter_str;
  342. //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 );
  343. 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 );
  344. /// Compute the coefficients of a low/high pass FIR filter
  345. /// See enum { kHighPass_LPSincFl=0x01, kNormalize_LPSincFl=0x02 } in acVectOps.h
  346. VECT_OP_TYPE* VECT_OP_FUNC(LP_Sinc)(VECT_OP_TYPE* dp, unsigned dn, double srate, double fcHz, unsigned flags );
  347. /// Compute the complex transient detection function from successive spectral frames.
  348. /// The spectral magntidue mag0V precedes mag1V and the phase (radians) spectrum phs0V precedes the phs1V which precedes phs2V.
  349. /// binCnt gives the length of each of the spectral vectors.
  350. 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 );
  351. /// Compute a set of filterCnt mel filter masks for wieghting magnitude spectra consisting of binCnt bins.
  352. /// The spectrum is divided into bandCnt equal bands in the mel domain
  353. /// Each row of the matrix contains the mask for a single filter band consisting of binCnt elements.
  354. /// See enum{ kShiftMelFl=0x01, kNormalizeMelFl=0x02 } in cmVectOps.h
  355. /// Set kShiftMelFl to shift the mel bands onto the nearest FFT bin.
  356. /// Set kNormalizeMelFl to normalize the combined filters for unity gain.
  357. VECT_OP_TYPE* VECT_OP_FUNC(MelMask)( VECT_OP_TYPE* maskMtx, unsigned bandCnt, unsigned binCnt, double srate, unsigned flags );
  358. /// Fill binIdxV[bandCnt] and cntV[bandCnt] with a bin to band map.
  359. /// binIdx[] contains the first (minimum) bin index for a given band.
  360. /// cntV[] contains the count of bins for each band.
  361. /// bandCnt is the number of bark bands to return
  362. /// The function returns the actual number of bands mapped which will always be <= 23.
  363. unsigned VECT_OP_FUNC(BarkMap)(unsigned* binIdxV, unsigned* cntV, unsigned bandCnt, unsigned binCnt, double srate );
  364. /// Calc a set of triangle fitler masks into each row of maskMtx.
  365. /// maskMtx[ bandCnt, binCnt ] - result matrix
  366. /// binHz - freq resolution of the output filters.
  367. /// stSpread - Semi-tone spread above and below each center frequency (stSpread*2) is the total bandwidth.
  368. /// (Only used if lowHzV or uprHzV are NULL)
  369. /// lowHz[ bandCnt ] - set of upper frequency limits for each band.
  370. /// ctrHz[ bandCnt ] set to the center value in Hz for each band
  371. /// uprHz[ bandCnt ] - set of lower frequency limits for each band.
  372. /// Note if lowHz[] and uprHz[] are set to NULL then stSpread is used to set the bandwidth of each band.
  373. 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 );
  374. /// Calculate a set of Bark band triangle filters into maskMtx.
  375. /// Each row of maskMtx contains the filter for one band.
  376. /// maskMtx[ bandCnt, binCnt ]
  377. /// bandCnt - the number of triangle bankds. If bandCnt is > 24 it will be reduced to 24.
  378. /// binCnt - the number of bins in the filters.
  379. /// binHz - the width of each bin in Hz.
  380. VECT_OP_TYPE* VECT_OP_FUNC(BarkMask)(VECT_OP_TYPE* maskMtx, unsigned bandCnt, unsigned binCnt, double binHz );
  381. // Terhardt 1979 (Calculating virtual pitch, Hearing Research #1, pp 155-182)
  382. // See enum { kNoTtmFlags=0, kModifiedTtmFl=0x01 } in cmVectOps.h
  383. VECT_OP_TYPE* VECT_OP_FUNC(TerhardtThresholdMask)(VECT_OP_TYPE* maskV, unsigned binCnt, double srate, unsigned flags);
  384. //Schroeder et al., 1979, JASA, Optimizing digital speech coders by exploiting masking properties of the human ear
  385. VECT_OP_TYPE* VECT_OP_FUNC(ShroederSpreadingFunc)(VECT_OP_TYPE* m, unsigned bandCnt, double srate);
  386. /// Compute a set of DCT-II coefficients. Result dp[ coeffCnt, filtCnt ]
  387. VECT_OP_TYPE* VECT_OP_FUNC(DctMatrix)( VECT_OP_TYPE* dp, unsigned coeffCnt, unsigned filtCnt );
  388. /// Set the indexes of local peaks greater than threshold in dbp[].
  389. /// Returns the number of peaks in dbp[]
  390. /// The maximum number of peaks from n source values is max(0,floor((n-1)/2)).
  391. /// Note that peaks will never be found at index 0 or index sn-1.
  392. unsigned VECT_OP_FUNC(PeakIndexes)( unsigned* dbp, unsigned dn, const VECT_OP_TYPE* sbp, unsigned sn, VECT_OP_TYPE threshold );
  393. /// Return the index of the bin containing v or acInvalidIdx if v is below sbp[0] or above sbp[ n-1 ]
  394. /// The bin limits are contained in sbp[].
  395. /// The value in spb[] are therefore expected to be in increasing order.
  396. /// The value returned will be in the range 0:sn-1.
  397. unsigned VECT_OP_FUNC(BinIndex)( const VECT_OP_TYPE* sbp, unsigned sn, VECT_OP_TYPE v );
  398. /// Assign each data point to one of k clusters using an expectation-maximization algorithm.
  399. /// k gives the number of clusters to identify
  400. /// Each column of sp[ srn, scn ] contains a multidimensional data point.
  401. /// srn therefore defines the dimensionality of the data.
  402. /// Each column of centroidV[ srn, k ] is set to the centroid of each of k clusters.
  403. /// classIdxV[ scn ] assigns the index (0 to k-1) of a cluster to each soure data point
  404. /// The function returns the number of iterations required for the EM process to converge.
  405. /// selIdxV[ scn ] is optional and contains a list of id's assoc'd with each column of sM.
  406. /// selKey is a integer value.
  407. /// If selIdxV is non-NULL then only columns of sM[] where selIdxV[] == selKey will be clustered.
  408. /// All columns of sM[] where the associated column in selIdxV[] do not match will be ignored.
  409. /// Set 'initFromCentroidFl' to true if the initial centroids should be taken from centroidM[].
  410. /// otherwise the initial centroids are selected from 'k' random data points in sp[].
  411. /// The distance function distFunc(cV,dV,dN) is called to determine the distance from a
  412. /// centroid the centroid 'cV[dN]' to a data point 'dV[dN]'. 'dN' is the dimensionality of the
  413. /// feature vector and is therefore equal to 'srn'.
  414. unsigned VECT_OP_FUNC(Kmeans)(
  415. unsigned* classIdxV,
  416. VECT_OP_TYPE* centroidM,
  417. unsigned k,
  418. const VECT_OP_TYPE* sp,
  419. unsigned srn,
  420. unsigned scn,
  421. const unsigned* selIdxV,
  422. unsigned selKey,
  423. bool initFromCentroidFl,
  424. VECT_OP_TYPE (*distFunc)( void* userPtr, const VECT_OP_TYPE* cV, const VECT_OP_TYPE* dV, unsigned dN ),
  425. void* userDistPtr );
  426. /// 'srcFunc() should return NULL if the data point located at 'frmIdx' should not be included in the clustering.
  427. /// Clustering is considered to be complete after 'maxIterCnt' iterations or when
  428. /// 'deltaStopCnt' or fewer data points change class on a single iteration
  429. unsigned VECT_OP_FUNC(Kmeans2)(
  430. unsigned* classIdxV, // classIdxV[scn] - data point class assignments
  431. VECT_OP_TYPE* centroidM, // centroidM[srn,K] - cluster centroids
  432. unsigned K, // count of clusters
  433. const VECT_OP_TYPE* (*srcFunc)(void* userPtr, unsigned frmIdx ),
  434. unsigned srn, // dimensionality of each data point
  435. unsigned scn, // count of data points
  436. void* userSrcPtr, // callback data for srcFunc
  437. VECT_OP_TYPE (*distFunc)( void* userPtr, const VECT_OP_TYPE* cV, const VECT_OP_TYPE* dV, unsigned dN ),
  438. void* userDistPtr, // arg. to distFunc()
  439. int iterCnt, // max. number of iterations (-1 to ignore)
  440. int deltaStopCnt); // if less than deltaStopCnt data points change classes on a given iteration then convergence occurs.
  441. /// Evaluate the univariate normal distribution defined by 'mean' and 'stdDev'.
  442. 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 );
  443. /// Evaluate a multivariate normal distribution defined by meanV[D] and covarM[D,D]
  444. /// at the data points held in the columns of xM[D,N]. Return the evaluation
  445. /// results in the vector yV[N]. D is the dimensionality of the data. N is the number of
  446. /// data points to evaluate and values to return in yV[N].
  447. /// Set diagFl to true if covarM is diagonal.
  448. /// The function fails and returns false if the covariance matrix is singular.
  449. 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 );
  450. /// Same as multVarGaussPDF[] except takes the inverse covar mtx invCovarM[D,D]
  451. /// and log determinant of covar mtx.
  452. /// Always returns yV[].
  453. 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 );
  454. /// Same as multVarGaussPDF[] except uses a function to obtain the data vectors.
  455. /// srcFunc() can filter the data points by returning NULL if the data vector at frmIdx should
  456. /// not be evaluated against the PDF. In this case yV[frmIdx] will be set to 0.
  457. VECT_OP_TYPE* VECT_OP_FUNC(MultVarGaussPDF3)(
  458. VECT_OP_TYPE* yV,
  459. const VECT_OP_TYPE* (*srcFunc)(void* funcDataPtr, unsigned frmIdx ),
  460. void* funcDataPtr,
  461. const VECT_OP_TYPE* meanV,
  462. const VECT_OP_TYPE* invCovarM,
  463. VECT_OP_TYPE logDet,
  464. unsigned D,
  465. unsigned N,
  466. bool diagFl );
  467. /// Determine the most likely state sequece stateV[timeN] given a
  468. /// transition matrix a[stateN,stateN],
  469. /// observation probability matrix b[stateN,timeN] and
  470. /// initial state probability vector phi[stateN].
  471. /// a[i,j] is the probability of transitioning from state i to state j.
  472. /// b[i,t] is the probability of state i emitting the obj t.
  473. 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 );
  474. /// Clip the line defined by x0,y0 to x1,y1 into the rect defined by xMin,yMin xMax,yMax.
  475. 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 );
  476. /// Return true if the line defined by x0,y0 to x1,y1 intersects with
  477. /// the rectangle formed by xMin,yMin - xMax,yMax
  478. 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 );
  479. /// Return the perpendicular distance from the line formed by x0,y0 and x1,y1
  480. /// and the point px,py
  481. 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);
  482. /// Calculate the best fit line: b0 + b1*x_i through the points x_i,y_i.
  483. /// Set x to NULL if it uses sequential integers [0,1,2,3...]
  484. 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 );
  485. /// Given the points x0[xy0N],y0[xy0N] fill y1[i] with the interpolated value of y0[] at
  486. /// x1[i]. Note that x0[] and x1[] must be increasing monotonic.
  487. /// This function is similar to the octave interp1() function.
  488. 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 );