libcm is a C development framework with an emphasis on audio signal processing applications.
Vous ne pouvez pas sélectionner plus de 25 sujets Les noms de sujets doivent commencer par une lettre ou un nombre, peuvent contenir des tirets ('-') et peuvent comporter jusqu'à 35 caractères.

cmVectOpsRICode.h 28KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208
  1. #ifdef cmVectOpsRICode_h
  2. VECT_OP_TYPE* VECT_OP_FUNC(Col)( VECT_OP_TYPE* m, unsigned ci, unsigned rn, unsigned cn )
  3. {
  4. assert(ci<cn);
  5. return m + (ci*rn);
  6. }
  7. VECT_OP_TYPE* VECT_OP_FUNC(Row)( VECT_OP_TYPE* m, unsigned ri, unsigned rn, unsigned cn )
  8. {
  9. assert(ri<rn);
  10. return m + ri;
  11. }
  12. VECT_OP_TYPE* VECT_OP_FUNC(ElePtr)( VECT_OP_TYPE* m, unsigned ri, unsigned ci, unsigned rn, unsigned cn )
  13. {
  14. assert(ri<rn && ci<cn);
  15. return m + (ci*rn) + ri;
  16. }
  17. VECT_OP_TYPE VECT_OP_FUNC(Ele)( VECT_OP_TYPE* m, unsigned ri, unsigned ci, unsigned rn, unsigned cn )
  18. { return *VECT_OP_FUNC(ElePtr)(m,ri,ci,rn,cn); }
  19. void VECT_OP_FUNC(Set)( VECT_OP_TYPE* m, unsigned ri, unsigned ci, unsigned rn, unsigned cn, VECT_OP_TYPE v )
  20. { *(VECT_OP_FUNC(ElePtr)(m,ri,ci,rn,cn)) = v; }
  21. const VECT_OP_TYPE* VECT_OP_FUNC(CCol)( const VECT_OP_TYPE* m, unsigned ci, unsigned rn, unsigned cn )
  22. {
  23. assert(ci<cn);
  24. return m + (ci*rn);
  25. }
  26. const VECT_OP_TYPE* VECT_OP_FUNC(CRow)( const VECT_OP_TYPE* m, unsigned ri, unsigned rn, unsigned cn )
  27. {
  28. assert(ri<rn);
  29. return m + ri;
  30. }
  31. const VECT_OP_TYPE* VECT_OP_FUNC(CElePtr)( const VECT_OP_TYPE* m, unsigned ri, unsigned ci, unsigned rn, unsigned cn )
  32. {
  33. assert(ri<rn && ci<cn);
  34. return m + (ci*rn) + ri;
  35. }
  36. VECT_OP_TYPE VECT_OP_FUNC(CEle)( const VECT_OP_TYPE* m, unsigned ri, unsigned ci, unsigned rn, unsigned cn )
  37. { return *VECT_OP_FUNC(CElePtr)(m,ri,ci,rn,cn); }
  38. VECT_OP_TYPE* VECT_OP_FUNC(Fill)( VECT_OP_TYPE* dbp, unsigned dn, VECT_OP_TYPE value )
  39. {
  40. const VECT_OP_TYPE* dep = dbp + dn;
  41. VECT_OP_TYPE* dp = dbp;
  42. if( value == 0 )
  43. memset(dbp,0,(dep-dbp)*sizeof(VECT_OP_TYPE));
  44. else
  45. {
  46. while( dbp < dep )
  47. *dbp++ = value;
  48. }
  49. return dp;
  50. }
  51. VECT_OP_TYPE* VECT_OP_FUNC(Zero)( VECT_OP_TYPE* dbp, unsigned dn )
  52. {
  53. memset( dbp, 0, sizeof(VECT_OP_TYPE)*dn);
  54. return dbp;
  55. }
  56. VECT_OP_TYPE* VECT_OP_FUNC(Move)( VECT_OP_TYPE* bp, unsigned bn, const VECT_OP_TYPE* sp )
  57. {
  58. memmove(bp,sp,sizeof(VECT_OP_TYPE)*bn);
  59. return bp;
  60. }
  61. VECT_OP_TYPE* VECT_OP_FUNC(Copy)( VECT_OP_TYPE* bp, unsigned bn, const VECT_OP_TYPE* sp )
  62. {
  63. memcpy(bp,sp,sizeof(VECT_OP_TYPE)*bn);
  64. return bp;
  65. }
  66. VECT_OP_TYPE* VECT_OP_FUNC(CopyN)( VECT_OP_TYPE* bp, unsigned bn, unsigned d_stride, const VECT_OP_TYPE* sp, unsigned s_stride )
  67. {
  68. VECT_OP_TYPE* dbp = bp;
  69. const VECT_OP_TYPE* ep = bp + (bn*d_stride);
  70. for(; bp < ep; bp += d_stride, sp += s_stride )
  71. *bp = *sp;
  72. return dbp;
  73. }
  74. VECT_OP_TYPE* VECT_OP_FUNC(CopyU)( VECT_OP_TYPE* bp, unsigned bn, const unsigned* sp )
  75. {
  76. VECT_OP_TYPE* dbp = bp;
  77. const VECT_OP_TYPE* ep = bp + bn;
  78. VECT_OP_TYPE* dp = bp;
  79. while( dp < ep )
  80. *dp++ = (VECT_OP_TYPE)*sp++;
  81. return dbp;
  82. }
  83. VECT_OP_TYPE* VECT_OP_FUNC(CopyI)( VECT_OP_TYPE* dbp, unsigned dn, const int* sp )
  84. {
  85. const VECT_OP_TYPE* dep = dbp + dn;
  86. VECT_OP_TYPE* dp = dbp;
  87. while( dp < dep )
  88. *dp++ = (VECT_OP_TYPE)*sp++;
  89. return dbp;
  90. }
  91. VECT_OP_TYPE* VECT_OP_FUNC(CopyF)( VECT_OP_TYPE* dbp, unsigned dn, const float* sp )
  92. {
  93. const VECT_OP_TYPE* dep = dbp + dn;
  94. VECT_OP_TYPE* dp = dbp;
  95. while( dp < dep )
  96. *dp++ = (VECT_OP_TYPE)*sp++;
  97. return dbp;
  98. }
  99. VECT_OP_TYPE* VECT_OP_FUNC(CopyD)( VECT_OP_TYPE* dbp, unsigned dn, const double* sp )
  100. {
  101. const VECT_OP_TYPE* dep = dbp + dn;
  102. VECT_OP_TYPE* dp = dbp;
  103. while( dp < dep )
  104. *dp++ = (VECT_OP_TYPE)*sp++;
  105. return dbp;
  106. }
  107. VECT_OP_TYPE* VECT_OP_FUNC(CopyS)( VECT_OP_TYPE* dbp, unsigned dn, const cmSample_t* sp )
  108. {
  109. const VECT_OP_TYPE* dep = dbp + dn;
  110. VECT_OP_TYPE* dp = dbp;
  111. while( dp < dep )
  112. *dp++ = (VECT_OP_TYPE)*sp++;
  113. return dbp;
  114. }
  115. VECT_OP_TYPE* VECT_OP_FUNC(CopyR)( VECT_OP_TYPE* dbp, unsigned dn, const cmReal_t* sp )
  116. {
  117. const VECT_OP_TYPE* dep = dbp + dn;
  118. VECT_OP_TYPE* dp = dbp;
  119. while( dp < dep )
  120. *dp++ = (VECT_OP_TYPE)*sp++;
  121. return dbp;
  122. }
  123. VECT_OP_TYPE* VECT_OP_FUNC(CopyStride)( VECT_OP_TYPE* dbp, unsigned dn, const VECT_OP_TYPE* sp, unsigned srcStride )
  124. {
  125. const VECT_OP_TYPE* dep = dbp + dn;
  126. VECT_OP_TYPE* dp = dbp;
  127. for(; dp < dep; sp += srcStride )
  128. *dp++ = *sp;
  129. return dbp;
  130. }
  131. VECT_OP_TYPE* VECT_OP_FUNC(Shrink)( VECT_OP_TYPE* s, unsigned sn, const VECT_OP_TYPE* t, unsigned tn )
  132. {
  133. assert( s <= t && t <= (s+sn) );
  134. assert( s <= (t+tn) && (t+tn) <= (s+sn));
  135. //VECT_OP_FUNC(Move)(s,sn - ((t - s) + tn),t+tn);
  136. VECT_OP_FUNC(Move)((VECT_OP_TYPE*)t,(sn - ((t+tn)-s)) + 1,t+tn);
  137. return s;
  138. }
  139. VECT_OP_TYPE* VECT_OP_FUNC(Expand)( VECT_OP_TYPE* s, unsigned sn, const VECT_OP_TYPE* t, unsigned tn )
  140. {
  141. assert( s <= t && t <= s+sn );
  142. unsigned i = t - s;
  143. s = cmMemResizeP(VECT_OP_TYPE,s,sn+tn);
  144. t = s + i;
  145. assert( t + tn + sn - i == s + sn + tn );
  146. VECT_OP_FUNC(Move)(((VECT_OP_TYPE*)t)+tn,sn-i,t);
  147. return s;
  148. }
  149. VECT_OP_TYPE* VECT_OP_FUNC(Replace)(VECT_OP_TYPE* s, unsigned* sn, const VECT_OP_TYPE* t, unsigned tn, const VECT_OP_TYPE* u, unsigned un )
  150. {
  151. // if s is empty and t[tn] is empty
  152. if( s == NULL && tn == 0 )
  153. {
  154. if( un == 0 )
  155. return s;
  156. s = cmMemAllocZ(VECT_OP_TYPE,un);
  157. VECT_OP_FUNC(Copy)(s,un,u);
  158. if( sn != NULL )
  159. *sn = un;
  160. return s;
  161. }
  162. assert( s!=NULL && t != NULL );
  163. assert( (u!=NULL && un>0) || (u==NULL && un==0) );
  164. if( (tn==0 && un==0) || (t==NULL && u==NULL))
  165. return s;
  166. // if the area to replace is greater than the area to insert ...
  167. if( tn > un )
  168. {
  169. VECT_OP_FUNC(Shrink)(s,*sn,t+un,tn-un); // ... then shrink the buffer
  170. *sn -= tn-un;
  171. }
  172. else
  173. // if the area to insert is greater than the area to replace ...
  174. if( un > tn )
  175. {
  176. unsigned offs = t - s;
  177. s = VECT_OP_FUNC(Expand)(s,*sn,t+tn,un-tn); // ... then expand the buffer
  178. t = s + offs;
  179. *sn += un-tn;
  180. }
  181. assert(t+un <= s+(*sn));
  182. if( u!=NULL )
  183. VECT_OP_FUNC(Copy)((VECT_OP_TYPE*)t,un,u);
  184. return s;
  185. }
  186. VECT_OP_TYPE* VECT_OP_FUNC(Rotate)( VECT_OP_TYPE* dbp, unsigned dn, int shiftCnt )
  187. {
  188. VECT_OP_TYPE* dep = dbp + dn;
  189. int i = 0;
  190. unsigned k = 0;
  191. int n = dep - dbp;
  192. VECT_OP_TYPE t1 = dbp[i];
  193. for(k=0; k<n; ++k)
  194. {
  195. int j;
  196. j = (i + shiftCnt) % n;
  197. if( j<0 )
  198. j += n;
  199. VECT_OP_TYPE t2 = dbp[j];
  200. dbp[j] = t1;
  201. t1 = t2;
  202. i = j;
  203. }
  204. return dbp;
  205. }
  206. VECT_OP_TYPE* VECT_OP_FUNC(RotateM)( VECT_OP_TYPE* dbp, unsigned drn, unsigned dcn, const VECT_OP_TYPE* sbp, int rShiftCnt, int cShiftCnt )
  207. {
  208. int j;
  209. while( rShiftCnt < 0 )
  210. rShiftCnt += drn;
  211. while( cShiftCnt < 0 )
  212. cShiftCnt += dcn;
  213. int m = rShiftCnt % drn;
  214. int n = cShiftCnt % dcn;
  215. for(j=0; j<dcn; ++j,++n)
  216. {
  217. if(n==dcn)
  218. n = 0;
  219. // cnt from dst position to end of column
  220. unsigned cn = drn - m;
  221. // copy from top of src col to bottom of dst column
  222. VECT_OP_FUNC(Copy)(dbp + (n*drn) + m, cn, sbp );
  223. sbp+=cn;
  224. if( cn < drn )
  225. {
  226. // copy from bottom of src col to top of dst column
  227. VECT_OP_FUNC(Copy)(dbp + (n*drn), drn-cn, sbp );
  228. sbp += drn-cn;
  229. }
  230. }
  231. return dbp;
  232. }
  233. VECT_OP_TYPE* VECT_OP_FUNC(Shift)( VECT_OP_TYPE* dbp, unsigned dn, int shiftCnt, VECT_OP_TYPE fillValue )
  234. {
  235. VECT_OP_TYPE* dep = dbp + dn;
  236. VECT_OP_TYPE* rp = dbp;
  237. unsigned n = dep - dbp;
  238. if( shiftCnt == 0 )
  239. return dbp;
  240. if( abs(shiftCnt) >= n )
  241. return VECT_OP_FUNC(Fill)(dbp,dn,fillValue);
  242. if( shiftCnt > 0 )
  243. {
  244. const VECT_OP_TYPE* sbp = dep - (shiftCnt+1);
  245. const VECT_OP_TYPE* sep = dbp;
  246. VECT_OP_TYPE* dp = dbp + (n-1);
  247. while( sbp >= sep )
  248. *dp-- = *sbp--;
  249. while(dbp <= dp )
  250. *dbp++ = fillValue;
  251. }
  252. else
  253. {
  254. const VECT_OP_TYPE* sbp = dbp + abs(shiftCnt);
  255. while( sbp < dep )
  256. *dbp++ = *sbp++;
  257. while(dbp<dep)
  258. *dbp++ = fillValue;
  259. }
  260. return rp;
  261. }
  262. VECT_OP_TYPE* VECT_OP_FUNC(Flip)( VECT_OP_TYPE* dbp, unsigned dn)
  263. {
  264. VECT_OP_TYPE* p0 = dbp;
  265. VECT_OP_TYPE* p1 = dbp + dn - 1;
  266. while( p0 < p1 )
  267. {
  268. VECT_OP_TYPE t = *p0;
  269. *p0++ = *p1;
  270. *p1-- = t;
  271. }
  272. return dbp;
  273. }
  274. VECT_OP_TYPE* VECT_OP_FUNC(SubVS)( VECT_OP_TYPE* bp, unsigned n, VECT_OP_TYPE v )
  275. {
  276. const VECT_OP_TYPE* ep = bp + n;
  277. VECT_OP_TYPE* dp = bp;
  278. while( dp < ep )
  279. *dp++ -= v;
  280. return bp;
  281. }
  282. VECT_OP_TYPE* VECT_OP_FUNC(SubVV)( VECT_OP_TYPE* bp, unsigned n, const VECT_OP_TYPE* v )
  283. {
  284. const VECT_OP_TYPE* ep = bp + n;
  285. VECT_OP_TYPE* dp = bp;
  286. while( dp < ep )
  287. *dp++ -= *v++;
  288. return bp;
  289. }
  290. VECT_OP_TYPE* VECT_OP_FUNC(SubVVS)( VECT_OP_TYPE* bp, unsigned n, const VECT_OP_TYPE* v, VECT_OP_TYPE s )
  291. {
  292. const VECT_OP_TYPE* ep = bp + n;
  293. VECT_OP_TYPE* dp = bp;
  294. while( dp < ep )
  295. *dp++ = *v++ - s;
  296. return bp;
  297. }
  298. VECT_OP_TYPE* VECT_OP_FUNC(SubVVNN)(VECT_OP_TYPE* dp, unsigned dn, unsigned dnn, const VECT_OP_TYPE* v, unsigned n )
  299. {
  300. const VECT_OP_TYPE* ep = dp + (dn*dnn);
  301. VECT_OP_TYPE* dbp = dp;
  302. for(; dp < ep; dp+=dnn, v+=n )
  303. *dp -= *v;
  304. return dbp;
  305. }
  306. VECT_OP_TYPE* VECT_OP_FUNC(SubVVV)( VECT_OP_TYPE* dbp, unsigned dn, const VECT_OP_TYPE* sb0p, const VECT_OP_TYPE* sb1p )
  307. {
  308. const VECT_OP_TYPE* dep = dbp + dn;
  309. VECT_OP_TYPE* dp = dbp;
  310. while( dbp < dep )
  311. *dbp++ = *sb0p++ - *sb1p++;
  312. return dp;
  313. }
  314. VECT_OP_TYPE* VECT_OP_FUNC(SubVSV)( VECT_OP_TYPE* dbp, unsigned dn, const VECT_OP_TYPE s0, const VECT_OP_TYPE* sb1p )
  315. {
  316. const VECT_OP_TYPE* dep = dbp + dn;
  317. VECT_OP_TYPE* dp = dbp;
  318. while( dbp < dep )
  319. *dbp++ = s0 - *sb1p++;
  320. return dp;
  321. }
  322. VECT_OP_TYPE* VECT_OP_FUNC(AddVS)( VECT_OP_TYPE* bp, unsigned n, VECT_OP_TYPE v )
  323. {
  324. const VECT_OP_TYPE* ep = bp + n;
  325. VECT_OP_TYPE* dp = bp;
  326. while( dp < ep )
  327. *dp++ += v;
  328. return bp;
  329. }
  330. VECT_OP_TYPE* VECT_OP_FUNC(AddVV)( VECT_OP_TYPE* bp, unsigned bn, const VECT_OP_TYPE* v )
  331. {
  332. const VECT_OP_TYPE* ep = bp + bn;
  333. VECT_OP_TYPE* dp = bp;
  334. while( dp < ep )
  335. *dp++ += *v++;
  336. return bp;
  337. }
  338. VECT_OP_TYPE* VECT_OP_FUNC(AddVVS)( VECT_OP_TYPE* bp, unsigned bn, const VECT_OP_TYPE* v, VECT_OP_TYPE s )
  339. {
  340. const VECT_OP_TYPE* ep = bp + bn;
  341. VECT_OP_TYPE* dp = bp;
  342. while( dp < ep )
  343. *dp++ = *v++ + s;
  344. return bp;
  345. }
  346. VECT_OP_TYPE* VECT_OP_FUNC(AddVVNN)(VECT_OP_TYPE* dp, unsigned dn, unsigned dnn, const VECT_OP_TYPE* v, unsigned n )
  347. {
  348. const VECT_OP_TYPE* ep = dp + (dn*dnn);
  349. VECT_OP_TYPE* dbp = dp;
  350. for(; dp < ep; v+=n, dp+=dnn )
  351. *dp += *v;
  352. return dbp;
  353. }
  354. VECT_OP_TYPE* VECT_OP_FUNC(AddVVV)( VECT_OP_TYPE* dbp, unsigned dn, const VECT_OP_TYPE* sb0p, const VECT_OP_TYPE* sb1p )
  355. {
  356. const VECT_OP_TYPE* dep = dbp + dn;
  357. VECT_OP_TYPE* dp = dbp;
  358. while( dbp < dep )
  359. *dbp++ = *sb0p++ + *sb1p++;
  360. return dp;
  361. }
  362. VECT_OP_TYPE* VECT_OP_FUNC(MultVVV)( VECT_OP_TYPE* dbp, unsigned dn, const VECT_OP_TYPE* sb0p, const VECT_OP_TYPE* sb1p )
  363. {
  364. const VECT_OP_TYPE* dep = dbp + dn;
  365. VECT_OP_TYPE* dp = dbp;
  366. while( dbp < dep )
  367. *dbp++ = *sb0p++ * *sb1p++;
  368. return dp;
  369. }
  370. VECT_OP_TYPE* VECT_OP_FUNC(MultVV)( VECT_OP_TYPE* dbp, unsigned dn, const VECT_OP_TYPE* sbp )
  371. {
  372. const VECT_OP_TYPE* dep = dbp + dn;
  373. VECT_OP_TYPE* dp = dbp;
  374. while( dbp < dep )
  375. *dbp++ *= *sbp++;
  376. return dp;
  377. }
  378. VECT_OP_TYPE* VECT_OP_FUNC(MultVVNN)(VECT_OP_TYPE* dp, unsigned dn, unsigned dnn, const VECT_OP_TYPE* v, unsigned n )
  379. {
  380. const VECT_OP_TYPE* ep = dp + (dn*dnn);
  381. VECT_OP_TYPE* dbp = dp;
  382. for(; dp < ep; v+=n, dp+=dnn )
  383. *dp *= *v;
  384. return dbp;
  385. }
  386. VECT_OP_TYPE* VECT_OP_FUNC(MultVS)( VECT_OP_TYPE* dbp, unsigned dn, VECT_OP_TYPE s )
  387. {
  388. const VECT_OP_TYPE* dep = dbp + dn;
  389. VECT_OP_TYPE* dp = dbp;
  390. while( dbp < dep )
  391. *dbp++ *= s;
  392. return dp;
  393. }
  394. VECT_OP_TYPE* VECT_OP_FUNC(MultVVS)( VECT_OP_TYPE* dbp, unsigned dn, const VECT_OP_TYPE* sbp, VECT_OP_TYPE s )
  395. {
  396. const VECT_OP_TYPE* dep = dbp + dn;
  397. VECT_OP_TYPE* dp = dbp;
  398. while( dbp < dep )
  399. *dbp++ = *sbp++ * s;
  400. return dp;
  401. }
  402. VECT_OP_TYPE* VECT_OP_FUNC(MultVaVS)( VECT_OP_TYPE* dbp, unsigned dn, const VECT_OP_TYPE* sbp, VECT_OP_TYPE s )
  403. {
  404. const VECT_OP_TYPE* dep = dbp + dn;
  405. VECT_OP_TYPE* dp = dbp;
  406. while( dbp < dep )
  407. *dbp++ += *sbp++ * s;
  408. return dp;
  409. }
  410. VECT_OP_TYPE* VECT_OP_FUNC(DivVVS)( VECT_OP_TYPE* dbp, unsigned dn, const VECT_OP_TYPE* sb0p, VECT_OP_TYPE s1 )
  411. {
  412. const VECT_OP_TYPE* dep = dbp + dn;
  413. VECT_OP_TYPE* dp = dbp;
  414. while( dbp < dep )
  415. *dbp++ = *sb0p++ / s1;
  416. return dp;
  417. }
  418. VECT_OP_TYPE* VECT_OP_FUNC(DivVV)( VECT_OP_TYPE* dbp, unsigned dn, const VECT_OP_TYPE* sb0p )
  419. {
  420. const VECT_OP_TYPE* dep = dbp + dn;
  421. VECT_OP_TYPE* dp = dbp;
  422. while( dbp < dep )
  423. *dbp++ /= *sb0p++;
  424. return dp;
  425. }
  426. VECT_OP_TYPE* VECT_OP_FUNC(DivVVV)( VECT_OP_TYPE* dbp, unsigned dn, const VECT_OP_TYPE* sb0p, const VECT_OP_TYPE* sb1p )
  427. {
  428. const VECT_OP_TYPE* dep = dbp + dn;
  429. VECT_OP_TYPE* dp = dbp;
  430. while( dbp < dep )
  431. *dbp++ = *sb0p++ / *sb1p++;
  432. return dp;
  433. }
  434. VECT_OP_TYPE* VECT_OP_FUNC(DivVVNN)(VECT_OP_TYPE* dp, unsigned dn, unsigned dnn, const VECT_OP_TYPE* v, unsigned n )
  435. {
  436. const VECT_OP_TYPE* ep = dp + (dn*dnn);
  437. VECT_OP_TYPE* dbp = dp;
  438. for(; dp < ep; v+=n, dp+=dnn )
  439. *dp /= *v;
  440. return dbp;
  441. }
  442. VECT_OP_TYPE* VECT_OP_FUNC(DivVS)( VECT_OP_TYPE* dbp, unsigned dn, VECT_OP_TYPE s )
  443. {
  444. const VECT_OP_TYPE* dep = dbp + dn;
  445. VECT_OP_TYPE* dp = dbp;
  446. while( dbp < dep )
  447. *dbp++ /= s;
  448. return dp;
  449. }
  450. VECT_OP_TYPE* VECT_OP_FUNC(DivVSV)( VECT_OP_TYPE* dbp, unsigned dn, const VECT_OP_TYPE s0, const VECT_OP_TYPE* sb1p )
  451. {
  452. const VECT_OP_TYPE* dep = dbp + dn;
  453. VECT_OP_TYPE* dp = dbp;
  454. while( dbp < dep )
  455. *dbp++ = s0 / *sb1p++;
  456. return dp;
  457. }
  458. VECT_OP_TYPE* VECT_OP_FUNC(DivVVZ)( VECT_OP_TYPE* dbp, unsigned dn, const VECT_OP_TYPE* sb0p )
  459. {
  460. const VECT_OP_TYPE* dep = dbp + dn;
  461. VECT_OP_TYPE* dp = dbp;
  462. for(; dbp < dep; ++sb0p )
  463. if( *sb0p == 0 )
  464. *dbp++ = 0;
  465. else
  466. *dbp++ /= *sb0p;
  467. return dp;
  468. }
  469. VECT_OP_TYPE* VECT_OP_FUNC(DivVVVZ)( VECT_OP_TYPE* dbp, unsigned dn, const VECT_OP_TYPE* sb0p, const VECT_OP_TYPE* sb1p )
  470. {
  471. const VECT_OP_TYPE* dep = dbp + dn;
  472. VECT_OP_TYPE* dp = dbp;
  473. for(; dbp < dep; ++sb0p,++sb1p )
  474. if( *sb1p == 0 )
  475. *dbp++ = 0;
  476. else
  477. *dbp++ = *sb0p / *sb1p;
  478. return dp;
  479. }
  480. VECT_OP_TYPE* VECT_OP_FUNC(DivMS)( VECT_OP_TYPE* dp, unsigned drn, unsigned dcn, const VECT_OP_TYPE* sp )
  481. {
  482. unsigned i;
  483. for(i=0; i<dcn; ++i)
  484. VECT_OP_FUNC(DivVS)( dp + i*drn, drn, sp[i] );
  485. return dp;
  486. }
  487. VECT_OP_TYPE VECT_OP_FUNC(Sum)( const VECT_OP_TYPE* bp, unsigned n )
  488. {
  489. const VECT_OP_TYPE* ep = bp + n;
  490. VECT_OP_TYPE s = 0;
  491. while( bp < ep )
  492. s += *bp++;
  493. return s;
  494. }
  495. VECT_OP_TYPE VECT_OP_FUNC(SumN)( const VECT_OP_TYPE* bp, unsigned n, unsigned stride )
  496. {
  497. const VECT_OP_TYPE* ep = bp + (n*stride);
  498. VECT_OP_TYPE s = 0;
  499. for(; bp < ep; bp += stride )
  500. s += *bp;
  501. return s;
  502. }
  503. VECT_OP_TYPE* VECT_OP_FUNC(SumM)(const VECT_OP_TYPE* sp, unsigned srn, unsigned scn, VECT_OP_TYPE* dp )
  504. {
  505. unsigned i;
  506. for(i=0; i<scn; ++i)
  507. dp[i] = VECT_OP_FUNC(Sum)(sp + (i*srn), srn );
  508. return dp;
  509. }
  510. VECT_OP_TYPE* VECT_OP_FUNC(SumMN)(const VECT_OP_TYPE* sp, unsigned srn, unsigned scn, VECT_OP_TYPE* dp )
  511. {
  512. unsigned i;
  513. for(i=0; i<srn; ++i)
  514. dp[i] = VECT_OP_FUNC(SumN)(sp + i, scn, srn );
  515. return dp;
  516. }
  517. VECT_OP_TYPE* VECT_OP_FUNC(Abs)( VECT_OP_TYPE* dbp, unsigned dn )
  518. {
  519. unsigned i;
  520. for(i=0; i<dn; ++i)
  521. if( dbp[i]<0 )
  522. dbp[i] = -dbp[i];
  523. return dbp;
  524. }
  525. // mi is a target value - it holds the number of elements in ap[an] which must be be less than the median value.
  526. // If the initial array contains an even number of values then the median value is formed by averaging the two center values.
  527. // In this case *evenFlPtr is set and used to indicate that the center-upper value must be found during undwinding.
  528. VECT_OP_TYPE VECT_OP_FUNC(MedianSearch)( unsigned mi, const VECT_OP_TYPE* ap, unsigned an, bool* evenFlPtr )
  529. {
  530. VECT_OP_TYPE x = ap[0]; // pick a random value as a potential median value
  531. VECT_OP_TYPE a1[ an ]; // values below x
  532. VECT_OP_TYPE a3[ an ]; // values above x
  533. unsigned a1n = 0;
  534. unsigned a2n = 0; // values equal to x
  535. unsigned a3n = 0;
  536. const VECT_OP_TYPE* abp = ap;
  537. const VECT_OP_TYPE* aep = abp + an;
  538. for(; abp < aep; ++abp )
  539. {
  540. if( *abp < x )
  541. a1[a1n++] = *abp;
  542. else
  543. {
  544. if( *abp > x )
  545. a3[a3n++] = *abp;
  546. else
  547. ++a2n;
  548. }
  549. }
  550. //printf("%i : %i %i %i\n",mi,a1n,a2n,a3n);
  551. // there are more values below x (mi remains the target split point)
  552. if( a1n > mi )
  553. {
  554. x = VECT_OP_FUNC(MedianSearch)(mi,a1,a1n,evenFlPtr);
  555. }
  556. else
  557. {
  558. // the target was located
  559. if( a1n+a2n >= mi )
  560. {
  561. // if a1n alone matches mi then the max value in a1[] holds the median value otherwise x is the median
  562. if(a1n>=1 && a1n==mi)
  563. {
  564. VECT_OP_TYPE mv = VECT_OP_FUNC(Max)(a1,a1n,1);
  565. x = *evenFlPtr ? (mv+x)/2 : mv;
  566. *evenFlPtr = false;
  567. }
  568. // if the evenFl is set then the closest value above the median (x) must be located
  569. if( *evenFlPtr )
  570. {
  571. // if the next greater value is in a2[]
  572. if( a2n > 1 && (a1n+a2n) > mi )
  573. *evenFlPtr = false;
  574. else
  575. // if the next greater value is in a3[]
  576. if( a3n > 1 )
  577. {
  578. x = (x + VECT_OP_FUNC(Min)(a3,a3n,1))/2;
  579. *evenFlPtr = false;
  580. }
  581. }
  582. // no need for unwind processing - all the possibilities at this level have been exhausted
  583. return x;
  584. }
  585. else
  586. {
  587. // There are more values above x - the median must therefore be in a3[].
  588. // Reset mi cmcounting for the fact that we know that there are
  589. // a1n+a2n values below the lowest value in a3.
  590. x = VECT_OP_FUNC(MedianSearch)(mi - (a1n+a2n), a3, a3n, evenFlPtr );
  591. }
  592. }
  593. if( *evenFlPtr )
  594. {
  595. // find the first value greater than x
  596. while( ap < aep && *ap <= x )
  597. ++ap;
  598. if( ap < aep )
  599. {
  600. VECT_OP_TYPE v = *ap++;
  601. // find the nearest value greater than x
  602. for(; ap < aep; ++ap )
  603. if( *ap > x && ((*ap - x) < (v-x)))
  604. v = *ap;
  605. x = (v + x)/2;
  606. *evenFlPtr = false;
  607. }
  608. }
  609. return x;
  610. }
  611. VECT_OP_TYPE VECT_OP_FUNC(Median)( const VECT_OP_TYPE* bp, unsigned n )
  612. {
  613. bool evenFl = cmIsEvenU(n);
  614. unsigned medIdx = evenFl ? n/2 : (n+1)/2;
  615. return VECT_OP_FUNC(MedianSearch)( medIdx, bp, n, &evenFl );
  616. }
  617. unsigned VECT_OP_FUNC(MinIndex)( const VECT_OP_TYPE* bp, unsigned n, unsigned stride )
  618. {
  619. const VECT_OP_TYPE* ep = bp + (n*stride);
  620. if( bp >= ep )
  621. return cmInvalidIdx;
  622. const VECT_OP_TYPE* p = bp;
  623. const VECT_OP_TYPE* mp = bp;
  624. bp+=stride;
  625. for(; bp < ep; bp+=stride )
  626. if( *bp < *mp )
  627. mp = bp;
  628. return (mp - p)/stride;
  629. }
  630. unsigned VECT_OP_FUNC(MaxIndex)( const VECT_OP_TYPE* bp, unsigned n, unsigned stride )
  631. {
  632. const VECT_OP_TYPE* ep = bp + (n*stride);
  633. if( bp >= ep )
  634. return cmInvalidIdx;
  635. const VECT_OP_TYPE* p = bp;
  636. const VECT_OP_TYPE* mp = bp;
  637. bp+=stride;
  638. for(; bp < ep; bp+=stride )
  639. if( *bp > *mp )
  640. mp = bp;
  641. return (mp - p)/stride;
  642. }
  643. VECT_OP_TYPE VECT_OP_FUNC(Min)( const VECT_OP_TYPE* bp, unsigned n, unsigned stride )
  644. {
  645. unsigned i;
  646. if((i = VECT_OP_FUNC(MinIndex)(bp,n,stride)) == cmInvalidIdx )
  647. {
  648. assert(0);
  649. return 0;
  650. }
  651. return bp[i*stride];
  652. }
  653. VECT_OP_TYPE VECT_OP_FUNC(Max)( const VECT_OP_TYPE* bp, unsigned n, unsigned stride )
  654. {
  655. unsigned i;
  656. if((i = VECT_OP_FUNC(MaxIndex)(bp,n,stride)) == cmInvalidIdx )
  657. {
  658. assert(0);
  659. return 0;
  660. }
  661. return bp[i*stride];
  662. }
  663. VECT_OP_TYPE* VECT_OP_FUNC(MinVV)( VECT_OP_TYPE* dp, unsigned dn, const VECT_OP_TYPE* sp )
  664. {
  665. unsigned i;
  666. for(i=0; i<dn; ++i)
  667. if( sp[i] < dp[i] )
  668. dp[i] = sp[i];
  669. return dp;
  670. }
  671. VECT_OP_TYPE* VECT_OP_FUNC(MaxVV)( VECT_OP_TYPE* dp, unsigned dn, const VECT_OP_TYPE* sp )
  672. {
  673. unsigned i;
  674. for(i=0; i<dn; ++i)
  675. if( sp[i] > dp[i] )
  676. dp[i] = sp[i];
  677. return dp;
  678. }
  679. unsigned* VECT_OP_FUNC(MinIndexM)( unsigned* dp, const VECT_OP_TYPE* sp, unsigned srn, unsigned scn )
  680. {
  681. unsigned i = 0;
  682. for(i=0; i<scn; ++i)
  683. dp[i] = VECT_OP_FUNC(MinIndex)(sp + (i*srn), srn, 1 );
  684. return dp;
  685. }
  686. unsigned* VECT_OP_FUNC(MaxIndexM)( unsigned* dp, const VECT_OP_TYPE* sp, unsigned srn, unsigned scn )
  687. {
  688. unsigned i = 0;
  689. for(i=0; i<scn; ++i)
  690. dp[i] = VECT_OP_FUNC(MaxIndex)(sp + (i*srn), srn, 1 );
  691. return dp;
  692. }
  693. VECT_OP_TYPE VECT_OP_FUNC(Mode)( const VECT_OP_TYPE* sp, unsigned sn )
  694. {
  695. unsigned n[sn];
  696. VECT_OP_TYPE v[sn];
  697. unsigned i,j,k = 0;
  698. unsigned n0 = 0; // idx of most freq occurring ele
  699. unsigned n1 = -1; // idx of 2nd most freq occurring ele
  700. for(i=0; i<sn; ++i)
  701. {
  702. // find sp[i] in v[]
  703. for(j=0; j<k; ++j)
  704. if( sp[i] == v[j] )
  705. {
  706. ++n[j];
  707. break;
  708. }
  709. // sp[i] was not found in v[]
  710. if( k == j )
  711. {
  712. v[j] = sp[i];
  713. n[j] = 1;
  714. ++k;
  715. }
  716. // n[j] holds frq of sp[i]
  717. // do nothing if j is already most freq
  718. if( j != n0 )
  719. {
  720. // if j is new most freq
  721. if( n[j] > n[n0] )
  722. {
  723. n1 = n0;
  724. n0 = j;
  725. }
  726. else
  727. // if j is 2nd most freq
  728. if( (n1==-1) || (n[j] > n[n1]) )
  729. n1 = j;
  730. }
  731. // if diff between two most freq is greater than remaining ele's
  732. if( (n1!=-1) && (n[n0]-n[n1]) >= (sn-i) )
  733. break;
  734. }
  735. // if there are no ele's with same count
  736. if( n[n0] > n[n1] )
  737. return v[n0];
  738. // break tie between ele's with same count be returning min value
  739. // (this is the same as Matlab tie break criteria)
  740. j = 0;
  741. for(i=1; i<k; ++i)
  742. if( (n[i] > n[j]) || (n[i] == n[j] && v[i] < v[j]) )
  743. j=i;
  744. return v[j];
  745. }
  746. unsigned VECT_OP_FUNC(Find)( const VECT_OP_TYPE* sp, unsigned sn, VECT_OP_TYPE key )
  747. {
  748. const VECT_OP_TYPE* sbp = sp;
  749. const VECT_OP_TYPE* ep = sp + sn;
  750. while( sp<ep )
  751. if( *sp++ == key )
  752. break;
  753. if( sp==ep )
  754. return cmInvalidIdx;
  755. return (sp-1) - sbp;
  756. }
  757. unsigned VECT_OP_FUNC(Count)( const VECT_OP_TYPE* sp, unsigned sn, VECT_OP_TYPE key )
  758. {
  759. unsigned cnt = 0;
  760. const VECT_OP_TYPE* ep = sp + sn;
  761. while( sp<ep )
  762. if( *sp++ == key )
  763. ++cnt;
  764. return cnt;
  765. }
  766. VECT_OP_TYPE* VECT_OP_FUNC(ReplaceLte)( VECT_OP_TYPE* dp, unsigned dn, const VECT_OP_TYPE* sp, VECT_OP_TYPE lteKeyVal, VECT_OP_TYPE replaceVal )
  767. {
  768. VECT_OP_TYPE* rp = dp;
  769. const VECT_OP_TYPE* ep = dp + dn;
  770. for(; dp < ep; ++sp )
  771. *dp++ = *sp <= lteKeyVal ? replaceVal : *sp;
  772. return rp;
  773. }
  774. VECT_OP_TYPE* VECT_OP_FUNC(Diag)( VECT_OP_TYPE* dbp, unsigned n, const VECT_OP_TYPE* sbp )
  775. {
  776. unsigned i,j;
  777. for(i=0,j=0; i<n && j<n; ++i,++j)
  778. dbp[ (i*n) + j ] = sbp[i];
  779. return dbp;
  780. }
  781. VECT_OP_TYPE* VECT_OP_FUNC(DiagZ)(VECT_OP_TYPE* dbp, unsigned n, const VECT_OP_TYPE* sbp )
  782. {
  783. VECT_OP_FUNC(Fill)(dbp,n*n,0);
  784. return VECT_OP_FUNC(Diag)(dbp,n,sbp);
  785. }
  786. VECT_OP_TYPE* VECT_OP_FUNC(Identity)( VECT_OP_TYPE* dbp, unsigned rn, unsigned cn )
  787. {
  788. unsigned i,j;
  789. for(i=0,j=0; i<cn && j<rn; ++i,++j)
  790. dbp[ (i*rn) + j ] = 1;
  791. return dbp;
  792. }
  793. VECT_OP_TYPE* VECT_OP_FUNC(IdentityZ)( VECT_OP_TYPE* dbp, unsigned rn, unsigned cn )
  794. {
  795. VECT_OP_FUNC(Fill)(dbp,rn*cn,0);
  796. return VECT_OP_FUNC(Identity)(dbp,rn,cn);
  797. }
  798. VECT_OP_TYPE* VECT_OP_FUNC(Transpose)( VECT_OP_TYPE* dbp, const VECT_OP_TYPE* sp, unsigned srn, unsigned scn )
  799. {
  800. VECT_OP_TYPE* dp = dbp;
  801. const VECT_OP_TYPE* dep = dbp + (srn*scn);
  802. while( dbp < dep )
  803. {
  804. const VECT_OP_TYPE* sbp = sp++;
  805. const VECT_OP_TYPE* sep = sbp + (srn*scn);
  806. for(; sbp < sep; sbp+=srn )
  807. *dbp++ = *sbp;
  808. }
  809. return dp;
  810. }
  811. VECT_OP_TYPE VECT_OP_FUNC(Seq)( VECT_OP_TYPE* dbp, unsigned dn, VECT_OP_TYPE beg, VECT_OP_TYPE incr )
  812. {
  813. const VECT_OP_TYPE* dep = dbp + dn;
  814. unsigned i = 0;
  815. for(; dbp<dep; ++i)
  816. *dbp++ = beg + (incr*i);
  817. return beg + (incr*i);
  818. }
  819. void VECT_OP_FUNC(FnThresh)( const VECT_OP_TYPE* xV, unsigned xN, unsigned wndN, VECT_OP_TYPE* yV, unsigned yStride, VECT_OP_TYPE (*fnPtr)(const VECT_OP_TYPE*, unsigned) )
  820. {
  821. int i0 = cmIsOddU(wndN) ? (wndN-1)/2 : wndN/2;
  822. int i1 = cmIsOddU(wndN) ? (wndN-1)/2 : wndN/2 - 1;
  823. int i,j;
  824. i0 = -i0;
  825. if( fnPtr == NULL )
  826. fnPtr = &(VECT_OP_FUNC(Median));
  827. for(i=0; i<xN; ++i,++i0,++i1)
  828. {
  829. j = (i*yStride);
  830. if( i0 < 0 )
  831. if( i1 >= xN )
  832. yV[j] = (*fnPtr)(xV,xN);
  833. else
  834. yV[j] = (*fnPtr)(xV,i1+1);
  835. else if( i1 >= xN )
  836. yV[j] = (*fnPtr)(xV+i0,xN-i0);
  837. else
  838. yV[j] = (*fnPtr)(xV+i0,wndN);
  839. }
  840. }
  841. void VECT_OP_FUNC(MedianFilt)( const VECT_OP_TYPE* xV, unsigned xN, unsigned wndN, VECT_OP_TYPE* yV, unsigned yStride )
  842. {
  843. int i0 = cmIsOddU(wndN) ? (wndN-1)/2 : wndN/2;
  844. int i1 = cmIsOddU(wndN) ? (wndN-1)/2 : wndN/2 - 1;
  845. int i,j;
  846. VECT_OP_TYPE tV[ wndN ];
  847. i0 = -i0;
  848. VECT_OP_FUNC(Fill)(tV,wndN,0);
  849. for(i=0; i<xN; ++i,++i0,++i1)
  850. {
  851. j = (i*yStride);
  852. // note that the position of the zero padding in tV[]
  853. // does not matter because the median calcluation does
  854. // not make any assumptions about the order of the argument
  855. // vector.
  856. if( i0 < 0 )
  857. {
  858. VECT_OP_FUNC(Copy)(tV,wndN+i0,xV);
  859. VECT_OP_FUNC(Fill)(tV+wndN+i0,labs(i0),0);
  860. //VECT_OP_FUNC(Print)(NULL,1,wndN,tV,-1,-1);
  861. yV[j] = VECT_OP_FUNC(Median)(tV,wndN);
  862. continue;
  863. }
  864. if( i1 >= xN )
  865. {
  866. VECT_OP_FUNC(Copy)(tV,wndN-(i1-xN+1),xV+i0);
  867. VECT_OP_FUNC(Fill)(tV+wndN-(i1-xN+1),i1-xN+1,0);
  868. //VECT_OP_FUNC(Print)(NULL,1,wndN,tV,-1,-1);
  869. yV[j] = VECT_OP_FUNC(Median)(tV,wndN);
  870. continue;
  871. }
  872. //VECT_OP_FUNC(Print)(NULL,1,wndN,xV+i0,-1,-1);
  873. yV[j] = VECT_OP_FUNC(Median)(xV+i0,wndN);
  874. }
  875. }
  876. unsigned* VECT_OP_FUNC(LevEditDistAllocMtx)(unsigned maxN)
  877. {
  878. maxN += 1;
  879. unsigned* m = cmMemAllocZ(unsigned,maxN*maxN);
  880. unsigned* p = m;
  881. unsigned i;
  882. // initialize the comparison matrix with the default costs in the
  883. // first row and column
  884. // (Note that this matrix is not oriented in column major order like most 'cm' matrices.)
  885. for(i=0; i<maxN; ++i)
  886. {
  887. p[i] = i; // 0th row
  888. p[ i * maxN ] = i; // 0th col
  889. }
  890. return m;
  891. }
  892. double VECT_OP_FUNC(LevEditDist)(unsigned mtxMaxN, unsigned* m, const VECT_OP_TYPE* s0, int n0, const VECT_OP_TYPE* s1, int n1, unsigned maxN )
  893. {
  894. mtxMaxN += 1;
  895. assert( n0 < mtxMaxN && n1 < mtxMaxN );
  896. int v = 0;
  897. unsigned i;
  898. // Note that m[maxN,maxN] is not oriented in column major order like most 'cm' matrices.
  899. for(i=1; i<n0+1; ++i)
  900. {
  901. unsigned ii = i * mtxMaxN; // current row
  902. unsigned i_1 = ii - mtxMaxN; // previous row
  903. unsigned j;
  904. for( j=1; j<n1+1; ++j)
  905. {
  906. int cost = s0[i-1] == s1[j-1] ? 0 : 1;
  907. //m[i][j] = min( m[i-1][j] + 1, min( m[i][j-1] + 1, m[i-1][j-1] + cost ) );
  908. m[ ii + j ] = v = cmMin( m[ i_1 + j] + 1, cmMin( m[ ii + j - 1] + 1, m[ i_1 + j - 1 ] + cost ) );
  909. }
  910. }
  911. return (double) v / maxN;
  912. }
  913. double VECT_OP_FUNC(LevEditDistWithCostThresh)( int mtxMaxN, unsigned* m, const VECT_OP_TYPE* s0, int n0, const VECT_OP_TYPE* s1, int n1, double maxCost, unsigned maxN )
  914. {
  915. mtxMaxN += 1;
  916. int v = 0;
  917. maxCost = cmMin(1.0,cmMax(0.0,maxCost));
  918. int iMaxCost = ceil( maxCost * maxN );
  919. assert( iMaxCost > 0 && maxCost > 0 );
  920. // If the two strings are different lengths and the min possible distance is
  921. // greater than the threshold then return the threshold as the cost.
  922. // (Note: For strings of different length the min possible distance is the
  923. // difference in length between the two strings).
  924. if( abs(n0-n1) > iMaxCost )
  925. return maxCost;
  926. int i;
  927. // for each row in the matrix ...
  928. for(i=1; i<n0+1; ++i)
  929. {
  930. int ii = i * mtxMaxN; // current row
  931. int i_1 = ii - mtxMaxN; // previous row
  932. // Limit the row to (2*iMaxCost)+1 diagnal strip.
  933. // This strip is based on the idea that the best case can be precomputed for
  934. // all matrix elements in advance - where the best case for position i,j is:
  935. // abs(i-j). This can be justified based on the idea that the least possible
  936. // distance between two strings of length i and j is abs(i-1). The minimum least
  937. // possible distance is therefore found on the matrix diagnal and grows as the
  938. // distance from the diagnal increases.
  939. int ji = cmMax( 1, i - iMaxCost );
  940. int jn = cmMin(iMaxCost + i, n1) + 1;
  941. int j;
  942. // fill in (max cost + 1) as the value in the column before the starting column
  943. // (it will be referred to during the first computation in this row)
  944. if( ji >= 2 )
  945. m[ ii + (ji-1) ] = iMaxCost + 1;
  946. // for each column in the diagnal stripe - beginning with the leftmost column.
  947. for( j=ji; j<jn; ++j)
  948. {
  949. int cost = s0[i-1] == s1[j-1] ? 0 : 1;
  950. m[ ii + j ] = v = cmMin( m[ i_1 + j] + 1, cmMin( m[ ii + j - 1] + 1, m[ i_1 + j - 1 ] + cost ) );
  951. }
  952. // fill in (max cost + 1) in the column following the last column
  953. // (it will be referred to during computation of the following row)
  954. if( j < n1+1 )
  955. m[ii + j] = iMaxCost + 1;
  956. }
  957. assert( v >= 0 );
  958. return cmMin( maxCost , (double) v / maxN);
  959. }
  960. #endif