1 /*
2 * Copyright (C) 2017 Analog Devices, Inc.
3 *
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
8 *
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
13 */
14
15 /* Include Files */
16 #include "rt_nonfinite.h"
17 #include "internal_design_filter_cg.h"
18 #include "internal_design_filter_cg_emxutil.h"
19
20 /* Function Definitions */
21
22 /*
23 * Arguments : emxArray_cint8_T *emxArray
24 * int oldNumel
25 * Return Type : void
26 */
emxEnsureCapacity_cint8_T(emxArray_cint8_T * emxArray,int oldNumel)27 void emxEnsureCapacity_cint8_T(emxArray_cint8_T *emxArray, int oldNumel)
28 {
29 int newNumel;
30 int i;
31 void *newData;
32 if (oldNumel < 0) {
33 oldNumel = 0;
34 }
35
36 newNumel = 1;
37 for (i = 0; i < emxArray->numDimensions; i++) {
38 newNumel *= emxArray->size[i];
39 }
40
41 if (newNumel > emxArray->allocatedSize) {
42 i = emxArray->allocatedSize;
43 if (i < 16) {
44 i = 16;
45 }
46
47 while (i < newNumel) {
48 if (i > 1073741823) {
49 i = MAX_int32_T;
50 } else {
51 i <<= 1;
52 }
53 }
54
55 newData = calloc((unsigned int)i, sizeof(cint8_T));
56 if (emxArray->data != NULL) {
57 memcpy(newData, (void *)emxArray->data, sizeof(cint8_T) * oldNumel);
58 if (emxArray->canFreeData) {
59 free((void *)emxArray->data);
60 }
61 }
62
63 emxArray->data = (cint8_T *)newData;
64 emxArray->allocatedSize = i;
65 emxArray->canFreeData = true;
66 }
67 }
68
69 /*
70 * Arguments : emxArray_creal_T *emxArray
71 * int oldNumel
72 * Return Type : void
73 */
emxEnsureCapacity_creal_T(emxArray_creal_T * emxArray,int oldNumel)74 void emxEnsureCapacity_creal_T(emxArray_creal_T *emxArray, int oldNumel)
75 {
76 int newNumel;
77 int i;
78 void *newData;
79 if (oldNumel < 0) {
80 oldNumel = 0;
81 }
82
83 newNumel = 1;
84 for (i = 0; i < emxArray->numDimensions; i++) {
85 newNumel *= emxArray->size[i];
86 }
87
88 if (newNumel > emxArray->allocatedSize) {
89 i = emxArray->allocatedSize;
90 if (i < 16) {
91 i = 16;
92 }
93
94 while (i < newNumel) {
95 if (i > 1073741823) {
96 i = MAX_int32_T;
97 } else {
98 i <<= 1;
99 }
100 }
101
102 newData = calloc((unsigned int)i, sizeof(creal_T));
103 if (emxArray->data != NULL) {
104 memcpy(newData, (void *)emxArray->data, sizeof(creal_T) * oldNumel);
105 if (emxArray->canFreeData) {
106 free((void *)emxArray->data);
107 }
108 }
109
110 emxArray->data = (creal_T *)newData;
111 emxArray->allocatedSize = i;
112 emxArray->canFreeData = true;
113 }
114 }
115
116 /*
117 * Arguments : emxArray_creal_T *emxArray
118 * int oldNumel
119 * Return Type : void
120 */
emxEnsureCapacity_creal_T1(emxArray_creal_T * emxArray,int oldNumel)121 void emxEnsureCapacity_creal_T1(emxArray_creal_T *emxArray, int oldNumel)
122 {
123 int newNumel;
124 int i;
125 void *newData;
126 if (oldNumel < 0) {
127 oldNumel = 0;
128 }
129
130 newNumel = 1;
131 for (i = 0; i < emxArray->numDimensions; i++) {
132 newNumel *= emxArray->size[i];
133 }
134
135 if (newNumel > emxArray->allocatedSize) {
136 i = emxArray->allocatedSize;
137 if (i < 16) {
138 i = 16;
139 }
140
141 while (i < newNumel) {
142 if (i > 1073741823) {
143 i = MAX_int32_T;
144 } else {
145 i <<= 1;
146 }
147 }
148
149 newData = calloc((unsigned int)i, sizeof(creal_T));
150 if (emxArray->data != NULL) {
151 memcpy(newData, (void *)emxArray->data, sizeof(creal_T) * oldNumel);
152 if (emxArray->canFreeData) {
153 free((void *)emxArray->data);
154 }
155 }
156
157 emxArray->data = (creal_T *)newData;
158 emxArray->allocatedSize = i;
159 emxArray->canFreeData = true;
160 }
161 }
162
163 /*
164 * Arguments : emxArray_int32_T *emxArray
165 * int oldNumel
166 * Return Type : void
167 */
emxEnsureCapacity_int32_T(emxArray_int32_T * emxArray,int oldNumel)168 void emxEnsureCapacity_int32_T(emxArray_int32_T *emxArray, int oldNumel)
169 {
170 int newNumel;
171 int i;
172 void *newData;
173 if (oldNumel < 0) {
174 oldNumel = 0;
175 }
176
177 newNumel = 1;
178 for (i = 0; i < emxArray->numDimensions; i++) {
179 newNumel *= emxArray->size[i];
180 }
181
182 if (newNumel > emxArray->allocatedSize) {
183 i = emxArray->allocatedSize;
184 if (i < 16) {
185 i = 16;
186 }
187
188 while (i < newNumel) {
189 if (i > 1073741823) {
190 i = MAX_int32_T;
191 } else {
192 i <<= 1;
193 }
194 }
195
196 newData = calloc((unsigned int)i, sizeof(int));
197 if (emxArray->data != NULL) {
198 memcpy(newData, (void *)emxArray->data, sizeof(int) * oldNumel);
199 if (emxArray->canFreeData) {
200 free((void *)emxArray->data);
201 }
202 }
203
204 emxArray->data = (int *)newData;
205 emxArray->allocatedSize = i;
206 emxArray->canFreeData = true;
207 }
208 }
209
210 /*
211 * Arguments : emxArray_int32_T *emxArray
212 * int oldNumel
213 * Return Type : void
214 */
emxEnsureCapacity_int32_T1(emxArray_int32_T * emxArray,int oldNumel)215 void emxEnsureCapacity_int32_T1(emxArray_int32_T *emxArray, int oldNumel)
216 {
217 int newNumel;
218 int i;
219 void *newData;
220 if (oldNumel < 0) {
221 oldNumel = 0;
222 }
223
224 newNumel = 1;
225 for (i = 0; i < emxArray->numDimensions; i++) {
226 newNumel *= emxArray->size[i];
227 }
228
229 if (newNumel > emxArray->allocatedSize) {
230 i = emxArray->allocatedSize;
231 if (i < 16) {
232 i = 16;
233 }
234
235 while (i < newNumel) {
236 if (i > 1073741823) {
237 i = MAX_int32_T;
238 } else {
239 i <<= 1;
240 }
241 }
242
243 newData = calloc((unsigned int)i, sizeof(int));
244 if (emxArray->data != NULL) {
245 memcpy(newData, (void *)emxArray->data, sizeof(int) * oldNumel);
246 if (emxArray->canFreeData) {
247 free((void *)emxArray->data);
248 }
249 }
250
251 emxArray->data = (int *)newData;
252 emxArray->allocatedSize = i;
253 emxArray->canFreeData = true;
254 }
255 }
256
257 /*
258 * Arguments : emxArray_int8_T *emxArray
259 * int oldNumel
260 * Return Type : void
261 */
emxEnsureCapacity_int8_T(emxArray_int8_T * emxArray,int oldNumel)262 void emxEnsureCapacity_int8_T(emxArray_int8_T *emxArray, int oldNumel)
263 {
264 int newNumel;
265 int i;
266 void *newData;
267 if (oldNumel < 0) {
268 oldNumel = 0;
269 }
270
271 newNumel = 1;
272 for (i = 0; i < emxArray->numDimensions; i++) {
273 newNumel *= emxArray->size[i];
274 }
275
276 if (newNumel > emxArray->allocatedSize) {
277 i = emxArray->allocatedSize;
278 if (i < 16) {
279 i = 16;
280 }
281
282 while (i < newNumel) {
283 if (i > 1073741823) {
284 i = MAX_int32_T;
285 } else {
286 i <<= 1;
287 }
288 }
289
290 newData = calloc((unsigned int)i, sizeof(signed char));
291 if (emxArray->data != NULL) {
292 memcpy(newData, (void *)emxArray->data, sizeof(signed char) * oldNumel);
293 if (emxArray->canFreeData) {
294 free((void *)emxArray->data);
295 }
296 }
297
298 emxArray->data = (signed char *)newData;
299 emxArray->allocatedSize = i;
300 emxArray->canFreeData = true;
301 }
302 }
303
304 /*
305 * Arguments : emxArray_real_T *emxArray
306 * int oldNumel
307 * Return Type : void
308 */
emxEnsureCapacity_real_T(emxArray_real_T * emxArray,int oldNumel)309 void emxEnsureCapacity_real_T(emxArray_real_T *emxArray, int oldNumel)
310 {
311 int newNumel;
312 int i;
313 void *newData;
314 if (oldNumel < 0) {
315 oldNumel = 0;
316 }
317
318 newNumel = 1;
319 for (i = 0; i < emxArray->numDimensions; i++) {
320 newNumel *= emxArray->size[i];
321 }
322
323 if (newNumel > emxArray->allocatedSize) {
324 i = emxArray->allocatedSize;
325 if (i < 16) {
326 i = 16;
327 }
328
329 while (i < newNumel) {
330 if (i > 1073741823) {
331 i = MAX_int32_T;
332 } else {
333 i <<= 1;
334 }
335 }
336
337 newData = calloc((unsigned int)i, sizeof(double));
338 if (emxArray->data != NULL) {
339 memcpy(newData, (void *)emxArray->data, sizeof(double) * oldNumel);
340 if (emxArray->canFreeData) {
341 free((void *)emxArray->data);
342 }
343 }
344
345 emxArray->data = (double *)newData;
346 emxArray->allocatedSize = i;
347 emxArray->canFreeData = true;
348 }
349 }
350
351 /*
352 * Arguments : emxArray_real_T *emxArray
353 * int oldNumel
354 * Return Type : void
355 */
emxEnsureCapacity_real_T1(emxArray_real_T * emxArray,int oldNumel)356 void emxEnsureCapacity_real_T1(emxArray_real_T *emxArray, int oldNumel)
357 {
358 int newNumel;
359 int i;
360 void *newData;
361 if (oldNumel < 0) {
362 oldNumel = 0;
363 }
364
365 newNumel = 1;
366 for (i = 0; i < emxArray->numDimensions; i++) {
367 newNumel *= emxArray->size[i];
368 }
369
370 if (newNumel > emxArray->allocatedSize) {
371 i = emxArray->allocatedSize;
372 if (i < 16) {
373 i = 16;
374 }
375
376 while (i < newNumel) {
377 if (i > 1073741823) {
378 i = MAX_int32_T;
379 } else {
380 i <<= 1;
381 }
382 }
383
384 newData = calloc((unsigned int)i, sizeof(double));
385 if (emxArray->data != NULL) {
386 memcpy(newData, (void *)emxArray->data, sizeof(double) * oldNumel);
387 if (emxArray->canFreeData) {
388 free((void *)emxArray->data);
389 }
390 }
391
392 emxArray->data = (double *)newData;
393 emxArray->allocatedSize = i;
394 emxArray->canFreeData = true;
395 }
396 }
397
398 /*
399 * Arguments : emxArray_cint8_T **pEmxArray
400 * Return Type : void
401 */
emxFree_cint8_T(emxArray_cint8_T ** pEmxArray)402 void emxFree_cint8_T(emxArray_cint8_T **pEmxArray)
403 {
404 if (*pEmxArray != (emxArray_cint8_T *)NULL) {
405 if (((*pEmxArray)->data != (cint8_T *)NULL) && (*pEmxArray)->canFreeData) {
406 free((void *)(*pEmxArray)->data);
407 }
408
409 free((void *)(*pEmxArray)->size);
410 free((void *)*pEmxArray);
411 *pEmxArray = (emxArray_cint8_T *)NULL;
412 }
413 }
414
415 /*
416 * Arguments : emxArray_creal_T **pEmxArray
417 * Return Type : void
418 */
emxFree_creal_T(emxArray_creal_T ** pEmxArray)419 void emxFree_creal_T(emxArray_creal_T **pEmxArray)
420 {
421 if (*pEmxArray != (emxArray_creal_T *)NULL) {
422 if (((*pEmxArray)->data != (creal_T *)NULL) && (*pEmxArray)->canFreeData) {
423 free((void *)(*pEmxArray)->data);
424 }
425
426 free((void *)(*pEmxArray)->size);
427 free((void *)*pEmxArray);
428 *pEmxArray = (emxArray_creal_T *)NULL;
429 }
430 }
431
432 /*
433 * Arguments : emxArray_int32_T **pEmxArray
434 * Return Type : void
435 */
emxFree_int32_T(emxArray_int32_T ** pEmxArray)436 void emxFree_int32_T(emxArray_int32_T **pEmxArray)
437 {
438 if (*pEmxArray != (emxArray_int32_T *)NULL) {
439 if (((*pEmxArray)->data != (int *)NULL) && (*pEmxArray)->canFreeData) {
440 free((void *)(*pEmxArray)->data);
441 }
442
443 free((void *)(*pEmxArray)->size);
444 free((void *)*pEmxArray);
445 *pEmxArray = (emxArray_int32_T *)NULL;
446 }
447 }
448
449 /*
450 * Arguments : emxArray_int8_T **pEmxArray
451 * Return Type : void
452 */
emxFree_int8_T(emxArray_int8_T ** pEmxArray)453 void emxFree_int8_T(emxArray_int8_T **pEmxArray)
454 {
455 if (*pEmxArray != (emxArray_int8_T *)NULL) {
456 if (((*pEmxArray)->data != (signed char *)NULL) && (*pEmxArray)->canFreeData) {
457 free((void *)(*pEmxArray)->data);
458 }
459
460 free((void *)(*pEmxArray)->size);
461 free((void *)*pEmxArray);
462 *pEmxArray = (emxArray_int8_T *)NULL;
463 }
464 }
465
466 /*
467 * Arguments : emxArray_real_T **pEmxArray
468 * Return Type : void
469 */
emxFree_real_T(emxArray_real_T ** pEmxArray)470 void emxFree_real_T(emxArray_real_T **pEmxArray)
471 {
472 if (*pEmxArray != (emxArray_real_T *)NULL) {
473 if (((*pEmxArray)->data != (double *)NULL) && (*pEmxArray)->canFreeData) {
474 free((void *)(*pEmxArray)->data);
475 }
476
477 free((void *)(*pEmxArray)->size);
478 free((void *)*pEmxArray);
479 *pEmxArray = (emxArray_real_T *)NULL;
480 }
481 }
482
483 /*
484 * Arguments : emxArray_cint8_T **pEmxArray
485 * int numDimensions
486 * Return Type : void
487 */
emxInit_cint8_T(emxArray_cint8_T ** pEmxArray,int numDimensions)488 void emxInit_cint8_T(emxArray_cint8_T **pEmxArray, int numDimensions)
489 {
490 emxArray_cint8_T *emxArray;
491 int i;
492 *pEmxArray = (emxArray_cint8_T *)malloc(sizeof(emxArray_cint8_T));
493 emxArray = *pEmxArray;
494 emxArray->data = (cint8_T *)NULL;
495 emxArray->numDimensions = numDimensions;
496 emxArray->size = (int *)malloc((unsigned int)(sizeof(int) * numDimensions));
497 emxArray->allocatedSize = 0;
498 emxArray->canFreeData = true;
499 for (i = 0; i < numDimensions; i++) {
500 emxArray->size[i] = 0;
501 }
502 }
503
504 /*
505 * Arguments : emxArray_creal_T **pEmxArray
506 * int numDimensions
507 * Return Type : void
508 */
emxInit_creal_T(emxArray_creal_T ** pEmxArray,int numDimensions)509 void emxInit_creal_T(emxArray_creal_T **pEmxArray, int numDimensions)
510 {
511 emxArray_creal_T *emxArray;
512 int i;
513 *pEmxArray = (emxArray_creal_T *)malloc(sizeof(emxArray_creal_T));
514 emxArray = *pEmxArray;
515 emxArray->data = (creal_T *)NULL;
516 emxArray->numDimensions = numDimensions;
517 emxArray->size = (int *)malloc((unsigned int)(sizeof(int) * numDimensions));
518 emxArray->allocatedSize = 0;
519 emxArray->canFreeData = true;
520 for (i = 0; i < numDimensions; i++) {
521 emxArray->size[i] = 0;
522 }
523 }
524
525 /*
526 * Arguments : emxArray_creal_T **pEmxArray
527 * int numDimensions
528 * Return Type : void
529 */
emxInit_creal_T1(emxArray_creal_T ** pEmxArray,int numDimensions)530 void emxInit_creal_T1(emxArray_creal_T **pEmxArray, int numDimensions)
531 {
532 emxArray_creal_T *emxArray;
533 int i;
534 *pEmxArray = (emxArray_creal_T *)malloc(sizeof(emxArray_creal_T));
535 emxArray = *pEmxArray;
536 emxArray->data = (creal_T *)NULL;
537 emxArray->numDimensions = numDimensions;
538 emxArray->size = (int *)malloc((unsigned int)(sizeof(int) * numDimensions));
539 emxArray->allocatedSize = 0;
540 emxArray->canFreeData = true;
541 for (i = 0; i < numDimensions; i++) {
542 emxArray->size[i] = 0;
543 }
544 }
545
546 /*
547 * Arguments : emxArray_int32_T **pEmxArray
548 * int numDimensions
549 * Return Type : void
550 */
emxInit_int32_T(emxArray_int32_T ** pEmxArray,int numDimensions)551 void emxInit_int32_T(emxArray_int32_T **pEmxArray, int numDimensions)
552 {
553 emxArray_int32_T *emxArray;
554 int i;
555 *pEmxArray = (emxArray_int32_T *)malloc(sizeof(emxArray_int32_T));
556 emxArray = *pEmxArray;
557 emxArray->data = (int *)NULL;
558 emxArray->numDimensions = numDimensions;
559 emxArray->size = (int *)malloc((unsigned int)(sizeof(int) * numDimensions));
560 emxArray->allocatedSize = 0;
561 emxArray->canFreeData = true;
562 for (i = 0; i < numDimensions; i++) {
563 emxArray->size[i] = 0;
564 }
565 }
566
567 /*
568 * Arguments : emxArray_int32_T **pEmxArray
569 * int numDimensions
570 * Return Type : void
571 */
emxInit_int32_T1(emxArray_int32_T ** pEmxArray,int numDimensions)572 void emxInit_int32_T1(emxArray_int32_T **pEmxArray, int numDimensions)
573 {
574 emxArray_int32_T *emxArray;
575 int i;
576 *pEmxArray = (emxArray_int32_T *)malloc(sizeof(emxArray_int32_T));
577 emxArray = *pEmxArray;
578 emxArray->data = (int *)NULL;
579 emxArray->numDimensions = numDimensions;
580 emxArray->size = (int *)malloc((unsigned int)(sizeof(int) * numDimensions));
581 emxArray->allocatedSize = 0;
582 emxArray->canFreeData = true;
583 for (i = 0; i < numDimensions; i++) {
584 emxArray->size[i] = 0;
585 }
586 }
587
588 /*
589 * Arguments : emxArray_int8_T **pEmxArray
590 * int numDimensions
591 * Return Type : void
592 */
emxInit_int8_T(emxArray_int8_T ** pEmxArray,int numDimensions)593 void emxInit_int8_T(emxArray_int8_T **pEmxArray, int numDimensions)
594 {
595 emxArray_int8_T *emxArray;
596 int i;
597 *pEmxArray = (emxArray_int8_T *)malloc(sizeof(emxArray_int8_T));
598 emxArray = *pEmxArray;
599 emxArray->data = (signed char *)NULL;
600 emxArray->numDimensions = numDimensions;
601 emxArray->size = (int *)malloc((unsigned int)(sizeof(int) * numDimensions));
602 emxArray->allocatedSize = 0;
603 emxArray->canFreeData = true;
604 for (i = 0; i < numDimensions; i++) {
605 emxArray->size[i] = 0;
606 }
607 }
608
609 /*
610 * Arguments : emxArray_real_T **pEmxArray
611 * int numDimensions
612 * Return Type : void
613 */
emxInit_real_T(emxArray_real_T ** pEmxArray,int numDimensions)614 void emxInit_real_T(emxArray_real_T **pEmxArray, int numDimensions)
615 {
616 emxArray_real_T *emxArray;
617 int i;
618 *pEmxArray = (emxArray_real_T *)malloc(sizeof(emxArray_real_T));
619 emxArray = *pEmxArray;
620 emxArray->data = (double *)NULL;
621 emxArray->numDimensions = numDimensions;
622 emxArray->size = (int *)malloc((unsigned int)(sizeof(int) * numDimensions));
623 emxArray->allocatedSize = 0;
624 emxArray->canFreeData = true;
625 for (i = 0; i < numDimensions; i++) {
626 emxArray->size[i] = 0;
627 }
628 }
629
630 /*
631 * Arguments : emxArray_real_T **pEmxArray
632 * int numDimensions
633 * Return Type : void
634 */
emxInit_real_T1(emxArray_real_T ** pEmxArray,int numDimensions)635 void emxInit_real_T1(emxArray_real_T **pEmxArray, int numDimensions)
636 {
637 emxArray_real_T *emxArray;
638 int i;
639 *pEmxArray = (emxArray_real_T *)malloc(sizeof(emxArray_real_T));
640 emxArray = *pEmxArray;
641 emxArray->data = (double *)NULL;
642 emxArray->numDimensions = numDimensions;
643 emxArray->size = (int *)malloc((unsigned int)(sizeof(int) * numDimensions));
644 emxArray->allocatedSize = 0;
645 emxArray->canFreeData = true;
646 for (i = 0; i < numDimensions; i++) {
647 emxArray->size[i] = 0;
648 }
649 }
650
651 /*
652 * File trailer for internal_design_filter_cg_emxutil.c
653 *
654 * [EOF]
655 */
656