libcm is a C development framework with an emphasis on audio signal processing applications.
Você não pode selecionar mais de 25 tópicos Os tópicos devem começar com uma letra ou um número, podem incluir traços ('-') e podem ter até 35 caracteres.

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