1 /*
2 * File: findpeaks.c
3 *
4 * MATLAB Coder version : 3.1
5 * C/C++ source code generated on : 22-Apr-2021 15:58:03
6 */
7
8 /* Include Files */
9 #include "rt_nonfinite.h"
10 #include "matlabfindpeaks.h"
11 #include "findpeaks.h"
12 #include "matlabfindpeaks_emxutil.h"
13 #include "sort1.h"
14 #include "diff.h"
15 #include "sign.h"
16
17 /* Function Declarations */
18 static void findLocalMaxima(const double yTemp[52000], emxArray_real_T *iPk,
19 emxArray_real_T *iInflect);
20 static double rt_roundd_snf(double u);
21
22 /* Function Definitions */
23
24 /*
25 * Arguments : const double yTemp[52000]
26 * emxArray_real_T *iPk
27 * emxArray_real_T *iInflect
28 * Return Type : void
29 */
30 static void findLocalMaxima(const double yTemp[52000], emxArray_real_T *iPk,
31 emxArray_real_T *iInflect)
32 {
33 static double b_yTemp[52002];
34 boolean_T yFinite[52002];
35 int ii;
36 boolean_T x[52001];
37 emxArray_int32_T *b_ii;
38 int idx;
39 int i2;
40 boolean_T exitg3;
41 emxArray_int32_T *r0;
42 boolean_T guard3 = false;
43 int loop_ub;
44 emxArray_real_T *iTemp;
45 emxArray_real_T *c_yTemp;
46 emxArray_real_T *s;
47 emxArray_real_T *r1;
48 int x_size_idx_0;
49 boolean_T x_data[52000];
50 emxArray_int32_T *c_ii;
51 boolean_T exitg2;
52 boolean_T guard2 = false;
53 emxArray_int32_T *d_ii;
54 boolean_T exitg1;
55 boolean_T guard1 = false;
56 b_yTemp[0] = rtNaN;
57 memcpy(&b_yTemp[1], &yTemp[0], 52000U * sizeof(double));
58 b_yTemp[52001] = rtNaN;
59 for (ii = 0; ii < 52002; ii++) {
60 yFinite[ii] = !rtIsNaN(b_yTemp[ii]);
61 }
62
63 for (ii = 0; ii < 52001; ii++) {
64 x[ii] = ((b_yTemp[ii] != b_yTemp[ii + 1]) && (yFinite[ii] || yFinite[ii + 1]));
65 }
66
67 emxInit_int32_T(&b_ii, 1);
68 idx = 0;
69 i2 = b_ii->size[0];
70 b_ii->size[0] = 52001;
71 emxEnsureCapacity((emxArray__common *)b_ii, i2, (int)sizeof(int));
72 ii = 1;
73 exitg3 = false;
74 while ((!exitg3) && (ii < 52002)) {
75 guard3 = false;
76 if (x[ii - 1]) {
77 idx++;
78 b_ii->data[idx - 1] = ii;
79 if (idx >= 52001) {
80 exitg3 = true;
81 } else {
82 guard3 = true;
83 }
84 } else {
85 guard3 = true;
86 }
87
88 if (guard3) {
89 ii++;
90 }
91 }
92
93 emxInit_int32_T(&r0, 1);
94 i2 = b_ii->size[0];
95 if (1 > idx) {
96 b_ii->size[0] = 0;
97 } else {
98 b_ii->size[0] = idx;
99 }
100
101 emxEnsureCapacity((emxArray__common *)b_ii, i2, (int)sizeof(int));
102 i2 = r0->size[0];
103 r0->size[0] = 1 + b_ii->size[0];
104 emxEnsureCapacity((emxArray__common *)r0, i2, (int)sizeof(int));
105 r0->data[0] = 1;
106 loop_ub = b_ii->size[0];
107 for (i2 = 0; i2 < loop_ub; i2++) {
108 r0->data[i2 + 1] = b_ii->data[i2] + 1;
109 }
110
111 emxFree_int32_T(&b_ii);
112 emxInit_real_T(&iTemp, 1);
113 i2 = iTemp->size[0];
114 iTemp->size[0] = r0->size[0];
115 emxEnsureCapacity((emxArray__common *)iTemp, i2, (int)sizeof(double));
116 loop_ub = r0->size[0];
117 for (i2 = 0; i2 < loop_ub; i2++) {
118 iTemp->data[i2] = 1.0 + (double)(r0->data[i2] - 1);
119 }
120
121 emxFree_int32_T(&r0);
122 emxInit_real_T(&c_yTemp, 1);
123 i2 = c_yTemp->size[0];
124 c_yTemp->size[0] = iTemp->size[0];
125 emxEnsureCapacity((emxArray__common *)c_yTemp, i2, (int)sizeof(double));
126 loop_ub = iTemp->size[0];
127 for (i2 = 0; i2 < loop_ub; i2++) {
128 c_yTemp->data[i2] = b_yTemp[(int)iTemp->data[i2] - 1];
129 }
130
131 emxInit_real_T(&s, 1);
132 emxInit_real_T(&r1, 1);
133 diff(c_yTemp, s);
134 b_sign(s);
135 diff(s, r1);
136 x_size_idx_0 = r1->size[0];
137 loop_ub = r1->size[0];
138 emxFree_real_T(&c_yTemp);
139 for (i2 = 0; i2 < loop_ub; i2++) {
140 x_data[i2] = (r1->data[i2] < 0.0);
141 }
142
143 emxFree_real_T(&r1);
144 emxInit_int32_T(&c_ii, 1);
145 idx = 0;
146 i2 = c_ii->size[0];
147 c_ii->size[0] = x_size_idx_0;
148 emxEnsureCapacity((emxArray__common *)c_ii, i2, (int)sizeof(int));
149 ii = 1;
150 exitg2 = false;
151 while ((!exitg2) && (ii <= x_size_idx_0)) {
152 guard2 = false;
153 if (x_data[ii - 1]) {
154 idx++;
155 c_ii->data[idx - 1] = ii;
156 if (idx >= x_size_idx_0) {
157 exitg2 = true;
158 } else {
159 guard2 = true;
160 }
161 } else {
162 guard2 = true;
163 }
164
165 if (guard2) {
166 ii++;
167 }
168 }
169
170 if (x_size_idx_0 == 1) {
171 if (idx == 0) {
172 i2 = c_ii->size[0];
173 c_ii->size[0] = 0;
174 emxEnsureCapacity((emxArray__common *)c_ii, i2, (int)sizeof(int));
175 }
176 } else {
177 i2 = c_ii->size[0];
178 if (1 > idx) {
179 c_ii->size[0] = 0;
180 } else {
181 c_ii->size[0] = idx;
182 }
183
184 emxEnsureCapacity((emxArray__common *)c_ii, i2, (int)sizeof(int));
185 }
186
187 if (1 > s->size[0] - 1) {
188 loop_ub = 0;
189 } else {
190 loop_ub = s->size[0] - 1;
191 }
192
193 if (2 > s->size[0]) {
194 i2 = 0;
195 } else {
196 i2 = 1;
197 }
198
199 for (ii = 0; ii < loop_ub; ii++) {
200 x_data[ii] = (s->data[ii] != s->data[i2 + ii]);
201 }
202
203 emxFree_real_T(&s);
204 emxInit_int32_T(&d_ii, 1);
205 idx = 0;
206 i2 = d_ii->size[0];
207 d_ii->size[0] = loop_ub;
208 emxEnsureCapacity((emxArray__common *)d_ii, i2, (int)sizeof(int));
209 ii = 1;
210 exitg1 = false;
211 while ((!exitg1) && (ii <= loop_ub)) {
212 guard1 = false;
213 if (x_data[ii - 1]) {
214 idx++;
215 d_ii->data[idx - 1] = ii;
216 if (idx >= loop_ub) {
217 exitg1 = true;
218 } else {
219 guard1 = true;
220 }
221 } else {
222 guard1 = true;
223 }
224
225 if (guard1) {
226 ii++;
227 }
228 }
229
230 if (loop_ub == 1) {
231 if (idx == 0) {
232 i2 = d_ii->size[0];
233 d_ii->size[0] = 0;
234 emxEnsureCapacity((emxArray__common *)d_ii, i2, (int)sizeof(int));
235 }
236 } else {
237 i2 = d_ii->size[0];
238 if (1 > idx) {
239 d_ii->size[0] = 0;
240 } else {
241 d_ii->size[0] = idx;
242 }
243
244 emxEnsureCapacity((emxArray__common *)d_ii, i2, (int)sizeof(int));
245 }
246
247 i2 = iInflect->size[0];
248 iInflect->size[0] = d_ii->size[0];
249 emxEnsureCapacity((emxArray__common *)iInflect, i2, (int)sizeof(double));
250 loop_ub = d_ii->size[0];
251 for (i2 = 0; i2 < loop_ub; i2++) {
252 iInflect->data[i2] = iTemp->data[d_ii->data[i2]] - 1.0;
253 }
254
255 emxFree_int32_T(&d_ii);
256 i2 = iPk->size[0];
257 iPk->size[0] = c_ii->size[0];
258 emxEnsureCapacity((emxArray__common *)iPk, i2, (int)sizeof(double));
259 loop_ub = c_ii->size[0];
260 for (i2 = 0; i2 < loop_ub; i2++) {
261 iPk->data[i2] = iTemp->data[c_ii->data[i2]] - 1.0;
262 }
263
264 emxFree_int32_T(&c_ii);
265 emxFree_real_T(&iTemp);
266 }
267
268 /*
269 * Arguments : double u
270 * Return Type : double
271 */
272 static double rt_roundd_snf(double u)
273 {
274 double y;
275 if (fabs(u) < 4.503599627370496E+15) {
276 if (u >= 0.5) {
277 y = floor(u + 0.5);
278 } else if (u > -0.5) {
279 y = u * 0.0;
280 } else {
281 y = ceil(u - 0.5);
282 }
283 } else {
284 y = u;
285 }
286
287 return y;
288 }
289
290 /*
291 * Arguments : const double y[52000]
292 * const emxArray_real_T *iPk
293 * int Pd
294 * emxArray_real_T *idx
295 * Return Type : void
296 */
297 void c_findPeaksSeparatedByMoreThanM(const double y[52000], const
298 emxArray_real_T *iPk, int Pd, emxArray_real_T *idx)
299 {
300 emxArray_real_T *locs;
301 emxArray_real_T *locs_temp;
302 emxArray_boolean_T *idelete;
303 emxArray_real_T *c_sortIdx;
304 emxArray_boolean_T *r2;
305 emxArray_int32_T *iidx;
306 emxArray_real_T *b_y;
307 int i3;
308 int ndbl;
309 int apnd;
310 int cdiff;
311 int absb;
312 double d0;
313 emxInit_real_T(&locs, 1);
314 emxInit_real_T(&locs_temp, 1);
315 emxInit_boolean_T(&idelete, 1);
316 emxInit_real_T(&c_sortIdx, 1);
317 emxInit_boolean_T(&r2, 1);
318 emxInit_int32_T(&iidx, 1);
319 emxInit_real_T1(&b_y, 2);
320 if ((iPk->size[0] == 0) || (Pd == 0)) {
321 if (iPk->size[0] < 1) {
322 ndbl = 0;
323 apnd = 0;
324 } else {
325 ndbl = (int)floor(((double)iPk->size[0] - 1.0) + 0.5);
326 apnd = ndbl + 1;
327 cdiff = (ndbl - iPk->size[0]) + 1;
328 absb = iPk->size[0];
329 if (fabs(cdiff) < 4.4408920985006262E-16 * (double)absb) {
330 ndbl++;
331 apnd = iPk->size[0];
332 } else if (cdiff > 0) {
333 apnd = ndbl;
334 } else {
335 ndbl++;
336 }
337 }
338
339 i3 = b_y->size[0] * b_y->size[1];
340 b_y->size[0] = 1;
341 b_y->size[1] = ndbl;
342 emxEnsureCapacity((emxArray__common *)b_y, i3, (int)sizeof(double));
343 if (ndbl > 0) {
344 b_y->data[0] = 1.0;
345 if (ndbl > 1) {
346 b_y->data[ndbl - 1] = apnd;
347 cdiff = (ndbl - 1) / 2;
348 for (absb = 1; absb < cdiff; absb++) {
349 b_y->data[absb] = 1.0 + (double)absb;
350 b_y->data[(ndbl - absb) - 1] = apnd - absb;
351 }
352
353 if (cdiff << 1 == ndbl - 1) {
354 b_y->data[cdiff] = (1.0 + (double)apnd) / 2.0;
355 } else {
356 b_y->data[cdiff] = 1.0 + (double)cdiff;
357 b_y->data[cdiff + 1] = apnd - cdiff;
358 }
359 }
360 }
361
362 i3 = idx->size[0];
363 idx->size[0] = b_y->size[1];
364 emxEnsureCapacity((emxArray__common *)idx, i3, (int)sizeof(double));
365 cdiff = b_y->size[1];
366 for (i3 = 0; i3 < cdiff; i3++) {
367 idx->data[i3] = b_y->data[b_y->size[0] * i3];
368 }
369 } else {
370 i3 = locs->size[0];
371 locs->size[0] = iPk->size[0];
372 emxEnsureCapacity((emxArray__common *)locs, i3, (int)sizeof(double));
373 cdiff = iPk->size[0];
374 for (i3 = 0; i3 < cdiff; i3++) {
375 locs->data[i3] = 1.0 + (double)((int)iPk->data[i3] - 1);
376 }
377
378 i3 = locs_temp->size[0];
379 locs_temp->size[0] = iPk->size[0];
380 emxEnsureCapacity((emxArray__common *)locs_temp, i3, (int)sizeof(double));
381 cdiff = iPk->size[0];
382 for (i3 = 0; i3 < cdiff; i3++) {
383 locs_temp->data[i3] = y[(int)iPk->data[i3] - 1];
384 }
385
386 sort(locs_temp, iidx);
387 i3 = c_sortIdx->size[0];
388 c_sortIdx->size[0] = iidx->size[0];
389 emxEnsureCapacity((emxArray__common *)c_sortIdx, i3, (int)sizeof(double));
390 cdiff = iidx->size[0];
391 for (i3 = 0; i3 < cdiff; i3++) {
392 c_sortIdx->data[i3] = iidx->data[i3];
393 }
394
395 i3 = locs_temp->size[0];
396 locs_temp->size[0] = c_sortIdx->size[0];
397 emxEnsureCapacity((emxArray__common *)locs_temp, i3, (int)sizeof(double));
398 cdiff = c_sortIdx->size[0];
399 for (i3 = 0; i3 < cdiff; i3++) {
400 locs_temp->data[i3] = locs->data[(int)c_sortIdx->data[i3] - 1];
401 }
402
403 cdiff = c_sortIdx->size[0];
404 i3 = idelete->size[0];
405 idelete->size[0] = cdiff;
406 emxEnsureCapacity((emxArray__common *)idelete, i3, (int)sizeof(boolean_T));
407 for (i3 = 0; i3 < cdiff; i3++) {
408 idelete->data[i3] = false;
409 }
410
411 for (apnd = 0; apnd < c_sortIdx->size[0]; apnd++) {
412 if (!idelete->data[apnd]) {
413 d0 = rt_roundd_snf(locs->data[(int)c_sortIdx->data[apnd] - 1] - (double)
414 Pd);
415 if (d0 < 2.147483648E+9) {
416 if (d0 >= -2.147483648E+9) {
417 absb = (int)d0;
418 } else {
419 absb = MIN_int32_T;
420 }
421 } else if (d0 >= 2.147483648E+9) {
422 absb = MAX_int32_T;
423 } else {
424 absb = 0;
425 }
426
427 d0 = rt_roundd_snf(locs->data[(int)c_sortIdx->data[apnd] - 1] + (double)
428 Pd);
429 if (d0 < 2.147483648E+9) {
430 if (d0 >= -2.147483648E+9) {
431 ndbl = (int)d0;
432 } else {
433 ndbl = MIN_int32_T;
434 }
435 } else if (d0 >= 2.147483648E+9) {
436 ndbl = MAX_int32_T;
437 } else {
438 ndbl = 0;
439 }
440
441 i3 = r2->size[0];
442 r2->size[0] = locs_temp->size[0];
443 emxEnsureCapacity((emxArray__common *)r2, i3, (int)sizeof(boolean_T));
444 cdiff = locs_temp->size[0];
445 for (i3 = 0; i3 < cdiff; i3++) {
446 r2->data[i3] = ((locs_temp->data[i3] >= absb) && (locs_temp->data[i3] <=
447 ndbl));
448 }
449
450 i3 = idelete->size[0];
451 emxEnsureCapacity((emxArray__common *)idelete, i3, (int)sizeof(boolean_T));
452 cdiff = idelete->size[0];
453 for (i3 = 0; i3 < cdiff; i3++) {
454 idelete->data[i3] = (idelete->data[i3] || r2->data[i3]);
455 }
456
457 idelete->data[apnd] = false;
458 }
459 }
460
461 absb = idelete->size[0] - 1;
462 cdiff = 0;
463 for (apnd = 0; apnd <= absb; apnd++) {
464 if (!idelete->data[apnd]) {
465 cdiff++;
466 }
467 }
468
469 i3 = iidx->size[0];
470 iidx->size[0] = cdiff;
471 emxEnsureCapacity((emxArray__common *)iidx, i3, (int)sizeof(int));
472 cdiff = 0;
473 for (apnd = 0; apnd <= absb; apnd++) {
474 if (!idelete->data[apnd]) {
475 iidx->data[cdiff] = apnd + 1;
476 cdiff++;
477 }
478 }
479
480 i3 = idx->size[0];
481 idx->size[0] = iidx->size[0];
482 emxEnsureCapacity((emxArray__common *)idx, i3, (int)sizeof(double));
483 cdiff = iidx->size[0];
484 for (i3 = 0; i3 < cdiff; i3++) {
485 idx->data[i3] = c_sortIdx->data[iidx->data[i3] - 1];
486 }
487
488 c_sort(idx);
489 }
490
491 emxFree_real_T(&b_y);
492 emxFree_int32_T(&iidx);
493 emxFree_boolean_T(&r2);
494 emxFree_real_T(&c_sortIdx);
495 emxFree_boolean_T(&idelete);
496 emxFree_real_T(&locs_temp);
497 emxFree_real_T(&locs);
498 }
499
500 /*
501 * Arguments : const double y[52000]
502 * emxArray_real_T *iPk
503 * emxArray_real_T *iInf
504 * emxArray_real_T *iInflect
505 * Return Type : void
506 */
507 void getAllPeaks(const double y[52000], emxArray_real_T *iPk, emxArray_real_T
508 *iInf, emxArray_real_T *iInflect)
509 {
510 static boolean_T x[52000];
511 int ii;
512 emxArray_int32_T *b_ii;
513 int idx;
514 int i1;
515 boolean_T exitg1;
516 boolean_T guard1 = false;
517 static double yTemp[52000];
518 for (ii = 0; ii < 52000; ii++) {
519 x[ii] = (rtIsInf(y[ii]) && (y[ii] > 0.0));
520 }
521
522 emxInit_int32_T(&b_ii, 1);
523 idx = 0;
524 i1 = b_ii->size[0];
525 b_ii->size[0] = 52000;
526 emxEnsureCapacity((emxArray__common *)b_ii, i1, (int)sizeof(int));
527 ii = 1;
528 exitg1 = false;
529 while ((!exitg1) && (ii < 52001)) {
530 guard1 = false;
531 if (x[ii - 1]) {
532 idx++;
533 b_ii->data[idx - 1] = ii;
534 if (idx >= 52000) {
535 exitg1 = true;
536 } else {
537 guard1 = true;
538 }
539 } else {
540 guard1 = true;
541 }
542
543 if (guard1) {
544 ii++;
545 }
546 }
547
548 i1 = b_ii->size[0];
549 if (1 > idx) {
550 b_ii->size[0] = 0;
551 } else {
552 b_ii->size[0] = idx;
553 }
554
555 emxEnsureCapacity((emxArray__common *)b_ii, i1, (int)sizeof(int));
556 i1 = iInf->size[0];
557 iInf->size[0] = b_ii->size[0];
558 emxEnsureCapacity((emxArray__common *)iInf, i1, (int)sizeof(double));
559 ii = b_ii->size[0];
560 for (i1 = 0; i1 < ii; i1++) {
561 iInf->data[i1] = b_ii->data[i1];
562 }
563
564 memcpy(&yTemp[0], &y[0], 52000U * sizeof(double));
565 i1 = b_ii->size[0];
566 b_ii->size[0] = iInf->size[0];
567 emxEnsureCapacity((emxArray__common *)b_ii, i1, (int)sizeof(int));
568 ii = iInf->size[0];
569 for (i1 = 0; i1 < ii; i1++) {
570 b_ii->data[i1] = (int)iInf->data[i1];
571 }
572
573 ii = b_ii->size[0];
574 for (i1 = 0; i1 < ii; i1++) {
575 yTemp[b_ii->data[i1] - 1] = rtNaN;
576 }
577
578 emxFree_int32_T(&b_ii);
579 findLocalMaxima(yTemp, iPk, iInflect);
580 }
581
582 /*
583 * Arguments : emxArray_real_T *idx
584 * Return Type : void
585 */
586 void keepAtMostNpPeaks(emxArray_real_T *idx)
587 {
588 emxArray_real_T *b_idx;
589 int i7;
590 int loop_ub;
591 if (idx->size[0] > 52000) {
592 emxInit_real_T(&b_idx, 1);
593 i7 = b_idx->size[0];
594 b_idx->size[0] = 52000;
595 emxEnsureCapacity((emxArray__common *)b_idx, i7, (int)sizeof(double));
596 for (i7 = 0; i7 < 52000; i7++) {
597 b_idx->data[i7] = idx->data[i7];
598 }
599
600 i7 = idx->size[0];
601 idx->size[0] = b_idx->size[0];
602 emxEnsureCapacity((emxArray__common *)idx, i7, (int)sizeof(double));
603 loop_ub = b_idx->size[0];
604 for (i7 = 0; i7 < loop_ub; i7++) {
605 idx->data[i7] = b_idx->data[i7];
606 }
607
608 emxFree_real_T(&b_idx);
609 }
610 }
611
612 /*
613 * Arguments : double varargin_2
614 * int varargin_4
615 * double *Ph
616 * int *Pd
617 * Return Type : void
618 */
619 void parse_inputs(double varargin_2, int varargin_4, double *Ph, int *Pd)
620 {
621 *Ph = varargin_2;
622 *Pd = varargin_4;
623 }
624
625 /*
626 * Arguments : const double Y[52000]
627 * emxArray_real_T *iPk
628 * double Ph
629 * Return Type : void
630 */
631 void removePeaksBelowMinPeakHeight(const double Y[52000], emxArray_real_T *iPk,
632 double Ph)
633 {
634 int end;
635 int trueCount;
636 int i;
637 int partialTrueCount;
638 if (!(iPk->size[0] == 0)) {
639 end = iPk->size[0] - 1;
640 trueCount = 0;
641 for (i = 0; i <= end; i++) {
642 if (Y[(int)iPk->data[i] - 1] > Ph) {
643 trueCount++;
644 }
645 }
646
647 partialTrueCount = 0;
648 for (i = 0; i <= end; i++) {
649 if (Y[(int)iPk->data[i] - 1] > Ph) {
650 iPk->data[partialTrueCount] = iPk->data[i];
651 partialTrueCount++;
652 }
653 }
654
655 end = iPk->size[0];
656 iPk->size[0] = trueCount;
657 emxEnsureCapacity((emxArray__common *)iPk, end, (int)sizeof(double));
658 }
659 }
660
661 /*
662 * Arguments : const double Y[52000]
663 * emxArray_real_T *iPk
664 * Return Type : void
665 */
666 void removePeaksBelowThreshold(const double Y[52000], emxArray_real_T *iPk)
667 {
668 int c;
669 emxArray_real_T *base;
670 int k;
671 int trueCount;
672 double extremum;
673 int partialTrueCount;
674 c = iPk->size[0];
675 emxInit_real_T(&base, 1);
676 k = base->size[0];
677 base->size[0] = (unsigned short)c;
678 emxEnsureCapacity((emxArray__common *)base, k, (int)sizeof(double));
679 for (k = 0; k + 1 <= (unsigned short)c; k++) {
680 if ((Y[(int)(iPk->data[k] - 1.0) - 1] >= Y[(int)(iPk->data[k] + 1.0) - 1]) ||
681 rtIsNaN(Y[(int)(iPk->data[k] + 1.0) - 1])) {
682 extremum = Y[(int)(iPk->data[k] - 1.0) - 1];
683 } else {
684 extremum = Y[(int)(iPk->data[k] + 1.0) - 1];
685 }
686
687 base->data[k] = extremum;
688 }
689
690 k = iPk->size[0] - 1;
691 trueCount = 0;
692 for (c = 0; c <= k; c++) {
693 if (Y[(int)iPk->data[c] - 1] - base->data[c] >= 0.0) {
694 trueCount++;
695 }
696 }
697
698 partialTrueCount = 0;
699 for (c = 0; c <= k; c++) {
700 if (Y[(int)iPk->data[c] - 1] - base->data[c] >= 0.0) {
701 iPk->data[partialTrueCount] = iPk->data[c];
702 partialTrueCount++;
703 }
704 }
705
706 emxFree_real_T(&base);
707 k = iPk->size[0];
708 iPk->size[0] = trueCount;
709 emxEnsureCapacity((emxArray__common *)iPk, k, (int)sizeof(double));
710 }
711
712 /*
713 * File trailer for findpeaks.c
714 *
715 * [EOF]
716 */
717
|