GCC Code Coverage Report
Directory: ./ Exec Total Coverage
File: src/nrrd/tmfKernel.c Lines: 1760 1770 99.4 %
Date: 2017-05-26 Branches: 2838 3048 93.1 %

Line Branch Exec Source
1
/*
2
  Teem: Tools to process and visualize scientific data and images             .
3
  Copyright (C) 2013, 2012, 2011, 2010, 2009  University of Chicago
4
  Copyright (C) 2008, 2007, 2006, 2005  Gordon Kindlmann
5
  Copyright (C) 2004, 2003, 2002, 2001, 2000, 1999, 1998  University of Utah
6
7
  This library is free software; you can redistribute it and/or
8
  modify it under the terms of the GNU Lesser General Public License
9
  (LGPL) as published by the Free Software Foundation; either
10
  version 2.1 of the License, or (at your option) any later version.
11
  The terms of redistributing and/or modifying this software also
12
  include exceptions to the LGPL that facilitate static linking.
13
14
  This library is distributed in the hope that it will be useful,
15
  but WITHOUT ANY WARRANTY; without even the implied warranty of
16
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17
  Lesser General Public License for more details.
18
19
  You should have received a copy of the GNU Lesser General Public License
20
  along with this library; if not, write to Free Software Foundation, Inc.,
21
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
22
*/
23
24
#include "nrrd.h"
25
26
 /* ************************************************* */
27
 /* !! WARNING !!! WARNING !!! WARNING !!! WARNING !! */
28
 /* !! WARNING !!! WARNING !!! WARNING !!! WARNING !! */
29
 /* !! WARNING !!! WARNING !!! WARNING !!! WARNING !! */
30
 /*                                                   */
31
 /*                                                   */
32
 /*       THIS FILE AUTOMATICALLY GENERATED FROM      */
33
 /*        PERL SCRIPTS IN THE tmf SUBDIRECTORY       */
34
 /*         EDIT THOSE SCRIPTS, NOT THIS FILE!        */
35
 /*                                                   */
36
 /*                                                   */
37
 /* !! WARNING !!! WARNING !!! WARNING !!! WARNING !! */
38
 /* !! WARNING !!! WARNING !!! WARNING !!! WARNING !! */
39
 /* !! WARNING !!! WARNING !!! WARNING !!! WARNING !! */
40
 /* ************************************************* */
41
42
static double
43
_nrrd_TMFBAD_Int(const double *parm) {
44
  AIR_UNUSED(parm);
45
  fprintf(stderr, "_nrrd_TMFBAD: Invalid TMF indexing: ef == 0\n");
46
  return 0.0;
47
}
48
49
static double
50
_nrrd_TMFBAD_Sup(const double *parm) {
51
  AIR_UNUSED(parm);
52
  fprintf(stderr, "_nrrd_TMFBAD: Invalid TMF indexing: ef == 0\n");
53
  return 0.0;
54
}
55
56
static double
57
_nrrd_TMFBAD_1_d(double x, const double *parm) {
58
  AIR_UNUSED(x);
59
  AIR_UNUSED(parm);
60
  fprintf(stderr, "_nrrd_TMFBAD: Invalid TMF indexing: ef == 0\n");
61
  return 0.0;
62
}
63
64
static float
65
_nrrd_TMFBAD_1_f(float x, const double *parm) {
66
  AIR_UNUSED(x);
67
  AIR_UNUSED(parm);
68
  fprintf(stderr, "_nrrd_TMFBAD: Invalid TMF indexing: ef == 0\n");
69
  return 0.0;
70
}
71
72
static void
73
_nrrd_TMFBAD_N_d(double *f, const double *x, size_t len, const double *parm) {
74
  AIR_UNUSED(f);
75
  AIR_UNUSED(x);
76
  AIR_UNUSED(len);
77
  AIR_UNUSED(parm);
78
  fprintf(stderr, "_nrrd_TMFBAD: Invalid TMF indexing: ef == 0\n");
79
}
80
81
static void
82
_nrrd_TMFBAD_N_f(float *f, const float *x, size_t len, const double *parm) {
83
  AIR_UNUSED(f);
84
  AIR_UNUSED(x);
85
  AIR_UNUSED(len);
86
  AIR_UNUSED(parm);
87
  fprintf(stderr, "_nrrd_TMFBAD: Invalid TMF indexing: ef == 0\n");
88
}
89
90
static NrrdKernel
91
_nrrdKernel_TMFBAD = {
92
  "TMFBAD",
93
  1, _nrrd_TMFBAD_Sup, _nrrd_TMFBAD_Int,
94
  _nrrd_TMFBAD_1_f, _nrrd_TMFBAD_N_f,
95
  _nrrd_TMFBAD_1_d, _nrrd_TMFBAD_N_d
96
};
97
#define OVER_3 0.33333333
98
#define OVER_6 0.16666666
99
#define OVER_12 0.0833333333
100
#define OVER_2_3 0.6666666666
101
102
/* ------------------------ TMF_dn_cn_1ef --------------------- */
103
104
#define TMF_dn_cn_1ef(a, i, t) ( \
105
  (i == 0 ? 0.5 : \
106
  (i == 1 ? 0.5 : \
107
  0)))
108
109
110
/* ------------------------ TMF_dn_cn_2ef --------------------- */
111
112
#define TMF_dn_cn_2ef(a, i, t) ( \
113
  TMF_d0_c0_2ef((double)(a), i, t))
114
115
116
/* ------------------------ TMF_dn_cn_3ef --------------------- */
117
118
#define TMF_dn_cn_3ef(a, i, t) ( \
119
  (i == 0 ? ( 0.25*t +(2*a-0.25))*t -   a   : \
120
  (i == 1 ? (-0.25*t -(6*a-1.25))*t + 3*a   : \
121
  (i == 2 ? (-0.25*t +(6*a-0.75))*t - 3*a+1 : \
122
  (i == 3 ? ( 0.25*t -(2*a+0.25))*t +   a   : \
123
  0)))))
124
125
126
/* ------------------------ TMF_dn_cn_4ef --------------------- */
127
128
#define TMF_dn_cn_4ef(a, i, t) ( \
129
  TMF_d0_c0_4ef((double)(a), i, t))
130
131
132
/* ------------------------ TMF_dn_c0_1ef --------------------- */
133
134
#define TMF_dn_c0_1ef(a, i, t) ( \
135
  TMF_d0_c0_2ef((double)(a), i, t))
136
137
138
/* ------------------------ TMF_dn_c0_2ef --------------------- */
139
140
#define TMF_dn_c0_2ef(a, i, t) ( \
141
  TMF_d0_c0_2ef((double)(a), i, t))
142
143
144
/* ------------------------ TMF_dn_c0_3ef --------------------- */
145
146
#define TMF_dn_c0_3ef(a, i, t) ( \
147
  TMF_d0_c0_3ef((double)(a), i, t))
148
149
150
/* ------------------------ TMF_dn_c0_4ef --------------------- */
151
152
#define TMF_dn_c0_4ef(a, i, t) ( \
153
  TMF_d0_c0_4ef((double)(a), i, t))
154
155
156
/* ------------------------ TMF_dn_c1_1ef --------------------- */
157
158
#define TMF_dn_c1_1ef(a, i, t) ( \
159
  TMF_d0_c1_1ef((double)(a), i, t))
160
161
162
/* ------------------------ TMF_dn_c1_2ef --------------------- */
163
164
#define TMF_dn_c1_2ef(a, i, t) ( \
165
  (i == 0 ? ( t   )*t/4 : \
166
  (i == 1 ? (-t +2)*t/4 +0.25 : \
167
  (i == 2 ? (-t   )*t/4 +0.5 : \
168
  (i == 3 ? ( t -2)*t/4 +0.25 : \
169
  0)))))
170
171
172
/* ------------------------ TMF_dn_c1_3ef --------------------- */
173
174
#define TMF_dn_c1_3ef(a, i, t) ( \
175
  TMF_d0_c1_3ef((double)(a), i, t))
176
177
178
/* ------------------------ TMF_dn_c1_4ef --------------------- */
179
180
#define TMF_dn_c1_4ef(a, i, t) ( \
181
  (i == 0 ? ((-(   a       )*t +(1.5*a- 1./24))*t +         0)*t +             0 : \
182
  (i == 1 ? (( ( 5*a+OVER_6)*t -(7.5*a- 1./8 ))*t - (OVER_12))*t +(0.5*a-1./24 ) : \
183
  (i == 2 ? ((-(10*a+   0.5)*t +( 15*a+ 5./12))*t +(OVER_2_3))*t -(  2*a-OVER_6) : \
184
  (i == 3 ? (( (10*a+   0.5)*t -( 15*a+13./12))*t +         0)*t +(  3*a+0.75  ) : \
185
  (i == 4 ? ((-( 5*a+OVER_6)*t +(7.5*a+ 5./8 ))*t -(OVER_2_3))*t -(  2*a-OVER_6) : \
186
  (i == 5 ? (( (   a       )*t -(1.5*a+ 1./24))*t + (OVER_12))*t +(0.5*a-1./24 ) : \
187
  0)))))))
188
189
190
/* ------------------------ TMF_dn_c2_1ef --------------------- */
191
192
#define TMF_dn_c2_1ef(a, i, t) ( \
193
  TMF_d0_c2_1ef((double)(a), i, t))
194
195
196
/* ------------------------ TMF_dn_c2_2ef --------------------- */
197
198
#define TMF_dn_c2_2ef(a, i, t) ( \
199
  (i == 0 ? (( OVER_6*t +  0)*t +  0)*t +       0 : \
200
  (i == 1 ? ((   -0.5*t +0.5)*t +0.5)*t +  OVER_6 : \
201
  (i == 2 ? ((    0.5*t -  1)*t +  0)*t +OVER_2_3 : \
202
  (i == 3 ? ((-OVER_6*t +0.5)*t -0.5)*t +  OVER_6 : \
203
  0)))))
204
205
206
/* ------------------------ TMF_dn_c2_3ef --------------------- */
207
208
#define TMF_dn_c2_3ef(a, i, t) ( \
209
  TMF_d0_c2_3ef((double)(a), i, t))
210
211
212
/* ------------------------ TMF_dn_c2_4ef --------------------- */
213
214
#define TMF_dn_c2_4ef(a, i, t) ( \
215
  TMF_dn_c1_4ef((double)(1./36), i, t))
216
217
218
/* ------------------------ TMF_dn_c3_1ef --------------------- */
219
220
#define TMF_dn_c3_1ef(a, i, t) ( \
221
  TMF_d0_c3_1ef((double)(a), i, t))
222
223
224
/* ------------------------ TMF_dn_c3_2ef --------------------- */
225
226
#define TMF_dn_c3_2ef(a, i, t) ( \
227
  (i == 0 ? (-0.10*t +0.25)*t*t*t*t : \
228
  (i == 1 ? ((( 0.30*t -0.75)*t*t +0.5)*t +0.5)*t +0.15 : \
229
  (i == 2 ? (((-0.30*t +0.75)*t*t -1  )*t +0  )*t +0.70 : \
230
  (i == 3 ? ((( 0.10*t -0.25)*t*t +0.5)*t -0.5)*t +0.15 : \
231
  0)))))
232
233
234
/* ------------------------ TMF_dn_c3_3ef --------------------- */
235
236
#define TMF_dn_c3_3ef(a, i, t) ( \
237
  TMF_d0_c3_3ef((double)(a), i, t))
238
239
240
/* ------------------------ TMF_dn_c3_4ef --------------------- */
241
242
#define TMF_dn_c3_4ef(a, i, t) ( \
243
  (i == 0 ? ((((  1./30*t - 1./16)*t +      0)*t +       0)*t +       0)*t + 0 : \
244
  (i == 1 ? ((((-OVER_6*t +17./48)*t +OVER_12)*t -   1./24)*t - OVER_12)*t - 7./240 : \
245
  (i == 2 ? (((( OVER_3*t -19./24)*t -OVER_6 )*t +OVER_2_3)*t +OVER_2_3)*t + 7./60 : \
246
  (i == 3 ? ((((-OVER_3*t + 7./8 )*t +      0)*t -    1.25)*t +       0)*t +33./40 : \
247
  (i == 4 ? (((( OVER_6*t -23./48)*t +OVER_6 )*t +OVER_2_3)*t -OVER_2_3)*t + 7./60 : \
248
  (i == 5 ? ((((- 1./30*t + 5./48)*t -OVER_12)*t -   1./24)*t + OVER_12)*t - 7./240 : \
249
  0)))))))
250
251
252
/* ------------------------ TMF_d0_cn_1ef --------------------- */
253
254
#define TMF_d0_cn_1ef(a, i, t) ( \
255
  TMF_d0_c0_2ef((double)(a), i, t))
256
257
258
/* ------------------------ TMF_d0_cn_2ef --------------------- */
259
260
#define TMF_d0_cn_2ef(a, i, t) ( \
261
  TMF_d0_c0_2ef((double)(a), i, t))
262
263
264
/* ------------------------ TMF_d0_cn_3ef --------------------- */
265
266
#define TMF_d0_cn_3ef(a, i, t) ( \
267
  TMF_d0_c0_3ef((double)(a), i, t))
268
269
270
/* ------------------------ TMF_d0_cn_4ef --------------------- */
271
272
#define TMF_d0_cn_4ef(a, i, t) ( \
273
  TMF_d0_c0_4ef((double)(a), i, t))
274
275
276
/* ------------------------ TMF_d0_c0_1ef --------------------- */
277
278
#define TMF_d0_c0_1ef(a, i, t) ( \
279
  TMF_d0_c0_2ef((double)(a), i, t))
280
281
282
/* ------------------------ TMF_d0_c0_2ef --------------------- */
283
284
#define TMF_d0_c0_2ef(a, i, t) ( \
285
  (i == 0 ? t : \
286
  (i == 1 ? 1-t : \
287
  0)))
288
289
290
/* ------------------------ TMF_d0_c0_3ef --------------------- */
291
292
#define TMF_d0_c0_3ef(a, i, t) ( \
293
  TMF_dn_cn_3ef((double)(0), i, t))
294
295
296
/* ------------------------ TMF_d0_c0_4ef --------------------- */
297
298
#define TMF_d0_c0_4ef(a, i, t) ( \
299
  (i == 0 ? (( OVER_6*t +0  )*t -OVER_6)*t   : \
300
  (i == 1 ? ((   -0.5*t +0.5)*t +1     )*t   : \
301
  (i == 2 ? ((    0.5*t -1  )*t -0.5   )*t+1 : \
302
  (i == 3 ? ((-OVER_6*t +0.5)*t -OVER_3)*t   : \
303
  0)))))
304
305
306
/* ------------------------ TMF_d0_c1_1ef --------------------- */
307
308
#define TMF_d0_c1_1ef(a, i, t) ( \
309
  (i == 0 ? (-2*t +3)*t*t : \
310
  (i == 1 ? ( 2*t -3)*t*t +1 : \
311
  0)))
312
313
314
/* ------------------------ TMF_d0_c1_2ef --------------------- */
315
316
#define TMF_d0_c1_2ef(a, i, t) ( \
317
  TMF_d0_c1_3ef((double)(a), i, t))
318
319
320
/* ------------------------ TMF_d0_c1_3ef --------------------- */
321
322
#define TMF_d0_c1_3ef(a, i, t) ( \
323
  (i == 0 ? (( 0.5*t -0.5)*t +0  )*t : \
324
  (i == 1 ? ((-1.5*t +2  )*t +0.5)*t : \
325
  (i == 2 ? (( 1.5*t -2.5)*t +0  )*t +1 : \
326
  (i == 3 ? ((-0.5*t +1  )*t -0.5)*t : \
327
  0)))))
328
329
330
/* ------------------------ TMF_d0_c1_4ef --------------------- */
331
332
#define TMF_d0_c1_4ef(a, i, t) ( \
333
  TMF_dn_c1_4ef((double)(1./12), i, t))
334
335
336
/* ------------------------ TMF_d0_c2_1ef --------------------- */
337
338
#define TMF_d0_c2_1ef(a, i, t) ( \
339
  (i == 0 ? (( 6*t -15)*t +10)*t*t*t : \
340
  (i == 1 ? ((-6*t +15)*t -10)*t*t*t +1 : \
341
  0)))
342
343
344
/* ------------------------ TMF_d0_c2_2ef --------------------- */
345
346
#define TMF_d0_c2_2ef(a, i, t) ( \
347
  (i == 0 ? ((( 0.5*t -0.5)*t +  0)*t +  0)*t : \
348
  (i == 1 ? (((-0.5*t -0.5)*t +1.5)*t +0.5)*t : \
349
  (i == 2 ? (((-0.5*t +2.5)*t -  3)*t +  0)*t +1 : \
350
  (i == 3 ? ((( 0.5*t -1.5)*t +1.5)*t -0.5)*t : \
351
  0)))))
352
353
354
/* ------------------------ TMF_d0_c2_3ef --------------------- */
355
356
#define TMF_d0_c2_3ef(a, i, t) ( \
357
  (i == 0 ? ((((-1*t +2.5)*t -1.5)*t +0  )*t +0  )*t    : \
358
  (i == 1 ? (((( 3*t -7.5)*t +4.5)*t +0.5)*t +0.5)*t    : \
359
  (i == 2 ? ((((-3*t +7.5)*t -4.5)*t -1  )*t +0  )*t +1 : \
360
  (i == 3 ? (((( 1*t -2.5)*t +1.5)*t +0.5)*t -0.5)*t    : \
361
  0)))))
362
363
364
/* ------------------------ TMF_d0_c2_4ef --------------------- */
365
366
#define TMF_d0_c2_4ef(a, i, t) ( \
367
  (i == 0 ? (((-1./12*t + 1./12)*t +   0)*t +       0)*t : \
368
  (i == 1 ? ((( 1./4 *t + 1./12)*t -1./4)*t - OVER_12)*t : \
369
  (i == 2 ? (((-1./6 *t - 1    )*t +3./2)*t +OVER_2_3)*t : \
370
  (i == 3 ? (((-1./6 *t + 5./3 )*t -5./2)*t +       0)*t +1 : \
371
  (i == 4 ? ((( 1./4 *t -13./12)*t +3./2)*t -OVER_2_3)*t : \
372
  (i == 5 ? (((-1./12*t + 1./4 )*t -1./4)*t + OVER_12)*t : \
373
  0)))))))
374
375
376
/* ------------------------ TMF_d0_c3_1ef --------------------- */
377
378
#define TMF_d0_c3_1ef(a, i, t) ( \
379
  (i == 0 ? (((-20*t +70)*t -84)*t +35)*t*t*t*t : \
380
  (i == 1 ? ((( 20*t -70)*t +84)*t -35)*t*t*t*t +1 : \
381
  0)))
382
383
384
/* ------------------------ TMF_d0_c3_2ef --------------------- */
385
386
#define TMF_d0_c3_2ef(a, i, t) ( \
387
  TMF_d0_c3_3ef((double)(a), i, t))
388
389
390
/* ------------------------ TMF_d0_c3_3ef --------------------- */
391
392
#define TMF_d0_c3_3ef(a, i, t) ( \
393
  (i == 0 ? ((((( 3*t -10.5)*t +12.5)*t - 5)*t*t +0  )*t +0  )*t    : \
394
  (i == 1 ? (((((-9*t +31.5)*t -37.5)*t +15)*t*t +0.5)*t +0.5)*t    : \
395
  (i == 2 ? ((((( 9*t -31.5)*t +37.5)*t -15)*t*t -1  )*t +0  )*t +1 : \
396
  (i == 3 ? (((((-3*t +10.5)*t -12.5)*t + 5)*t*t +0.5)*t -0.5)*t    : \
397
  0)))))
398
399
400
/* ------------------------ TMF_d0_c3_4ef --------------------- */
401
402
#define TMF_d0_c3_4ef(a, i, t) ( \
403
  (i == 0 ? ((((( 7./48*t - 3./8)*t +11./48)*t +0    )*t + 0    )*t +       0)*t : \
404
  (i == 1 ? (((((-7./16*t + 1   )*t - 3./8 )*t +1./12)*t - 3./16)*t - OVER_12)*t : \
405
  (i == 2 ? ((((( 7./24*t - 1./4)*t -19./24)*t -1./6 )*t + 5./4 )*t +OVER_2_3)*t : \
406
  (i == 3 ? ((((( 7./24*t - 3./2)*t + 7./3 )*t +0    )*t -17./8 )*t +       0)*t +1 : \
407
  (i == 4 ? (((((-7./16*t +13./8)*t -31./16)*t +1./6 )*t + 5./4 )*t -OVER_2_3)*t : \
408
  (i == 5 ? ((((( 7./48*t - 1./2)*t +13./24)*t -1./12)*t - 3./16)*t + OVER_12)*t : \
409
  0)))))))
410
411
412
/* ------------------------ TMF_d1_cn_1ef --------------------- */
413
414
#define TMF_d1_cn_1ef(a, i, t) ( \
415
  (i == 0 ? 1 : \
416
  (i == 1 ? -1 : \
417
  0)))
418
419
420
/* ------------------------ TMF_d1_cn_2ef --------------------- */
421
422
#define TMF_d1_cn_2ef(a, i, t) ( \
423
  (i == 0 ? 0.5*t +(  a    ) : \
424
  (i == 1 ? -0.5*t -(3*a-0.5) : \
425
  (i == 2 ? -0.5*t +(3*a    ) : \
426
  (i == 3 ? 0.5*t -(  a+0.5) : \
427
  0)))))
428
429
430
/* ------------------------ TMF_d1_cn_3ef --------------------- */
431
432
#define TMF_d1_cn_3ef(a, i, t) ( \
433
  (i == 0 ? ( 0.5*t +0)*t -OVER_6 : \
434
  (i == 1 ? (-1.5*t +1)*t +1 : \
435
  (i == 2 ? ( 1.5*t -2)*t -0.5 : \
436
  (i == 3 ? (-0.5*t +1)*t -OVER_3 : \
437
  0)))))
438
439
440
/* ------------------------ TMF_d1_cn_4ef --------------------- */
441
442
#define TMF_d1_cn_4ef(a, i, t) ( \
443
  TMF_d1_c0_4ef((double)(a), i, t))
444
445
446
/* ------------------------ TMF_d1_c0_1ef --------------------- */
447
448
#define TMF_d1_c0_1ef(a, i, t) ( \
449
  TMF_d1_c0_2ef((double)(a), i, t))
450
451
452
/* ------------------------ TMF_d1_c0_2ef --------------------- */
453
454
#define TMF_d1_c0_2ef(a, i, t) ( \
455
  TMF_d1_cn_2ef((double)(0), i, t))
456
457
458
/* ------------------------ TMF_d1_c0_3ef --------------------- */
459
460
#define TMF_d1_c0_3ef(a, i, t) ( \
461
  (i == 0 ? ( (   a    )*t -(   a+OVER_12))*t +0 : \
462
  (i == 1 ? (-( 5*a-0.5)*t +( 5*a+   0.25))*t -OVER_12 : \
463
  (i == 2 ? ( (10*a-1.5)*t -(10*a-   5./6))*t +OVER_2_3 : \
464
  (i == 3 ? (-(10*a-1.5)*t +(10*a-  13./6))*t +0 : \
465
  (i == 4 ? ( ( 5*a-0.5)*t -( 5*a-   1.25))*t -OVER_2_3 : \
466
  (i == 5 ? (-(   a    )*t +(   a-OVER_12))*t +OVER_12 : \
467
  0)))))))
468
469
470
/* ------------------------ TMF_d1_c0_4ef --------------------- */
471
472
#define TMF_d1_c0_4ef(a, i, t) ( \
473
  (i == 0 ? ((OVER_12*t +(   a     ))*t -(   a+ OVER_6))*t +0 : \
474
  (i == 1 ? ((  -0.25*t -( 5*a-0.25))*t +( 5*a+   0.75))*t -OVER_12 : \
475
  (i == 2 ? (( OVER_6*t +(10*a- 0.5))*t -(10*a+ OVER_3))*t +OVER_2_3 : \
476
  (i == 3 ? (( OVER_6*t -(10*a     ))*t +(10*a-   5./6))*t +0 : \
477
  (i == 4 ? ((  -0.25*t +( 5*a+ 0.5))*t -( 5*a-    0.5))*t -OVER_2_3 : \
478
  (i == 5 ? ((OVER_12*t -(   a+0.25))*t +(   a+OVER_12))*t +OVER_12 : \
479
  0)))))))
480
481
482
/* ------------------------ TMF_d1_c1_1ef --------------------- */
483
484
#define TMF_d1_c1_1ef(a, i, t) ( \
485
  TMF_d1_c1_2ef((double)(a), i, t))
486
487
488
/* ------------------------ TMF_d1_c1_2ef --------------------- */
489
490
#define TMF_d1_c1_2ef(a, i, t) ( \
491
  (i == 0 ? ( 0.5*t +0)*t +0 : \
492
  (i == 1 ? (-1.5*t +1)*t +0.5 : \
493
  (i == 2 ? ( 1.5*t -2)*t +0 : \
494
  (i == 3 ? (-0.5*t +1)*t -0.5 : \
495
  0)))))
496
497
498
/* ------------------------ TMF_d1_c1_3ef --------------------- */
499
500
#define TMF_d1_c1_3ef(a, i, t) ( \
501
  TMF_d1_c0_3ef((double)(-1./12), i, t))
502
503
504
/* ------------------------ TMF_d1_c1_4ef --------------------- */
505
506
#define TMF_d1_c1_4ef(a, i, t) ( \
507
  TMF_d1_c0_4ef((double)(-1./6), i, t))
508
509
510
/* ------------------------ TMF_d1_c2_1ef --------------------- */
511
512
#define TMF_d1_c2_1ef(a, i, t) ( \
513
  TMF_d1_c2_2ef((double)(a), i, t))
514
515
516
/* ------------------------ TMF_d1_c2_2ef --------------------- */
517
518
#define TMF_d1_c2_2ef(a, i, t) ( \
519
  (i == 0 ? ((-0.5*t +1)*t*t +0)*t +0 : \
520
  (i == 1 ? (( 1.5*t -3)*t*t +1)*t +0.5 : \
521
  (i == 2 ? ((-1.5*t +3)*t*t -2)*t +0 : \
522
  (i == 3 ? (( 0.5*t -1)*t*t +1)*t -0.5 : \
523
  0)))))
524
525
526
/* ------------------------ TMF_d1_c2_3ef --------------------- */
527
528
#define TMF_d1_c2_3ef(a, i, t) ( \
529
  TMF_d1_c2_4ef((double)(a), i, t))
530
531
532
/* ------------------------ TMF_d1_c2_4ef --------------------- */
533
534
#define TMF_d1_c2_4ef(a, i, t) ( \
535
  (i == 0 ? ((( OVER_6*t -  0.25)*t +   0)*t +      0)*t +0 : \
536
  (i == 1 ? (((-  5./6*t +17./12)*t +0.25)*t -OVER_12)*t -OVER_12 : \
537
  (i == 2 ? (((   5./3*t - 19./6)*t -0.5 )*t +   4./3)*t +OVER_2_3 : \
538
  (i == 3 ? (((-  5./3*t +   3.5)*t +0   )*t -    2.5)*t +0 : \
539
  (i == 4 ? (((   5./6*t -23./12)*t +0.5 )*t +   4./3)*t -OVER_2_3 : \
540
  (i == 5 ? (((-OVER_6*t + 5./12)*t -0.25)*t -OVER_12)*t +OVER_12 : \
541
  0)))))))
542
543
544
/* ------------------------ TMF_d1_c3_1ef --------------------- */
545
546
#define TMF_d1_c3_1ef(a, i, t) ( \
547
  (i == 0 ? (((-0.75*t +1.25)*t +  0)*t*t +   0)*t +0 : \
548
  (i == 1 ? ((( 0.75*t +   0)*t -2.5)*t*t +1.25)*t +0.5 : \
549
  (i == 2 ? ((( 0.75*t -3.75)*t +5  )*t*t -2.5 )*t +0 : \
550
  (i == 3 ? (((-0.75*t +2.5 )*t -2.5)*t*t +1.25)*t -0.5 : \
551
  0)))))
552
553
554
/* ------------------------ TMF_d1_c3_2ef --------------------- */
555
556
#define TMF_d1_c3_2ef(a, i, t) ( \
557
  (i == 0 ? ((( 1*t -3)*t +2.5)*t*t*t +0)*t +0 : \
558
  (i == 1 ? (((-3*t +9)*t -7.5)*t*t*t +1)*t +0.5 : \
559
  (i == 2 ? ((( 3*t -9)*t +7.5)*t*t*t -2)*t +0 : \
560
  (i == 3 ? (((-1*t +3)*t -2.5)*t*t*t +1)*t -0.5 : \
561
  0)))))
562
563
564
/* ------------------------ TMF_d1_c3_3ef --------------------- */
565
566
#define TMF_d1_c3_3ef(a, i, t) ( \
567
  (i == 0 ? (((( 3./16*t -  13./48)*t +     0)*t +   0)*t +     0)*t +0 : \
568
  (i == 1 ? ((((-9./16*t +   5./12)*t +19./24)*t +0.25)*t - 7./48)*t -OVER_12 : \
569
  (i == 2 ? (((( 3./8 *t +  25./24)*t -19./6 )*t - 0.5)*t +19./12)*t +OVER_2_3 : \
570
  (i == 3 ? (((( 3./8 *t -  35./12)*t +19./4 )*t +   0)*t -23./8 )*t +0 : \
571
  (i == 4 ? ((((-9./16*t + 115./48)*t -19./6 )*t + 0.5)*t +19./12)*t -OVER_2_3 : \
572
  (i == 5 ? (((( 3./16*t -OVER_2_3)*t +19./24)*t -0.25)*t - 7./48)*t +OVER_12 : \
573
  0)))))))
574
575
576
/* ------------------------ TMF_d1_c3_4ef --------------------- */
577
578
#define TMF_d1_c3_4ef(a, i, t) ( \
579
  (i == 0 ? (((((-0.25*t +0.75)*t - 7./12)*t +       0)*t +   0)*t +      0)*t +0 : \
580
  (i == 1 ? ((((( 1.25*t -3.75)*t +35./12)*t +  OVER_6)*t +0.25)*t -OVER_12)*t -OVER_12 : \
581
  (i == 2 ? ((((( -2.5*t + 7.5)*t -35./6 )*t -OVER_2_3)*t - 0.5)*t +   4./3)*t +OVER_2_3 : \
582
  (i == 3 ? (((((  2.5*t - 7.5)*t +35./6 )*t +       1)*t +   0)*t -   5./2)*t +0 : \
583
  (i == 4 ? (((((-1.25*t +3.75)*t -35./12)*t -OVER_2_3)*t + 0.5)*t +   4./3)*t -OVER_2_3 : \
584
  (i == 5 ? ((((( 0.25*t -0.75)*t + 7./12)*t +  OVER_6)*t -0.25)*t -OVER_12)*t +OVER_12 : \
585
  0)))))))
586
587
588
/* ------------------------ TMF_d2_cn_1ef --------------------- */
589
590
#define TMF_d2_cn_1ef(a, i, t) ( \
591
  (i == 0 ? 0.5 : \
592
  (i == 1 ? -0.5 : \
593
  (i == 2 ? -0.5 : \
594
  (i == 3 ? 0.5 : \
595
  0)))))
596
597
598
/* ------------------------ TMF_d2_cn_2ef --------------------- */
599
600
#define TMF_d2_cn_2ef(a, i, t) ( \
601
  TMF_d2_c0_2ef((double)(a), i, t))
602
603
604
/* ------------------------ TMF_d2_cn_3ef --------------------- */
605
606
#define TMF_d2_cn_3ef(a, i, t) ( \
607
  (i == 0 ? ( 0.25*t +(a-30)/120)*t -(a+10)/240 : \
608
  (i == 1 ? (-0.75*t -(a-42)/24 )*t +(a+ 6)/48 : \
609
  (i == 2 ? ( 0.5 *t +(a-42)/12 )*t -(a-22)/24 : \
610
  (i == 3 ? ( 0.5 *t -(a-30)/12 )*t +(a-50)/24 : \
611
  (i == 4 ? (-0.75*t +(a- 6)/24 )*t -(a-54)/48 : \
612
  (i == 5 ? ( 0.25*t -(a+30)/120)*t +(a-10)/240 : \
613
  0)))))))
614
615
616
/* ------------------------ TMF_d2_cn_4ef --------------------- */
617
618
#define TMF_d2_cn_4ef(a, i, t) ( \
619
  TMF_d2_c0_4ef((double)(a), i, t))
620
621
622
/* ------------------------ TMF_d2_c0_1ef --------------------- */
623
624
#define TMF_d2_c0_1ef(a, i, t) ( \
625
  TMF_d2_c0_2ef((double)(a), i, t))
626
627
628
/* ------------------------ TMF_d2_c0_2ef --------------------- */
629
630
#define TMF_d2_c0_2ef(a, i, t) ( \
631
  (i == 0 ? t : \
632
  (i == 1 ? -3*t +1 : \
633
  (i == 2 ? 3*t -2 : \
634
  (i == 3 ? -  t +1 : \
635
  0)))))
636
637
638
/* ------------------------ TMF_d2_c0_3ef --------------------- */
639
640
#define TMF_d2_c0_3ef(a, i, t) ( \
641
  TMF_d2_cn_3ef((double)(-10), i, t))
642
643
644
/* ------------------------ TMF_d2_c0_4ef --------------------- */
645
646
#define TMF_d2_c0_4ef(a, i, t) ( \
647
  (i == 0 ? (( 1./6*t +0  )*t -0.25)*t +    0 : \
648
  (i == 1 ? ((-5./6*t +0.5)*t +1.75)*t -1./12 : \
649
  (i == 2 ? (( 5./3*t -2  )*t -3.5 )*t + 4./3 : \
650
  (i == 3 ? ((-5./3*t +3  )*t +2.5 )*t -  2.5 : \
651
  (i == 4 ? (( 5./6*t -2  )*t -0.25)*t + 4./3 : \
652
  (i == 5 ? ((-1./6*t +0.5)*t -0.25)*t -1./12 : \
653
  0)))))))
654
655
656
/* ------------------------ TMF_d2_c1_1ef --------------------- */
657
658
#define TMF_d2_c1_1ef(a, i, t) ( \
659
  (i == 0 ? (-2*t +3)*t*t +0 : \
660
  (i == 1 ? ( 6*t -9)*t*t +1 : \
661
  (i == 2 ? (-6*t +9)*t*t -2 : \
662
  (i == 3 ? ( 2*t -3)*t*t +1 : \
663
  0)))))
664
665
666
/* ------------------------ TMF_d2_c1_2ef --------------------- */
667
668
#define TMF_d2_c1_2ef(a, i, t) ( \
669
  (i == 0 ? ( 0.25*t +0  )*t : \
670
  (i == 1 ? (-0.75*t +0.5)*t +0.25 : \
671
  (i == 2 ? ( 0.5 *t -1  )*t : \
672
  (i == 3 ? ( 0.5 *t +0  )*t -0.5 : \
673
  (i == 4 ? (-0.75*t +1  )*t : \
674
  (i == 5 ? ( 0.25*t -0.5)*t +0.25 : \
675
  0)))))))
676
677
678
/* ------------------------ TMF_d2_c1_3ef --------------------- */
679
680
#define TMF_d2_c1_3ef(a, i, t) ( \
681
  (i == 0 ? ((  2./3*t - 0.75)*t +0  )*t : \
682
  (i == 1 ? ((-10./3*t + 4.25)*t +0.5)*t -1./12 : \
683
  (i == 2 ? (( 20./3*t - 9.5 )*t -1  )*t +4./3 : \
684
  (i == 3 ? ((-20./3*t +10.5 )*t +0  )*t -2.5 : \
685
  (i == 4 ? (( 10./3*t - 5.75)*t +1  )*t +4./3 : \
686
  (i == 5 ? ((- 2./3*t + 1.25)*t -0.5)*t -1./12 : \
687
  0)))))))
688
689
690
/* ------------------------ TMF_d2_c1_4ef --------------------- */
691
692
#define TMF_d2_c1_4ef(a, i, t) ( \
693
  (i == 0 ? ((-(  a+ 53)/360*t +(  a+ 38)/240)*t +0    )*t : \
694
  (i == 1 ? (( (7*a+431)/360*t -(7*a+296)/240)*t - 1./8)*t +(a+ 8)/720 : \
695
  (i == 2 ? ((-(7*a+471)/120*t +(7*a+366)/80 )*t +1    )*t -(a+18)/120 : \
696
  (i == 3 ? (( (7*a+491)/72 *t -(7*a+452)/48 )*t -13./8)*t +(a+72)/48  : \
697
  (i == 4 ? ((-(7*a+491)/72 *t +(7*a+530)/48 )*t +0    )*t -(a+98)/36  : \
698
  (i == 5 ? (( (7*a+471)/120*t -(7*a+576)/80 )*t +13./8)*t +(a+72)/48  : \
699
  (i == 6 ? ((-(7*a+431)/360*t +(7*a+566)/240)*t -1    )*t -(a+18)/120 : \
700
  (i == 7 ? (( (  a+ 53)/360*t -(  a+ 68)/240)*t + 1./8)*t +(a+ 8)/720 : \
701
  0)))))))))
702
703
704
/* ------------------------ TMF_d2_c2_1ef --------------------- */
705
706
#define TMF_d2_c2_1ef(a, i, t) ( \
707
  (i == 0 ? ((  6*t -15)*t +10)*t*t*t : \
708
  (i == 1 ? ((-18*t +45)*t -30)*t*t*t +1 : \
709
  (i == 2 ? (( 18*t -45)*t +30)*t*t*t -2 : \
710
  (i == 3 ? ((- 6*t +15)*t -10)*t*t*t +1 : \
711
  0)))))
712
713
714
/* ------------------------ TMF_d2_c2_2ef --------------------- */
715
716
#define TMF_d2_c2_2ef(a, i, t) ( \
717
  (i == 0 ? (( 1./6*t +0  )*t +0  )*t : \
718
  (i == 1 ? ((-5./6*t +0.5)*t +0.5)*t +1./6 : \
719
  (i == 2 ? (( 5./3*t -2  )*t -1  )*t +1./3 : \
720
  (i == 3 ? ((-5./3*t +3  )*t +0  )*t -1 : \
721
  (i == 4 ? (( 5./6*t -2  )*t +1  )*t +1./3 : \
722
  (i == 5 ? ((-1./6*t +0.5)*t -0.5)*t +1./6 : \
723
  0)))))))
724
725
726
/* ------------------------ TMF_d2_c2_3ef --------------------- */
727
728
#define TMF_d2_c2_3ef(a, i, t) ( \
729
  (i == 0 ? ((((-1.5*t + 3.75)*t - 7./3)*t +0  )*t +0  )*t : \
730
  (i == 1 ? (((( 7.5*t -18.75)*t +35./3)*t +0.5)*t +0.5)*t -1./12 : \
731
  (i == 2 ? ((((- 15*t +37.5 )*t -70./3)*t -2  )*t -1  )*t +4./3  : \
732
  (i == 3 ? ((((  15*t -37.5 )*t +70./3)*t +3  )*t +0  )*t -2.5   : \
733
  (i == 4 ? ((((-7.5*t +18.75)*t -35./3)*t -2  )*t +1  )*t +4./3  : \
734
  (i == 5 ? (((( 1.5*t - 3.75)*t + 7./3)*t +0.5)*t -0.5)*t -1./12 : \
735
  0)))))))
736
737
738
/* ------------------------ TMF_d2_c2_4ef --------------------- */
739
740
#define TMF_d2_c2_4ef(a, i, t) ( \
741
  TMF_d2_c1_4ef((double)(-38), i, t))
742
743
744
/* ------------------------ TMF_d2_c3_1ef --------------------- */
745
746
#define TMF_d2_c3_1ef(a, i, t) ( \
747
  (i == 0 ? (((-20*t + 70)*t - 84)*t + 35)*t*t*t*t : \
748
  (i == 1 ? ((( 60*t -210)*t +252)*t -105)*t*t*t*t +1 : \
749
  (i == 2 ? (((-60*t +210)*t -252)*t +105)*t*t*t*t -2 : \
750
  (i == 3 ? ((( 20*t - 70)*t + 84)*t - 35)*t*t*t*t +1 : \
751
  0)))))
752
753
754
/* ------------------------ TMF_d2_c3_2ef --------------------- */
755
756
#define TMF_d2_c3_2ef(a, i, t) ( \
757
  (i == 0 ? (((-0.1*t +0.25)*t*t +  0)*t +0  )*t : \
758
  (i == 1 ? ((( 0.5*t -1.25)*t*t +0.5)*t +0.5)*t +3./20 : \
759
  (i == 2 ? (((-1  *t +2.5 )*t*t -2  )*t -1  )*t +2./5 : \
760
  (i == 3 ? ((( 1  *t -2.5 )*t*t +3  )*t +0  )*t -11./10 : \
761
  (i == 4 ? (((-0.5*t +1.25)*t*t -2  )*t +1  )*t +2./5 : \
762
  (i == 5 ? ((( 0.1*t -0.25)*t*t +0.5)*t -0.5)*t +3./20 : \
763
  0)))))))
764
765
766
/* ------------------------ TMF_d2_c3_3ef --------------------- */
767
768
#define TMF_d2_c3_3ef(a, i, t) ( \
769
  (i == 0 ? (((((  14./3*t - 49./3)*t + 39./2)*t - 95./12)*t*t +0  )*t +0  )*t : \
770
  (i == 1 ? (((((- 70./3*t +245./3)*t -195./2)*t +475./12)*t*t +0.5)*t +0.5)*t -1./12 : \
771
  (i == 2 ? ((((( 140./3*t -490./3)*t +195   )*t -475./6 )*t*t -2  )*t -1  )*t +4./3 : \
772
  (i == 3 ? (((((-140./3*t +490./3)*t -195   )*t +475./6 )*t*t +3  )*t +0  )*t -5./2 : \
773
  (i == 4 ? (((((  70./3*t -245./3)*t +195./2)*t -475./12)*t*t -2  )*t +1  )*t +4./3 : \
774
  (i == 5 ? (((((- 14./3*t + 49./3)*t - 39./2)*t + 95./12)*t*t +0.5)*t -0.5)*t -1./12 : \
775
  0)))))))
776
777
778
/* ------------------------ TMF_d2_c3_4ef --------------------- */
779
780
#define TMF_d2_c3_4ef(a, i, t) ( \
781
  (i == 0 ? ((((  1./24*t - 1./12)*t +0    )*t +0    )*t +0    )*t : \
782
  (i == 1 ? ((((- 7./24*t + 5./8 )*t +1./12)*t -1./12)*t - 1./8)*t - 1./24 : \
783
  (i == 2 ? ((((  7./8 *t - 2    )*t -1./3 )*t +1    )*t +1    )*t + 1./6 : \
784
  (i == 3 ? ((((-35./24*t +85./24)*t +5./12)*t -13./4)*t -13./8)*t +17./24 : \
785
  (i == 4 ? (((( 35./24*t -15./4 )*t +0    )*t +14./3)*t +0    )*t - 5./3 : \
786
  (i == 5 ? ((((- 7./8 *t +19./8 )*t -5./12)*t -13./4)*t +13./8)*t +17./24 : \
787
  (i == 6 ? ((((  7./24*t - 5./6 )*t +1./3 )*t +1    )*t -1    )*t + 1./6 : \
788
  (i == 7 ? ((((- 1./24*t + 1./8 )*t -1./12)*t -1./12)*t + 1./8)*t - 1./24 : \
789
  0)))))))))
790
791
792
/* ------------------------ TMF_dn_cn_1ef --------------------- */
793
794
static double _nrrd_TMF_dn_cn_1ef_Int(const double *parm) {
795
  AIR_UNUSED(parm);
796
4
  return 1.0;
797
}
798
799
static double _nrrd_TMF_dn_cn_1ef_Sup(const double *parm) {
800
  AIR_UNUSED(parm);
801
4
  return 1;
802
}
803
804
static double
805
_nrrd_TMF_dn_cn_1ef_1_d(double x, const double *parm) {
806
  int i;
807
808
  AIR_UNUSED(parm); /* TMF_dn_cn_1ef */
809
480024
  x += 1;
810
240012
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
811
240012
  x -= i;
812
600036
  return TMF_dn_cn_1ef(parm[0], i, x);
813
}
814
815
static float
816
_nrrd_TMF_dn_cn_1ef_1_f(float x, const double *parm) {
817
  int i;
818
819
  AIR_UNUSED(parm); /* TMF_dn_cn_1ef */
820
480000
  x += 1;
821
240000
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
822
240000
  x -= AIR_CAST(float, i);
823
600000
  return AIR_CAST(float, TMF_dn_cn_1ef(parm[0], i, x));
824
}
825
826
static void
827
_nrrd_TMF_dn_cn_1ef_N_d(double *f, const double *x, size_t len, const double *parm) {
828
  double t;
829
  size_t I;
830
  int i;
831
832
  AIR_UNUSED(parm); /* TMF_dn_cn_1ef */
833
480006
  for (I=0; I<len; I++) {
834
240000
    t = x[I] + 1;
835
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
836
240000
    t -= i;
837
600000
    f[I] = TMF_dn_cn_1ef(parm[0], i, t);
838
  }
839
2
}
840
841
static void
842
_nrrd_TMF_dn_cn_1ef_N_f(float *f, const float *x, size_t len, const double *parm) {
843
  float t;
844
  size_t I;
845
  int i;
846
847
  AIR_UNUSED(parm); /* TMF_dn_cn_1ef */
848
480006
  for (I=0; I<len; I++) {
849
240000
    t = x[I] + 1;
850
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
851
240000
    t -= AIR_CAST(float, i);
852
600000
    f[I] = AIR_CAST(float, TMF_dn_cn_1ef(parm[0], i, t));
853
  }
854
2
}
855
856
static NrrdKernel
857
_nrrdKernel_TMF_dn_cn_1ef = {
858
  "TMF_dn_cn_1ef",
859
  1, _nrrd_TMF_dn_cn_1ef_Sup, _nrrd_TMF_dn_cn_1ef_Int,
860
  _nrrd_TMF_dn_cn_1ef_1_f,  _nrrd_TMF_dn_cn_1ef_N_f,
861
  _nrrd_TMF_dn_cn_1ef_1_d,  _nrrd_TMF_dn_cn_1ef_N_d
862
};
863
864
865
/* ------------------------ TMF_dn_cn_2ef --------------------- */
866
867
static double _nrrd_TMF_dn_cn_2ef_Int(const double *parm) {
868
  AIR_UNUSED(parm);
869
4
  return 1.0;
870
}
871
872
static double _nrrd_TMF_dn_cn_2ef_Sup(const double *parm) {
873
  AIR_UNUSED(parm);
874
4
  return 1;
875
}
876
877
static double
878
_nrrd_TMF_dn_cn_2ef_1_d(double x, const double *parm) {
879
  int i;
880
881
  AIR_UNUSED(parm); /* TMF_dn_cn_2ef */
882
480024
  x += 1;
883
240012
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
884
240012
  x -= i;
885
720036
  return TMF_dn_cn_2ef(parm[0], i, x);
886
}
887
888
static float
889
_nrrd_TMF_dn_cn_2ef_1_f(float x, const double *parm) {
890
  int i;
891
892
  AIR_UNUSED(parm); /* TMF_dn_cn_2ef */
893
480000
  x += 1;
894
240000
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
895
240000
  x -= AIR_CAST(float, i);
896
720000
  return AIR_CAST(float, TMF_dn_cn_2ef(parm[0], i, x));
897
}
898
899
static void
900
_nrrd_TMF_dn_cn_2ef_N_d(double *f, const double *x, size_t len, const double *parm) {
901
  double t;
902
  size_t I;
903
  int i;
904
905
  AIR_UNUSED(parm); /* TMF_dn_cn_2ef */
906
480006
  for (I=0; I<len; I++) {
907
240000
    t = x[I] + 1;
908
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
909
240000
    t -= i;
910
720000
    f[I] = TMF_dn_cn_2ef(parm[0], i, t);
911
  }
912
2
}
913
914
static void
915
_nrrd_TMF_dn_cn_2ef_N_f(float *f, const float *x, size_t len, const double *parm) {
916
  float t;
917
  size_t I;
918
  int i;
919
920
  AIR_UNUSED(parm); /* TMF_dn_cn_2ef */
921
480006
  for (I=0; I<len; I++) {
922
240000
    t = x[I] + 1;
923
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
924
240000
    t -= AIR_CAST(float, i);
925
720000
    f[I] = AIR_CAST(float, TMF_dn_cn_2ef(parm[0], i, t));
926
  }
927
2
}
928
929
static NrrdKernel
930
_nrrdKernel_TMF_dn_cn_2ef = {
931
  "TMF_dn_cn_2ef",
932
  1, _nrrd_TMF_dn_cn_2ef_Sup, _nrrd_TMF_dn_cn_2ef_Int,
933
  _nrrd_TMF_dn_cn_2ef_1_f,  _nrrd_TMF_dn_cn_2ef_N_f,
934
  _nrrd_TMF_dn_cn_2ef_1_d,  _nrrd_TMF_dn_cn_2ef_N_d
935
};
936
937
938
/* ------------------------ TMF_dn_cn_3ef --------------------- */
939
940
static double _nrrd_TMF_dn_cn_3ef_Int(const double *parm) {
941
  AIR_UNUSED(parm);
942
4
  return 1.0;
943
}
944
945
static double _nrrd_TMF_dn_cn_3ef_Sup(const double *parm) {
946
  AIR_UNUSED(parm);
947
4
  return 2;
948
}
949
950
static double
951
_nrrd_TMF_dn_cn_3ef_1_d(double x, const double *parm) {
952
  int i;
953
954
955
480024
  x += 2;
956
240012
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
957
240012
  x -= i;
958


1080060
  return TMF_dn_cn_3ef(parm[0], i, x);
959
}
960
961
static float
962
_nrrd_TMF_dn_cn_3ef_1_f(float x, const double *parm) {
963
  int i;
964
965
966
480000
  x += 2;
967
240000
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
968
240000
  x -= AIR_CAST(float, i);
969


1080000
  return AIR_CAST(float, TMF_dn_cn_3ef(parm[0], i, x));
970
}
971
972
static void
973
_nrrd_TMF_dn_cn_3ef_N_d(double *f, const double *x, size_t len, const double *parm) {
974
  double t;
975
  size_t I;
976
  int i;
977
978
979
480006
  for (I=0; I<len; I++) {
980
240000
    t = x[I] + 2;
981
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
982
240000
    t -= i;
983


1080000
    f[I] = TMF_dn_cn_3ef(parm[0], i, t);
984
  }
985
2
}
986
987
static void
988
_nrrd_TMF_dn_cn_3ef_N_f(float *f, const float *x, size_t len, const double *parm) {
989
  float t;
990
  size_t I;
991
  int i;
992
993
994
480006
  for (I=0; I<len; I++) {
995
240000
    t = x[I] + 2;
996
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
997
240000
    t -= AIR_CAST(float, i);
998


1080000
    f[I] = AIR_CAST(float, TMF_dn_cn_3ef(parm[0], i, t));
999
  }
1000
2
}
1001
1002
static NrrdKernel
1003
_nrrdKernel_TMF_dn_cn_3ef = {
1004
  "TMF_dn_cn_3ef",
1005
  1, _nrrd_TMF_dn_cn_3ef_Sup, _nrrd_TMF_dn_cn_3ef_Int,
1006
  _nrrd_TMF_dn_cn_3ef_1_f,  _nrrd_TMF_dn_cn_3ef_N_f,
1007
  _nrrd_TMF_dn_cn_3ef_1_d,  _nrrd_TMF_dn_cn_3ef_N_d
1008
};
1009
1010
1011
/* ------------------------ TMF_dn_cn_4ef --------------------- */
1012
1013
static double _nrrd_TMF_dn_cn_4ef_Int(const double *parm) {
1014
  AIR_UNUSED(parm);
1015
4
  return 1.0;
1016
}
1017
1018
static double _nrrd_TMF_dn_cn_4ef_Sup(const double *parm) {
1019
  AIR_UNUSED(parm);
1020
4
  return 2;
1021
}
1022
1023
static double
1024
_nrrd_TMF_dn_cn_4ef_1_d(double x, const double *parm) {
1025
  int i;
1026
1027
  AIR_UNUSED(parm); /* TMF_dn_cn_4ef */
1028
480024
  x += 2;
1029
240012
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
1030
240012
  x -= i;
1031


1080060
  return TMF_dn_cn_4ef(parm[0], i, x);
1032
}
1033
1034
static float
1035
_nrrd_TMF_dn_cn_4ef_1_f(float x, const double *parm) {
1036
  int i;
1037
1038
  AIR_UNUSED(parm); /* TMF_dn_cn_4ef */
1039
480000
  x += 2;
1040
240000
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
1041
240000
  x -= AIR_CAST(float, i);
1042


1080000
  return AIR_CAST(float, TMF_dn_cn_4ef(parm[0], i, x));
1043
}
1044
1045
static void
1046
_nrrd_TMF_dn_cn_4ef_N_d(double *f, const double *x, size_t len, const double *parm) {
1047
  double t;
1048
  size_t I;
1049
  int i;
1050
1051
  AIR_UNUSED(parm); /* TMF_dn_cn_4ef */
1052
480006
  for (I=0; I<len; I++) {
1053
240000
    t = x[I] + 2;
1054
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
1055
240000
    t -= i;
1056


1080000
    f[I] = TMF_dn_cn_4ef(parm[0], i, t);
1057
  }
1058
2
}
1059
1060
static void
1061
_nrrd_TMF_dn_cn_4ef_N_f(float *f, const float *x, size_t len, const double *parm) {
1062
  float t;
1063
  size_t I;
1064
  int i;
1065
1066
  AIR_UNUSED(parm); /* TMF_dn_cn_4ef */
1067
480006
  for (I=0; I<len; I++) {
1068
240000
    t = x[I] + 2;
1069
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
1070
240000
    t -= AIR_CAST(float, i);
1071


1080000
    f[I] = AIR_CAST(float, TMF_dn_cn_4ef(parm[0], i, t));
1072
  }
1073
2
}
1074
1075
static NrrdKernel
1076
_nrrdKernel_TMF_dn_cn_4ef = {
1077
  "TMF_dn_cn_4ef",
1078
  1, _nrrd_TMF_dn_cn_4ef_Sup, _nrrd_TMF_dn_cn_4ef_Int,
1079
  _nrrd_TMF_dn_cn_4ef_1_f,  _nrrd_TMF_dn_cn_4ef_N_f,
1080
  _nrrd_TMF_dn_cn_4ef_1_d,  _nrrd_TMF_dn_cn_4ef_N_d
1081
};
1082
1083
1084
/* ------------------------ TMF_dn_c0_1ef --------------------- */
1085
1086
static double _nrrd_TMF_dn_c0_1ef_Int(const double *parm) {
1087
  AIR_UNUSED(parm);
1088
4
  return 1.0;
1089
}
1090
1091
static double _nrrd_TMF_dn_c0_1ef_Sup(const double *parm) {
1092
  AIR_UNUSED(parm);
1093
4
  return 1;
1094
}
1095
1096
static double
1097
_nrrd_TMF_dn_c0_1ef_1_d(double x, const double *parm) {
1098
  int i;
1099
1100
  AIR_UNUSED(parm); /* TMF_dn_c0_1ef */
1101
480024
  x += 1;
1102
240012
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
1103
240012
  x -= i;
1104
720036
  return TMF_dn_c0_1ef(parm[0], i, x);
1105
}
1106
1107
static float
1108
_nrrd_TMF_dn_c0_1ef_1_f(float x, const double *parm) {
1109
  int i;
1110
1111
  AIR_UNUSED(parm); /* TMF_dn_c0_1ef */
1112
480000
  x += 1;
1113
240000
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
1114
240000
  x -= AIR_CAST(float, i);
1115
720000
  return AIR_CAST(float, TMF_dn_c0_1ef(parm[0], i, x));
1116
}
1117
1118
static void
1119
_nrrd_TMF_dn_c0_1ef_N_d(double *f, const double *x, size_t len, const double *parm) {
1120
  double t;
1121
  size_t I;
1122
  int i;
1123
1124
  AIR_UNUSED(parm); /* TMF_dn_c0_1ef */
1125
480006
  for (I=0; I<len; I++) {
1126
240000
    t = x[I] + 1;
1127
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
1128
240000
    t -= i;
1129
720000
    f[I] = TMF_dn_c0_1ef(parm[0], i, t);
1130
  }
1131
2
}
1132
1133
static void
1134
_nrrd_TMF_dn_c0_1ef_N_f(float *f, const float *x, size_t len, const double *parm) {
1135
  float t;
1136
  size_t I;
1137
  int i;
1138
1139
  AIR_UNUSED(parm); /* TMF_dn_c0_1ef */
1140
480006
  for (I=0; I<len; I++) {
1141
240000
    t = x[I] + 1;
1142
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
1143
240000
    t -= AIR_CAST(float, i);
1144
720000
    f[I] = AIR_CAST(float, TMF_dn_c0_1ef(parm[0], i, t));
1145
  }
1146
2
}
1147
1148
static NrrdKernel
1149
_nrrdKernel_TMF_dn_c0_1ef = {
1150
  "TMF_dn_c0_1ef",
1151
  1, _nrrd_TMF_dn_c0_1ef_Sup, _nrrd_TMF_dn_c0_1ef_Int,
1152
  _nrrd_TMF_dn_c0_1ef_1_f,  _nrrd_TMF_dn_c0_1ef_N_f,
1153
  _nrrd_TMF_dn_c0_1ef_1_d,  _nrrd_TMF_dn_c0_1ef_N_d
1154
};
1155
1156
1157
/* ------------------------ TMF_dn_c0_2ef --------------------- */
1158
1159
static double _nrrd_TMF_dn_c0_2ef_Int(const double *parm) {
1160
  AIR_UNUSED(parm);
1161
4
  return 1.0;
1162
}
1163
1164
static double _nrrd_TMF_dn_c0_2ef_Sup(const double *parm) {
1165
  AIR_UNUSED(parm);
1166
4
  return 1;
1167
}
1168
1169
static double
1170
_nrrd_TMF_dn_c0_2ef_1_d(double x, const double *parm) {
1171
  int i;
1172
1173
  AIR_UNUSED(parm); /* TMF_dn_c0_2ef */
1174
480024
  x += 1;
1175
240012
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
1176
240012
  x -= i;
1177
720036
  return TMF_dn_c0_2ef(parm[0], i, x);
1178
}
1179
1180
static float
1181
_nrrd_TMF_dn_c0_2ef_1_f(float x, const double *parm) {
1182
  int i;
1183
1184
  AIR_UNUSED(parm); /* TMF_dn_c0_2ef */
1185
480000
  x += 1;
1186
240000
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
1187
240000
  x -= AIR_CAST(float, i);
1188
720000
  return AIR_CAST(float, TMF_dn_c0_2ef(parm[0], i, x));
1189
}
1190
1191
static void
1192
_nrrd_TMF_dn_c0_2ef_N_d(double *f, const double *x, size_t len, const double *parm) {
1193
  double t;
1194
  size_t I;
1195
  int i;
1196
1197
  AIR_UNUSED(parm); /* TMF_dn_c0_2ef */
1198
480006
  for (I=0; I<len; I++) {
1199
240000
    t = x[I] + 1;
1200
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
1201
240000
    t -= i;
1202
720000
    f[I] = TMF_dn_c0_2ef(parm[0], i, t);
1203
  }
1204
2
}
1205
1206
static void
1207
_nrrd_TMF_dn_c0_2ef_N_f(float *f, const float *x, size_t len, const double *parm) {
1208
  float t;
1209
  size_t I;
1210
  int i;
1211
1212
  AIR_UNUSED(parm); /* TMF_dn_c0_2ef */
1213
480006
  for (I=0; I<len; I++) {
1214
240000
    t = x[I] + 1;
1215
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
1216
240000
    t -= AIR_CAST(float, i);
1217
720000
    f[I] = AIR_CAST(float, TMF_dn_c0_2ef(parm[0], i, t));
1218
  }
1219
2
}
1220
1221
static NrrdKernel
1222
_nrrdKernel_TMF_dn_c0_2ef = {
1223
  "TMF_dn_c0_2ef",
1224
  1, _nrrd_TMF_dn_c0_2ef_Sup, _nrrd_TMF_dn_c0_2ef_Int,
1225
  _nrrd_TMF_dn_c0_2ef_1_f,  _nrrd_TMF_dn_c0_2ef_N_f,
1226
  _nrrd_TMF_dn_c0_2ef_1_d,  _nrrd_TMF_dn_c0_2ef_N_d
1227
};
1228
1229
1230
/* ------------------------ TMF_dn_c0_3ef --------------------- */
1231
1232
static double _nrrd_TMF_dn_c0_3ef_Int(const double *parm) {
1233
  AIR_UNUSED(parm);
1234
4
  return 1.0;
1235
}
1236
1237
static double _nrrd_TMF_dn_c0_3ef_Sup(const double *parm) {
1238
  AIR_UNUSED(parm);
1239
4
  return 2;
1240
}
1241
1242
static double
1243
_nrrd_TMF_dn_c0_3ef_1_d(double x, const double *parm) {
1244
  int i;
1245
1246
  AIR_UNUSED(parm); /* TMF_dn_c0_3ef */
1247
480024
  x += 2;
1248
240012
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
1249
240012
  x -= i;
1250


1080060
  return TMF_dn_c0_3ef(parm[0], i, x);
1251
}
1252
1253
static float
1254
_nrrd_TMF_dn_c0_3ef_1_f(float x, const double *parm) {
1255
  int i;
1256
1257
  AIR_UNUSED(parm); /* TMF_dn_c0_3ef */
1258
480000
  x += 2;
1259
240000
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
1260
240000
  x -= AIR_CAST(float, i);
1261


1080000
  return AIR_CAST(float, TMF_dn_c0_3ef(parm[0], i, x));
1262
}
1263
1264
static void
1265
_nrrd_TMF_dn_c0_3ef_N_d(double *f, const double *x, size_t len, const double *parm) {
1266
  double t;
1267
  size_t I;
1268
  int i;
1269
1270
  AIR_UNUSED(parm); /* TMF_dn_c0_3ef */
1271
480006
  for (I=0; I<len; I++) {
1272
240000
    t = x[I] + 2;
1273
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
1274
240000
    t -= i;
1275


1080000
    f[I] = TMF_dn_c0_3ef(parm[0], i, t);
1276
  }
1277
2
}
1278
1279
static void
1280
_nrrd_TMF_dn_c0_3ef_N_f(float *f, const float *x, size_t len, const double *parm) {
1281
  float t;
1282
  size_t I;
1283
  int i;
1284
1285
  AIR_UNUSED(parm); /* TMF_dn_c0_3ef */
1286
480006
  for (I=0; I<len; I++) {
1287
240000
    t = x[I] + 2;
1288
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
1289
240000
    t -= AIR_CAST(float, i);
1290


1080000
    f[I] = AIR_CAST(float, TMF_dn_c0_3ef(parm[0], i, t));
1291
  }
1292
2
}
1293
1294
static NrrdKernel
1295
_nrrdKernel_TMF_dn_c0_3ef = {
1296
  "TMF_dn_c0_3ef",
1297
  1, _nrrd_TMF_dn_c0_3ef_Sup, _nrrd_TMF_dn_c0_3ef_Int,
1298
  _nrrd_TMF_dn_c0_3ef_1_f,  _nrrd_TMF_dn_c0_3ef_N_f,
1299
  _nrrd_TMF_dn_c0_3ef_1_d,  _nrrd_TMF_dn_c0_3ef_N_d
1300
};
1301
1302
1303
/* ------------------------ TMF_dn_c0_4ef --------------------- */
1304
1305
static double _nrrd_TMF_dn_c0_4ef_Int(const double *parm) {
1306
  AIR_UNUSED(parm);
1307
4
  return 1.0;
1308
}
1309
1310
static double _nrrd_TMF_dn_c0_4ef_Sup(const double *parm) {
1311
  AIR_UNUSED(parm);
1312
4
  return 2;
1313
}
1314
1315
static double
1316
_nrrd_TMF_dn_c0_4ef_1_d(double x, const double *parm) {
1317
  int i;
1318
1319
  AIR_UNUSED(parm); /* TMF_dn_c0_4ef */
1320
480024
  x += 2;
1321
240012
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
1322
240012
  x -= i;
1323


1080060
  return TMF_dn_c0_4ef(parm[0], i, x);
1324
}
1325
1326
static float
1327
_nrrd_TMF_dn_c0_4ef_1_f(float x, const double *parm) {
1328
  int i;
1329
1330
  AIR_UNUSED(parm); /* TMF_dn_c0_4ef */
1331
480000
  x += 2;
1332
240000
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
1333
240000
  x -= AIR_CAST(float, i);
1334


1080000
  return AIR_CAST(float, TMF_dn_c0_4ef(parm[0], i, x));
1335
}
1336
1337
static void
1338
_nrrd_TMF_dn_c0_4ef_N_d(double *f, const double *x, size_t len, const double *parm) {
1339
  double t;
1340
  size_t I;
1341
  int i;
1342
1343
  AIR_UNUSED(parm); /* TMF_dn_c0_4ef */
1344
480006
  for (I=0; I<len; I++) {
1345
240000
    t = x[I] + 2;
1346
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
1347
240000
    t -= i;
1348


1080000
    f[I] = TMF_dn_c0_4ef(parm[0], i, t);
1349
  }
1350
2
}
1351
1352
static void
1353
_nrrd_TMF_dn_c0_4ef_N_f(float *f, const float *x, size_t len, const double *parm) {
1354
  float t;
1355
  size_t I;
1356
  int i;
1357
1358
  AIR_UNUSED(parm); /* TMF_dn_c0_4ef */
1359
480006
  for (I=0; I<len; I++) {
1360
240000
    t = x[I] + 2;
1361
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
1362
240000
    t -= AIR_CAST(float, i);
1363


1080000
    f[I] = AIR_CAST(float, TMF_dn_c0_4ef(parm[0], i, t));
1364
  }
1365
2
}
1366
1367
static NrrdKernel
1368
_nrrdKernel_TMF_dn_c0_4ef = {
1369
  "TMF_dn_c0_4ef",
1370
  1, _nrrd_TMF_dn_c0_4ef_Sup, _nrrd_TMF_dn_c0_4ef_Int,
1371
  _nrrd_TMF_dn_c0_4ef_1_f,  _nrrd_TMF_dn_c0_4ef_N_f,
1372
  _nrrd_TMF_dn_c0_4ef_1_d,  _nrrd_TMF_dn_c0_4ef_N_d
1373
};
1374
1375
1376
/* ------------------------ TMF_dn_c1_1ef --------------------- */
1377
1378
static double _nrrd_TMF_dn_c1_1ef_Int(const double *parm) {
1379
  AIR_UNUSED(parm);
1380
4
  return 1.0;
1381
}
1382
1383
static double _nrrd_TMF_dn_c1_1ef_Sup(const double *parm) {
1384
  AIR_UNUSED(parm);
1385
4
  return 1;
1386
}
1387
1388
static double
1389
_nrrd_TMF_dn_c1_1ef_1_d(double x, const double *parm) {
1390
  int i;
1391
1392
  AIR_UNUSED(parm); /* TMF_dn_c1_1ef */
1393
480024
  x += 1;
1394
240012
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
1395
240012
  x -= i;
1396

840036
  return TMF_dn_c1_1ef(parm[0], i, x);
1397
}
1398
1399
static float
1400
_nrrd_TMF_dn_c1_1ef_1_f(float x, const double *parm) {
1401
  int i;
1402
1403
  AIR_UNUSED(parm); /* TMF_dn_c1_1ef */
1404
480000
  x += 1;
1405
240000
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
1406
240000
  x -= AIR_CAST(float, i);
1407

840000
  return AIR_CAST(float, TMF_dn_c1_1ef(parm[0], i, x));
1408
}
1409
1410
static void
1411
_nrrd_TMF_dn_c1_1ef_N_d(double *f, const double *x, size_t len, const double *parm) {
1412
  double t;
1413
  size_t I;
1414
  int i;
1415
1416
  AIR_UNUSED(parm); /* TMF_dn_c1_1ef */
1417
480006
  for (I=0; I<len; I++) {
1418
240000
    t = x[I] + 1;
1419
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
1420
240000
    t -= i;
1421

840000
    f[I] = TMF_dn_c1_1ef(parm[0], i, t);
1422
  }
1423
2
}
1424
1425
static void
1426
_nrrd_TMF_dn_c1_1ef_N_f(float *f, const float *x, size_t len, const double *parm) {
1427
  float t;
1428
  size_t I;
1429
  int i;
1430
1431
  AIR_UNUSED(parm); /* TMF_dn_c1_1ef */
1432
480006
  for (I=0; I<len; I++) {
1433
240000
    t = x[I] + 1;
1434
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
1435
240000
    t -= AIR_CAST(float, i);
1436

840000
    f[I] = AIR_CAST(float, TMF_dn_c1_1ef(parm[0], i, t));
1437
  }
1438
2
}
1439
1440
static NrrdKernel
1441
_nrrdKernel_TMF_dn_c1_1ef = {
1442
  "TMF_dn_c1_1ef",
1443
  1, _nrrd_TMF_dn_c1_1ef_Sup, _nrrd_TMF_dn_c1_1ef_Int,
1444
  _nrrd_TMF_dn_c1_1ef_1_f,  _nrrd_TMF_dn_c1_1ef_N_f,
1445
  _nrrd_TMF_dn_c1_1ef_1_d,  _nrrd_TMF_dn_c1_1ef_N_d
1446
};
1447
1448
1449
/* ------------------------ TMF_dn_c1_2ef --------------------- */
1450
1451
static double _nrrd_TMF_dn_c1_2ef_Int(const double *parm) {
1452
  AIR_UNUSED(parm);
1453
4
  return 1.0;
1454
}
1455
1456
static double _nrrd_TMF_dn_c1_2ef_Sup(const double *parm) {
1457
  AIR_UNUSED(parm);
1458
4
  return 2;
1459
}
1460
1461
static double
1462
_nrrd_TMF_dn_c1_2ef_1_d(double x, const double *parm) {
1463
  int i;
1464
1465
  AIR_UNUSED(parm); /* TMF_dn_c1_2ef */
1466
480024
  x += 2;
1467
240012
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
1468
240012
  x -= i;
1469


1080060
  return TMF_dn_c1_2ef(parm[0], i, x);
1470
}
1471
1472
static float
1473
_nrrd_TMF_dn_c1_2ef_1_f(float x, const double *parm) {
1474
  int i;
1475
1476
  AIR_UNUSED(parm); /* TMF_dn_c1_2ef */
1477
480000
  x += 2;
1478
240000
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
1479
240000
  x -= AIR_CAST(float, i);
1480


1080000
  return AIR_CAST(float, TMF_dn_c1_2ef(parm[0], i, x));
1481
}
1482
1483
static void
1484
_nrrd_TMF_dn_c1_2ef_N_d(double *f, const double *x, size_t len, const double *parm) {
1485
  double t;
1486
  size_t I;
1487
  int i;
1488
1489
  AIR_UNUSED(parm); /* TMF_dn_c1_2ef */
1490
480006
  for (I=0; I<len; I++) {
1491
240000
    t = x[I] + 2;
1492
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
1493
240000
    t -= i;
1494


1080000
    f[I] = TMF_dn_c1_2ef(parm[0], i, t);
1495
  }
1496
2
}
1497
1498
static void
1499
_nrrd_TMF_dn_c1_2ef_N_f(float *f, const float *x, size_t len, const double *parm) {
1500
  float t;
1501
  size_t I;
1502
  int i;
1503
1504
  AIR_UNUSED(parm); /* TMF_dn_c1_2ef */
1505
480006
  for (I=0; I<len; I++) {
1506
240000
    t = x[I] + 2;
1507
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
1508
240000
    t -= AIR_CAST(float, i);
1509


1080000
    f[I] = AIR_CAST(float, TMF_dn_c1_2ef(parm[0], i, t));
1510
  }
1511
2
}
1512
1513
static NrrdKernel
1514
_nrrdKernel_TMF_dn_c1_2ef = {
1515
  "TMF_dn_c1_2ef",
1516
  1, _nrrd_TMF_dn_c1_2ef_Sup, _nrrd_TMF_dn_c1_2ef_Int,
1517
  _nrrd_TMF_dn_c1_2ef_1_f,  _nrrd_TMF_dn_c1_2ef_N_f,
1518
  _nrrd_TMF_dn_c1_2ef_1_d,  _nrrd_TMF_dn_c1_2ef_N_d
1519
};
1520
1521
1522
/* ------------------------ TMF_dn_c1_3ef --------------------- */
1523
1524
static double _nrrd_TMF_dn_c1_3ef_Int(const double *parm) {
1525
  AIR_UNUSED(parm);
1526
4
  return 1.0;
1527
}
1528
1529
static double _nrrd_TMF_dn_c1_3ef_Sup(const double *parm) {
1530
  AIR_UNUSED(parm);
1531
4
  return 2;
1532
}
1533
1534
static double
1535
_nrrd_TMF_dn_c1_3ef_1_d(double x, const double *parm) {
1536
  int i;
1537
1538
  AIR_UNUSED(parm); /* TMF_dn_c1_3ef */
1539
480024
  x += 2;
1540
240012
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
1541
240012
  x -= i;
1542


1080060
  return TMF_dn_c1_3ef(parm[0], i, x);
1543
}
1544
1545
static float
1546
_nrrd_TMF_dn_c1_3ef_1_f(float x, const double *parm) {
1547
  int i;
1548
1549
  AIR_UNUSED(parm); /* TMF_dn_c1_3ef */
1550
480000
  x += 2;
1551
240000
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
1552
240000
  x -= AIR_CAST(float, i);
1553


1080000
  return AIR_CAST(float, TMF_dn_c1_3ef(parm[0], i, x));
1554
}
1555
1556
static void
1557
_nrrd_TMF_dn_c1_3ef_N_d(double *f, const double *x, size_t len, const double *parm) {
1558
  double t;
1559
  size_t I;
1560
  int i;
1561
1562
  AIR_UNUSED(parm); /* TMF_dn_c1_3ef */
1563
480006
  for (I=0; I<len; I++) {
1564
240000
    t = x[I] + 2;
1565
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
1566
240000
    t -= i;
1567


1080000
    f[I] = TMF_dn_c1_3ef(parm[0], i, t);
1568
  }
1569
2
}
1570
1571
static void
1572
_nrrd_TMF_dn_c1_3ef_N_f(float *f, const float *x, size_t len, const double *parm) {
1573
  float t;
1574
  size_t I;
1575
  int i;
1576
1577
  AIR_UNUSED(parm); /* TMF_dn_c1_3ef */
1578
480006
  for (I=0; I<len; I++) {
1579
240000
    t = x[I] + 2;
1580
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
1581
240000
    t -= AIR_CAST(float, i);
1582


1080000
    f[I] = AIR_CAST(float, TMF_dn_c1_3ef(parm[0], i, t));
1583
  }
1584
2
}
1585
1586
static NrrdKernel
1587
_nrrdKernel_TMF_dn_c1_3ef = {
1588
  "TMF_dn_c1_3ef",
1589
  1, _nrrd_TMF_dn_c1_3ef_Sup, _nrrd_TMF_dn_c1_3ef_Int,
1590
  _nrrd_TMF_dn_c1_3ef_1_f,  _nrrd_TMF_dn_c1_3ef_N_f,
1591
  _nrrd_TMF_dn_c1_3ef_1_d,  _nrrd_TMF_dn_c1_3ef_N_d
1592
};
1593
1594
1595
/* ------------------------ TMF_dn_c1_4ef --------------------- */
1596
1597
static double _nrrd_TMF_dn_c1_4ef_Int(const double *parm) {
1598
  AIR_UNUSED(parm);
1599
4
  return 1.0;
1600
}
1601
1602
static double _nrrd_TMF_dn_c1_4ef_Sup(const double *parm) {
1603
  AIR_UNUSED(parm);
1604
4
  return 3;
1605
}
1606
1607
static double
1608
_nrrd_TMF_dn_c1_4ef_1_d(double x, const double *parm) {
1609
  int i;
1610
1611
1612
480024
  x += 3;
1613
240012
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
1614
240012
  x -= i;
1615



1320084
  return TMF_dn_c1_4ef(parm[0], i, x);
1616
}
1617
1618
static float
1619
_nrrd_TMF_dn_c1_4ef_1_f(float x, const double *parm) {
1620
  int i;
1621
1622
1623
480000
  x += 3;
1624
240000
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
1625
240000
  x -= AIR_CAST(float, i);
1626



1320000
  return AIR_CAST(float, TMF_dn_c1_4ef(parm[0], i, x));
1627
}
1628
1629
static void
1630
_nrrd_TMF_dn_c1_4ef_N_d(double *f, const double *x, size_t len, const double *parm) {
1631
  double t;
1632
  size_t I;
1633
  int i;
1634
1635
1636
480006
  for (I=0; I<len; I++) {
1637
240000
    t = x[I] + 3;
1638
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
1639
240000
    t -= i;
1640



1320000
    f[I] = TMF_dn_c1_4ef(parm[0], i, t);
1641
  }
1642
2
}
1643
1644
static void
1645
_nrrd_TMF_dn_c1_4ef_N_f(float *f, const float *x, size_t len, const double *parm) {
1646
  float t;
1647
  size_t I;
1648
  int i;
1649
1650
1651
480006
  for (I=0; I<len; I++) {
1652
240000
    t = x[I] + 3;
1653
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
1654
240000
    t -= AIR_CAST(float, i);
1655



1320000
    f[I] = AIR_CAST(float, TMF_dn_c1_4ef(parm[0], i, t));
1656
  }
1657
2
}
1658
1659
static NrrdKernel
1660
_nrrdKernel_TMF_dn_c1_4ef = {
1661
  "TMF_dn_c1_4ef",
1662
  1, _nrrd_TMF_dn_c1_4ef_Sup, _nrrd_TMF_dn_c1_4ef_Int,
1663
  _nrrd_TMF_dn_c1_4ef_1_f,  _nrrd_TMF_dn_c1_4ef_N_f,
1664
  _nrrd_TMF_dn_c1_4ef_1_d,  _nrrd_TMF_dn_c1_4ef_N_d
1665
};
1666
1667
1668
/* ------------------------ TMF_dn_c2_1ef --------------------- */
1669
1670
static double _nrrd_TMF_dn_c2_1ef_Int(const double *parm) {
1671
  AIR_UNUSED(parm);
1672
4
  return 1.0;
1673
}
1674
1675
static double _nrrd_TMF_dn_c2_1ef_Sup(const double *parm) {
1676
  AIR_UNUSED(parm);
1677
4
  return 1;
1678
}
1679
1680
static double
1681
_nrrd_TMF_dn_c2_1ef_1_d(double x, const double *parm) {
1682
  int i;
1683
1684
  AIR_UNUSED(parm); /* TMF_dn_c2_1ef */
1685
480024
  x += 1;
1686
240012
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
1687
240012
  x -= i;
1688

840036
  return TMF_dn_c2_1ef(parm[0], i, x);
1689
}
1690
1691
static float
1692
_nrrd_TMF_dn_c2_1ef_1_f(float x, const double *parm) {
1693
  int i;
1694
1695
  AIR_UNUSED(parm); /* TMF_dn_c2_1ef */
1696
480000
  x += 1;
1697
240000
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
1698
240000
  x -= AIR_CAST(float, i);
1699

840000
  return AIR_CAST(float, TMF_dn_c2_1ef(parm[0], i, x));
1700
}
1701
1702
static void
1703
_nrrd_TMF_dn_c2_1ef_N_d(double *f, const double *x, size_t len, const double *parm) {
1704
  double t;
1705
  size_t I;
1706
  int i;
1707
1708
  AIR_UNUSED(parm); /* TMF_dn_c2_1ef */
1709
480006
  for (I=0; I<len; I++) {
1710
240000
    t = x[I] + 1;
1711
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
1712
240000
    t -= i;
1713

840000
    f[I] = TMF_dn_c2_1ef(parm[0], i, t);
1714
  }
1715
2
}
1716
1717
static void
1718
_nrrd_TMF_dn_c2_1ef_N_f(float *f, const float *x, size_t len, const double *parm) {
1719
  float t;
1720
  size_t I;
1721
  int i;
1722
1723
  AIR_UNUSED(parm); /* TMF_dn_c2_1ef */
1724
480006
  for (I=0; I<len; I++) {
1725
240000
    t = x[I] + 1;
1726
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
1727
240000
    t -= AIR_CAST(float, i);
1728

840000
    f[I] = AIR_CAST(float, TMF_dn_c2_1ef(parm[0], i, t));
1729
  }
1730
2
}
1731
1732
static NrrdKernel
1733
_nrrdKernel_TMF_dn_c2_1ef = {
1734
  "TMF_dn_c2_1ef",
1735
  1, _nrrd_TMF_dn_c2_1ef_Sup, _nrrd_TMF_dn_c2_1ef_Int,
1736
  _nrrd_TMF_dn_c2_1ef_1_f,  _nrrd_TMF_dn_c2_1ef_N_f,
1737
  _nrrd_TMF_dn_c2_1ef_1_d,  _nrrd_TMF_dn_c2_1ef_N_d
1738
};
1739
1740
1741
/* ------------------------ TMF_dn_c2_2ef --------------------- */
1742
1743
static double _nrrd_TMF_dn_c2_2ef_Int(const double *parm) {
1744
  AIR_UNUSED(parm);
1745
4
  return 1.0;
1746
}
1747
1748
static double _nrrd_TMF_dn_c2_2ef_Sup(const double *parm) {
1749
  AIR_UNUSED(parm);
1750
4
  return 2;
1751
}
1752
1753
static double
1754
_nrrd_TMF_dn_c2_2ef_1_d(double x, const double *parm) {
1755
  int i;
1756
1757
  AIR_UNUSED(parm); /* TMF_dn_c2_2ef */
1758
480024
  x += 2;
1759
240012
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
1760
240012
  x -= i;
1761


1080060
  return TMF_dn_c2_2ef(parm[0], i, x);
1762
}
1763
1764
static float
1765
_nrrd_TMF_dn_c2_2ef_1_f(float x, const double *parm) {
1766
  int i;
1767
1768
  AIR_UNUSED(parm); /* TMF_dn_c2_2ef */
1769
480000
  x += 2;
1770
240000
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
1771
240000
  x -= AIR_CAST(float, i);
1772


1080000
  return AIR_CAST(float, TMF_dn_c2_2ef(parm[0], i, x));
1773
}
1774
1775
static void
1776
_nrrd_TMF_dn_c2_2ef_N_d(double *f, const double *x, size_t len, const double *parm) {
1777
  double t;
1778
  size_t I;
1779
  int i;
1780
1781
  AIR_UNUSED(parm); /* TMF_dn_c2_2ef */
1782
480006
  for (I=0; I<len; I++) {
1783
240000
    t = x[I] + 2;
1784
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
1785
240000
    t -= i;
1786


1080000
    f[I] = TMF_dn_c2_2ef(parm[0], i, t);
1787
  }
1788
2
}
1789
1790
static void
1791
_nrrd_TMF_dn_c2_2ef_N_f(float *f, const float *x, size_t len, const double *parm) {
1792
  float t;
1793
  size_t I;
1794
  int i;
1795
1796
  AIR_UNUSED(parm); /* TMF_dn_c2_2ef */
1797
480006
  for (I=0; I<len; I++) {
1798
240000
    t = x[I] + 2;
1799
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
1800
240000
    t -= AIR_CAST(float, i);
1801


1080000
    f[I] = AIR_CAST(float, TMF_dn_c2_2ef(parm[0], i, t));
1802
  }
1803
2
}
1804
1805
static NrrdKernel
1806
_nrrdKernel_TMF_dn_c2_2ef = {
1807
  "TMF_dn_c2_2ef",
1808
  1, _nrrd_TMF_dn_c2_2ef_Sup, _nrrd_TMF_dn_c2_2ef_Int,
1809
  _nrrd_TMF_dn_c2_2ef_1_f,  _nrrd_TMF_dn_c2_2ef_N_f,
1810
  _nrrd_TMF_dn_c2_2ef_1_d,  _nrrd_TMF_dn_c2_2ef_N_d
1811
};
1812
1813
1814
/* ------------------------ TMF_dn_c2_3ef --------------------- */
1815
1816
static double _nrrd_TMF_dn_c2_3ef_Int(const double *parm) {
1817
  AIR_UNUSED(parm);
1818
4
  return 1.0;
1819
}
1820
1821
static double _nrrd_TMF_dn_c2_3ef_Sup(const double *parm) {
1822
  AIR_UNUSED(parm);
1823
4
  return 2;
1824
}
1825
1826
static double
1827
_nrrd_TMF_dn_c2_3ef_1_d(double x, const double *parm) {
1828
  int i;
1829
1830
  AIR_UNUSED(parm); /* TMF_dn_c2_3ef */
1831
480024
  x += 2;
1832
240012
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
1833
240012
  x -= i;
1834


1080060
  return TMF_dn_c2_3ef(parm[0], i, x);
1835
}
1836
1837
static float
1838
_nrrd_TMF_dn_c2_3ef_1_f(float x, const double *parm) {
1839
  int i;
1840
1841
  AIR_UNUSED(parm); /* TMF_dn_c2_3ef */
1842
480000
  x += 2;
1843
240000
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
1844
240000
  x -= AIR_CAST(float, i);
1845


1080000
  return AIR_CAST(float, TMF_dn_c2_3ef(parm[0], i, x));
1846
}
1847
1848
static void
1849
_nrrd_TMF_dn_c2_3ef_N_d(double *f, const double *x, size_t len, const double *parm) {
1850
  double t;
1851
  size_t I;
1852
  int i;
1853
1854
  AIR_UNUSED(parm); /* TMF_dn_c2_3ef */
1855
480006
  for (I=0; I<len; I++) {
1856
240000
    t = x[I] + 2;
1857
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
1858
240000
    t -= i;
1859


1080000
    f[I] = TMF_dn_c2_3ef(parm[0], i, t);
1860
  }
1861
2
}
1862
1863
static void
1864
_nrrd_TMF_dn_c2_3ef_N_f(float *f, const float *x, size_t len, const double *parm) {
1865
  float t;
1866
  size_t I;
1867
  int i;
1868
1869
  AIR_UNUSED(parm); /* TMF_dn_c2_3ef */
1870
480006
  for (I=0; I<len; I++) {
1871
240000
    t = x[I] + 2;
1872
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
1873
240000
    t -= AIR_CAST(float, i);
1874


1080000
    f[I] = AIR_CAST(float, TMF_dn_c2_3ef(parm[0], i, t));
1875
  }
1876
2
}
1877
1878
static NrrdKernel
1879
_nrrdKernel_TMF_dn_c2_3ef = {
1880
  "TMF_dn_c2_3ef",
1881
  1, _nrrd_TMF_dn_c2_3ef_Sup, _nrrd_TMF_dn_c2_3ef_Int,
1882
  _nrrd_TMF_dn_c2_3ef_1_f,  _nrrd_TMF_dn_c2_3ef_N_f,
1883
  _nrrd_TMF_dn_c2_3ef_1_d,  _nrrd_TMF_dn_c2_3ef_N_d
1884
};
1885
1886
1887
/* ------------------------ TMF_dn_c2_4ef --------------------- */
1888
1889
static double _nrrd_TMF_dn_c2_4ef_Int(const double *parm) {
1890
  AIR_UNUSED(parm);
1891
4
  return 1.0;
1892
}
1893
1894
static double _nrrd_TMF_dn_c2_4ef_Sup(const double *parm) {
1895
  AIR_UNUSED(parm);
1896
4
  return 3;
1897
}
1898
1899
static double
1900
_nrrd_TMF_dn_c2_4ef_1_d(double x, const double *parm) {
1901
  int i;
1902
1903
  AIR_UNUSED(parm); /* TMF_dn_c2_4ef */
1904
480024
  x += 3;
1905
240012
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
1906
240012
  x -= i;
1907



1320084
  return TMF_dn_c2_4ef(parm[0], i, x);
1908
}
1909
1910
static float
1911
_nrrd_TMF_dn_c2_4ef_1_f(float x, const double *parm) {
1912
  int i;
1913
1914
  AIR_UNUSED(parm); /* TMF_dn_c2_4ef */
1915
480000
  x += 3;
1916
240000
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
1917
240000
  x -= AIR_CAST(float, i);
1918



1320000
  return AIR_CAST(float, TMF_dn_c2_4ef(parm[0], i, x));
1919
}
1920
1921
static void
1922
_nrrd_TMF_dn_c2_4ef_N_d(double *f, const double *x, size_t len, const double *parm) {
1923
  double t;
1924
  size_t I;
1925
  int i;
1926
1927
  AIR_UNUSED(parm); /* TMF_dn_c2_4ef */
1928
480006
  for (I=0; I<len; I++) {
1929
240000
    t = x[I] + 3;
1930
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
1931
240000
    t -= i;
1932



1320000
    f[I] = TMF_dn_c2_4ef(parm[0], i, t);
1933
  }
1934
2
}
1935
1936
static void
1937
_nrrd_TMF_dn_c2_4ef_N_f(float *f, const float *x, size_t len, const double *parm) {
1938
  float t;
1939
  size_t I;
1940
  int i;
1941
1942
  AIR_UNUSED(parm); /* TMF_dn_c2_4ef */
1943
480006
  for (I=0; I<len; I++) {
1944
240000
    t = x[I] + 3;
1945
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
1946
240000
    t -= AIR_CAST(float, i);
1947



1320000
    f[I] = AIR_CAST(float, TMF_dn_c2_4ef(parm[0], i, t));
1948
  }
1949
2
}
1950
1951
static NrrdKernel
1952
_nrrdKernel_TMF_dn_c2_4ef = {
1953
  "TMF_dn_c2_4ef",
1954
  1, _nrrd_TMF_dn_c2_4ef_Sup, _nrrd_TMF_dn_c2_4ef_Int,
1955
  _nrrd_TMF_dn_c2_4ef_1_f,  _nrrd_TMF_dn_c2_4ef_N_f,
1956
  _nrrd_TMF_dn_c2_4ef_1_d,  _nrrd_TMF_dn_c2_4ef_N_d
1957
};
1958
1959
1960
/* ------------------------ TMF_dn_c3_1ef --------------------- */
1961
1962
static double _nrrd_TMF_dn_c3_1ef_Int(const double *parm) {
1963
  AIR_UNUSED(parm);
1964
4
  return 1.0;
1965
}
1966
1967
static double _nrrd_TMF_dn_c3_1ef_Sup(const double *parm) {
1968
  AIR_UNUSED(parm);
1969
4
  return 1;
1970
}
1971
1972
static double
1973
_nrrd_TMF_dn_c3_1ef_1_d(double x, const double *parm) {
1974
  int i;
1975
1976
  AIR_UNUSED(parm); /* TMF_dn_c3_1ef */
1977
480024
  x += 1;
1978
240012
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
1979
240012
  x -= i;
1980

840036
  return TMF_dn_c3_1ef(parm[0], i, x);
1981
}
1982
1983
static float
1984
_nrrd_TMF_dn_c3_1ef_1_f(float x, const double *parm) {
1985
  int i;
1986
1987
  AIR_UNUSED(parm); /* TMF_dn_c3_1ef */
1988
480000
  x += 1;
1989
240000
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
1990
240000
  x -= AIR_CAST(float, i);
1991

840000
  return AIR_CAST(float, TMF_dn_c3_1ef(parm[0], i, x));
1992
}
1993
1994
static void
1995
_nrrd_TMF_dn_c3_1ef_N_d(double *f, const double *x, size_t len, const double *parm) {
1996
  double t;
1997
  size_t I;
1998
  int i;
1999
2000
  AIR_UNUSED(parm); /* TMF_dn_c3_1ef */
2001
480006
  for (I=0; I<len; I++) {
2002
240000
    t = x[I] + 1;
2003
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
2004
240000
    t -= i;
2005

840000
    f[I] = TMF_dn_c3_1ef(parm[0], i, t);
2006
  }
2007
2
}
2008
2009
static void
2010
_nrrd_TMF_dn_c3_1ef_N_f(float *f, const float *x, size_t len, const double *parm) {
2011
  float t;
2012
  size_t I;
2013
  int i;
2014
2015
  AIR_UNUSED(parm); /* TMF_dn_c3_1ef */
2016
480006
  for (I=0; I<len; I++) {
2017
240000
    t = x[I] + 1;
2018
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
2019
240000
    t -= AIR_CAST(float, i);
2020

840000
    f[I] = AIR_CAST(float, TMF_dn_c3_1ef(parm[0], i, t));
2021
  }
2022
2
}
2023
2024
static NrrdKernel
2025
_nrrdKernel_TMF_dn_c3_1ef = {
2026
  "TMF_dn_c3_1ef",
2027
  1, _nrrd_TMF_dn_c3_1ef_Sup, _nrrd_TMF_dn_c3_1ef_Int,
2028
  _nrrd_TMF_dn_c3_1ef_1_f,  _nrrd_TMF_dn_c3_1ef_N_f,
2029
  _nrrd_TMF_dn_c3_1ef_1_d,  _nrrd_TMF_dn_c3_1ef_N_d
2030
};
2031
2032
2033
/* ------------------------ TMF_dn_c3_2ef --------------------- */
2034
2035
static double _nrrd_TMF_dn_c3_2ef_Int(const double *parm) {
2036
  AIR_UNUSED(parm);
2037
4
  return 1.0;
2038
}
2039
2040
static double _nrrd_TMF_dn_c3_2ef_Sup(const double *parm) {
2041
  AIR_UNUSED(parm);
2042
4
  return 2;
2043
}
2044
2045
static double
2046
_nrrd_TMF_dn_c3_2ef_1_d(double x, const double *parm) {
2047
  int i;
2048
2049
  AIR_UNUSED(parm); /* TMF_dn_c3_2ef */
2050
480024
  x += 2;
2051
240012
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
2052
240012
  x -= i;
2053


1080060
  return TMF_dn_c3_2ef(parm[0], i, x);
2054
}
2055
2056
static float
2057
_nrrd_TMF_dn_c3_2ef_1_f(float x, const double *parm) {
2058
  int i;
2059
2060
  AIR_UNUSED(parm); /* TMF_dn_c3_2ef */
2061
480000
  x += 2;
2062
240000
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
2063
240000
  x -= AIR_CAST(float, i);
2064


1080000
  return AIR_CAST(float, TMF_dn_c3_2ef(parm[0], i, x));
2065
}
2066
2067
static void
2068
_nrrd_TMF_dn_c3_2ef_N_d(double *f, const double *x, size_t len, const double *parm) {
2069
  double t;
2070
  size_t I;
2071
  int i;
2072
2073
  AIR_UNUSED(parm); /* TMF_dn_c3_2ef */
2074
480006
  for (I=0; I<len; I++) {
2075
240000
    t = x[I] + 2;
2076
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
2077
240000
    t -= i;
2078


1080000
    f[I] = TMF_dn_c3_2ef(parm[0], i, t);
2079
  }
2080
2
}
2081
2082
static void
2083
_nrrd_TMF_dn_c3_2ef_N_f(float *f, const float *x, size_t len, const double *parm) {
2084
  float t;
2085
  size_t I;
2086
  int i;
2087
2088
  AIR_UNUSED(parm); /* TMF_dn_c3_2ef */
2089
480006
  for (I=0; I<len; I++) {
2090
240000
    t = x[I] + 2;
2091
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
2092
240000
    t -= AIR_CAST(float, i);
2093


1080000
    f[I] = AIR_CAST(float, TMF_dn_c3_2ef(parm[0], i, t));
2094
  }
2095
2
}
2096
2097
static NrrdKernel
2098
_nrrdKernel_TMF_dn_c3_2ef = {
2099
  "TMF_dn_c3_2ef",
2100
  1, _nrrd_TMF_dn_c3_2ef_Sup, _nrrd_TMF_dn_c3_2ef_Int,
2101
  _nrrd_TMF_dn_c3_2ef_1_f,  _nrrd_TMF_dn_c3_2ef_N_f,
2102
  _nrrd_TMF_dn_c3_2ef_1_d,  _nrrd_TMF_dn_c3_2ef_N_d
2103
};
2104
2105
2106
/* ------------------------ TMF_dn_c3_3ef --------------------- */
2107
2108
static double _nrrd_TMF_dn_c3_3ef_Int(const double *parm) {
2109
  AIR_UNUSED(parm);
2110
4
  return 1.0;
2111
}
2112
2113
static double _nrrd_TMF_dn_c3_3ef_Sup(const double *parm) {
2114
  AIR_UNUSED(parm);
2115
4
  return 2;
2116
}
2117
2118
static double
2119
_nrrd_TMF_dn_c3_3ef_1_d(double x, const double *parm) {
2120
  int i;
2121
2122
  AIR_UNUSED(parm); /* TMF_dn_c3_3ef */
2123
480024
  x += 2;
2124
240012
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
2125
240012
  x -= i;
2126


1080060
  return TMF_dn_c3_3ef(parm[0], i, x);
2127
}
2128
2129
static float
2130
_nrrd_TMF_dn_c3_3ef_1_f(float x, const double *parm) {
2131
  int i;
2132
2133
  AIR_UNUSED(parm); /* TMF_dn_c3_3ef */
2134
480000
  x += 2;
2135
240000
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
2136
240000
  x -= AIR_CAST(float, i);
2137


1080000
  return AIR_CAST(float, TMF_dn_c3_3ef(parm[0], i, x));
2138
}
2139
2140
static void
2141
_nrrd_TMF_dn_c3_3ef_N_d(double *f, const double *x, size_t len, const double *parm) {
2142
  double t;
2143
  size_t I;
2144
  int i;
2145
2146
  AIR_UNUSED(parm); /* TMF_dn_c3_3ef */
2147
480006
  for (I=0; I<len; I++) {
2148
240000
    t = x[I] + 2;
2149
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
2150
240000
    t -= i;
2151


1080000
    f[I] = TMF_dn_c3_3ef(parm[0], i, t);
2152
  }
2153
2
}
2154
2155
static void
2156
_nrrd_TMF_dn_c3_3ef_N_f(float *f, const float *x, size_t len, const double *parm) {
2157
  float t;
2158
  size_t I;
2159
  int i;
2160
2161
  AIR_UNUSED(parm); /* TMF_dn_c3_3ef */
2162
480006
  for (I=0; I<len; I++) {
2163
240000
    t = x[I] + 2;
2164
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
2165
240000
    t -= AIR_CAST(float, i);
2166


1080000
    f[I] = AIR_CAST(float, TMF_dn_c3_3ef(parm[0], i, t));
2167
  }
2168
2
}
2169
2170
static NrrdKernel
2171
_nrrdKernel_TMF_dn_c3_3ef = {
2172
  "TMF_dn_c3_3ef",
2173
  1, _nrrd_TMF_dn_c3_3ef_Sup, _nrrd_TMF_dn_c3_3ef_Int,
2174
  _nrrd_TMF_dn_c3_3ef_1_f,  _nrrd_TMF_dn_c3_3ef_N_f,
2175
  _nrrd_TMF_dn_c3_3ef_1_d,  _nrrd_TMF_dn_c3_3ef_N_d
2176
};
2177
2178
2179
/* ------------------------ TMF_dn_c3_4ef --------------------- */
2180
2181
static double _nrrd_TMF_dn_c3_4ef_Int(const double *parm) {
2182
  AIR_UNUSED(parm);
2183
4
  return 1.0;
2184
}
2185
2186
static double _nrrd_TMF_dn_c3_4ef_Sup(const double *parm) {
2187
  AIR_UNUSED(parm);
2188
4
  return 3;
2189
}
2190
2191
static double
2192
_nrrd_TMF_dn_c3_4ef_1_d(double x, const double *parm) {
2193
  int i;
2194
2195
  AIR_UNUSED(parm); /* TMF_dn_c3_4ef */
2196
480024
  x += 3;
2197
240012
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
2198
240012
  x -= i;
2199



1320084
  return TMF_dn_c3_4ef(parm[0], i, x);
2200
}
2201
2202
static float
2203
_nrrd_TMF_dn_c3_4ef_1_f(float x, const double *parm) {
2204
  int i;
2205
2206
  AIR_UNUSED(parm); /* TMF_dn_c3_4ef */
2207
480000
  x += 3;
2208
240000
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
2209
240000
  x -= AIR_CAST(float, i);
2210



1320000
  return AIR_CAST(float, TMF_dn_c3_4ef(parm[0], i, x));
2211
}
2212
2213
static void
2214
_nrrd_TMF_dn_c3_4ef_N_d(double *f, const double *x, size_t len, const double *parm) {
2215
  double t;
2216
  size_t I;
2217
  int i;
2218
2219
  AIR_UNUSED(parm); /* TMF_dn_c3_4ef */
2220
480006
  for (I=0; I<len; I++) {
2221
240000
    t = x[I] + 3;
2222
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
2223
240000
    t -= i;
2224



1320000
    f[I] = TMF_dn_c3_4ef(parm[0], i, t);
2225
  }
2226
2
}
2227
2228
static void
2229
_nrrd_TMF_dn_c3_4ef_N_f(float *f, const float *x, size_t len, const double *parm) {
2230
  float t;
2231
  size_t I;
2232
  int i;
2233
2234
  AIR_UNUSED(parm); /* TMF_dn_c3_4ef */
2235
480006
  for (I=0; I<len; I++) {
2236
240000
    t = x[I] + 3;
2237
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
2238
240000
    t -= AIR_CAST(float, i);
2239



1320000
    f[I] = AIR_CAST(float, TMF_dn_c3_4ef(parm[0], i, t));
2240
  }
2241
2
}
2242
2243
static NrrdKernel
2244
_nrrdKernel_TMF_dn_c3_4ef = {
2245
  "TMF_dn_c3_4ef",
2246
  1, _nrrd_TMF_dn_c3_4ef_Sup, _nrrd_TMF_dn_c3_4ef_Int,
2247
  _nrrd_TMF_dn_c3_4ef_1_f,  _nrrd_TMF_dn_c3_4ef_N_f,
2248
  _nrrd_TMF_dn_c3_4ef_1_d,  _nrrd_TMF_dn_c3_4ef_N_d
2249
};
2250
2251
2252
/* ------------------------ TMF_d0_cn_1ef --------------------- */
2253
2254
static double _nrrd_TMF_d0_cn_1ef_Int(const double *parm) {
2255
  AIR_UNUSED(parm);
2256
4
  return 1.0;
2257
}
2258
2259
static double _nrrd_TMF_d0_cn_1ef_Sup(const double *parm) {
2260
  AIR_UNUSED(parm);
2261
4
  return 1;
2262
}
2263
2264
static double
2265
_nrrd_TMF_d0_cn_1ef_1_d(double x, const double *parm) {
2266
  int i;
2267
2268
  AIR_UNUSED(parm); /* TMF_d0_cn_1ef */
2269
480024
  x += 1;
2270
240012
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
2271
240012
  x -= i;
2272
720036
  return TMF_d0_cn_1ef(parm[0], i, x);
2273
}
2274
2275
static float
2276
_nrrd_TMF_d0_cn_1ef_1_f(float x, const double *parm) {
2277
  int i;
2278
2279
  AIR_UNUSED(parm); /* TMF_d0_cn_1ef */
2280
480000
  x += 1;
2281
240000
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
2282
240000
  x -= AIR_CAST(float, i);
2283
720000
  return AIR_CAST(float, TMF_d0_cn_1ef(parm[0], i, x));
2284
}
2285
2286
static void
2287
_nrrd_TMF_d0_cn_1ef_N_d(double *f, const double *x, size_t len, const double *parm) {
2288
  double t;
2289
  size_t I;
2290
  int i;
2291
2292
  AIR_UNUSED(parm); /* TMF_d0_cn_1ef */
2293
480006
  for (I=0; I<len; I++) {
2294
240000
    t = x[I] + 1;
2295
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
2296
240000
    t -= i;
2297
720000
    f[I] = TMF_d0_cn_1ef(parm[0], i, t);
2298
  }
2299
2
}
2300
2301
static void
2302
_nrrd_TMF_d0_cn_1ef_N_f(float *f, const float *x, size_t len, const double *parm) {
2303
  float t;
2304
  size_t I;
2305
  int i;
2306
2307
  AIR_UNUSED(parm); /* TMF_d0_cn_1ef */
2308
480006
  for (I=0; I<len; I++) {
2309
240000
    t = x[I] + 1;
2310
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
2311
240000
    t -= AIR_CAST(float, i);
2312
720000
    f[I] = AIR_CAST(float, TMF_d0_cn_1ef(parm[0], i, t));
2313
  }
2314
2
}
2315
2316
static NrrdKernel
2317
_nrrdKernel_TMF_d0_cn_1ef = {
2318
  "TMF_d0_cn_1ef",
2319
  1, _nrrd_TMF_d0_cn_1ef_Sup, _nrrd_TMF_d0_cn_1ef_Int,
2320
  _nrrd_TMF_d0_cn_1ef_1_f,  _nrrd_TMF_d0_cn_1ef_N_f,
2321
  _nrrd_TMF_d0_cn_1ef_1_d,  _nrrd_TMF_d0_cn_1ef_N_d
2322
};
2323
2324
2325
/* ------------------------ TMF_d0_cn_2ef --------------------- */
2326
2327
static double _nrrd_TMF_d0_cn_2ef_Int(const double *parm) {
2328
  AIR_UNUSED(parm);
2329
4
  return 1.0;
2330
}
2331
2332
static double _nrrd_TMF_d0_cn_2ef_Sup(const double *parm) {
2333
  AIR_UNUSED(parm);
2334
4
  return 1;
2335
}
2336
2337
static double
2338
_nrrd_TMF_d0_cn_2ef_1_d(double x, const double *parm) {
2339
  int i;
2340
2341
  AIR_UNUSED(parm); /* TMF_d0_cn_2ef */
2342
480024
  x += 1;
2343
240012
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
2344
240012
  x -= i;
2345
720036
  return TMF_d0_cn_2ef(parm[0], i, x);
2346
}
2347
2348
static float
2349
_nrrd_TMF_d0_cn_2ef_1_f(float x, const double *parm) {
2350
  int i;
2351
2352
  AIR_UNUSED(parm); /* TMF_d0_cn_2ef */
2353
480000
  x += 1;
2354
240000
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
2355
240000
  x -= AIR_CAST(float, i);
2356
720000
  return AIR_CAST(float, TMF_d0_cn_2ef(parm[0], i, x));
2357
}
2358
2359
static void
2360
_nrrd_TMF_d0_cn_2ef_N_d(double *f, const double *x, size_t len, const double *parm) {
2361
  double t;
2362
  size_t I;
2363
  int i;
2364
2365
  AIR_UNUSED(parm); /* TMF_d0_cn_2ef */
2366
480006
  for (I=0; I<len; I++) {
2367
240000
    t = x[I] + 1;
2368
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
2369
240000
    t -= i;
2370
720000
    f[I] = TMF_d0_cn_2ef(parm[0], i, t);
2371
  }
2372
2
}
2373
2374
static void
2375
_nrrd_TMF_d0_cn_2ef_N_f(float *f, const float *x, size_t len, const double *parm) {
2376
  float t;
2377
  size_t I;
2378
  int i;
2379
2380
  AIR_UNUSED(parm); /* TMF_d0_cn_2ef */
2381
480006
  for (I=0; I<len; I++) {
2382
240000
    t = x[I] + 1;
2383
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
2384
240000
    t -= AIR_CAST(float, i);
2385
720000
    f[I] = AIR_CAST(float, TMF_d0_cn_2ef(parm[0], i, t));
2386
  }
2387
2
}
2388
2389
static NrrdKernel
2390
_nrrdKernel_TMF_d0_cn_2ef = {
2391
  "TMF_d0_cn_2ef",
2392
  1, _nrrd_TMF_d0_cn_2ef_Sup, _nrrd_TMF_d0_cn_2ef_Int,
2393
  _nrrd_TMF_d0_cn_2ef_1_f,  _nrrd_TMF_d0_cn_2ef_N_f,
2394
  _nrrd_TMF_d0_cn_2ef_1_d,  _nrrd_TMF_d0_cn_2ef_N_d
2395
};
2396
2397
2398
/* ------------------------ TMF_d0_cn_3ef --------------------- */
2399
2400
static double _nrrd_TMF_d0_cn_3ef_Int(const double *parm) {
2401
  AIR_UNUSED(parm);
2402
4
  return 1.0;
2403
}
2404
2405
static double _nrrd_TMF_d0_cn_3ef_Sup(const double *parm) {
2406
  AIR_UNUSED(parm);
2407
4
  return 2;
2408
}
2409
2410
static double
2411
_nrrd_TMF_d0_cn_3ef_1_d(double x, const double *parm) {
2412
  int i;
2413
2414
  AIR_UNUSED(parm); /* TMF_d0_cn_3ef */
2415
480024
  x += 2;
2416
240012
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
2417
240012
  x -= i;
2418


1080060
  return TMF_d0_cn_3ef(parm[0], i, x);
2419
}
2420
2421
static float
2422
_nrrd_TMF_d0_cn_3ef_1_f(float x, const double *parm) {
2423
  int i;
2424
2425
  AIR_UNUSED(parm); /* TMF_d0_cn_3ef */
2426
480000
  x += 2;
2427
240000
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
2428
240000
  x -= AIR_CAST(float, i);
2429


1080000
  return AIR_CAST(float, TMF_d0_cn_3ef(parm[0], i, x));
2430
}
2431
2432
static void
2433
_nrrd_TMF_d0_cn_3ef_N_d(double *f, const double *x, size_t len, const double *parm) {
2434
  double t;
2435
  size_t I;
2436
  int i;
2437
2438
  AIR_UNUSED(parm); /* TMF_d0_cn_3ef */
2439
480006
  for (I=0; I<len; I++) {
2440
240000
    t = x[I] + 2;
2441
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
2442
240000
    t -= i;
2443


1080000
    f[I] = TMF_d0_cn_3ef(parm[0], i, t);
2444
  }
2445
2
}
2446
2447
static void
2448
_nrrd_TMF_d0_cn_3ef_N_f(float *f, const float *x, size_t len, const double *parm) {
2449
  float t;
2450
  size_t I;
2451
  int i;
2452
2453
  AIR_UNUSED(parm); /* TMF_d0_cn_3ef */
2454
480006
  for (I=0; I<len; I++) {
2455
240000
    t = x[I] + 2;
2456
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
2457
240000
    t -= AIR_CAST(float, i);
2458


1080000
    f[I] = AIR_CAST(float, TMF_d0_cn_3ef(parm[0], i, t));
2459
  }
2460
2
}
2461
2462
static NrrdKernel
2463
_nrrdKernel_TMF_d0_cn_3ef = {
2464
  "TMF_d0_cn_3ef",
2465
  1, _nrrd_TMF_d0_cn_3ef_Sup, _nrrd_TMF_d0_cn_3ef_Int,
2466
  _nrrd_TMF_d0_cn_3ef_1_f,  _nrrd_TMF_d0_cn_3ef_N_f,
2467
  _nrrd_TMF_d0_cn_3ef_1_d,  _nrrd_TMF_d0_cn_3ef_N_d
2468
};
2469
2470
2471
/* ------------------------ TMF_d0_cn_4ef --------------------- */
2472
2473
static double _nrrd_TMF_d0_cn_4ef_Int(const double *parm) {
2474
  AIR_UNUSED(parm);
2475
4
  return 1.0;
2476
}
2477
2478
static double _nrrd_TMF_d0_cn_4ef_Sup(const double *parm) {
2479
  AIR_UNUSED(parm);
2480
4
  return 2;
2481
}
2482
2483
static double
2484
_nrrd_TMF_d0_cn_4ef_1_d(double x, const double *parm) {
2485
  int i;
2486
2487
  AIR_UNUSED(parm); /* TMF_d0_cn_4ef */
2488
480024
  x += 2;
2489
240012
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
2490
240012
  x -= i;
2491


1080060
  return TMF_d0_cn_4ef(parm[0], i, x);
2492
}
2493
2494
static float
2495
_nrrd_TMF_d0_cn_4ef_1_f(float x, const double *parm) {
2496
  int i;
2497
2498
  AIR_UNUSED(parm); /* TMF_d0_cn_4ef */
2499
480000
  x += 2;
2500
240000
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
2501
240000
  x -= AIR_CAST(float, i);
2502


1080000
  return AIR_CAST(float, TMF_d0_cn_4ef(parm[0], i, x));
2503
}
2504
2505
static void
2506
_nrrd_TMF_d0_cn_4ef_N_d(double *f, const double *x, size_t len, const double *parm) {
2507
  double t;
2508
  size_t I;
2509
  int i;
2510
2511
  AIR_UNUSED(parm); /* TMF_d0_cn_4ef */
2512
480006
  for (I=0; I<len; I++) {
2513
240000
    t = x[I] + 2;
2514
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
2515
240000
    t -= i;
2516


1080000
    f[I] = TMF_d0_cn_4ef(parm[0], i, t);
2517
  }
2518
2
}
2519
2520
static void
2521
_nrrd_TMF_d0_cn_4ef_N_f(float *f, const float *x, size_t len, const double *parm) {
2522
  float t;
2523
  size_t I;
2524
  int i;
2525
2526
  AIR_UNUSED(parm); /* TMF_d0_cn_4ef */
2527
480006
  for (I=0; I<len; I++) {
2528
240000
    t = x[I] + 2;
2529
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
2530
240000
    t -= AIR_CAST(float, i);
2531


1080000
    f[I] = AIR_CAST(float, TMF_d0_cn_4ef(parm[0], i, t));
2532
  }
2533
2
}
2534
2535
static NrrdKernel
2536
_nrrdKernel_TMF_d0_cn_4ef = {
2537
  "TMF_d0_cn_4ef",
2538
  1, _nrrd_TMF_d0_cn_4ef_Sup, _nrrd_TMF_d0_cn_4ef_Int,
2539
  _nrrd_TMF_d0_cn_4ef_1_f,  _nrrd_TMF_d0_cn_4ef_N_f,
2540
  _nrrd_TMF_d0_cn_4ef_1_d,  _nrrd_TMF_d0_cn_4ef_N_d
2541
};
2542
2543
2544
/* ------------------------ TMF_d0_c0_1ef --------------------- */
2545
2546
static double _nrrd_TMF_d0_c0_1ef_Int(const double *parm) {
2547
  AIR_UNUSED(parm);
2548
4
  return 1.0;
2549
}
2550
2551
static double _nrrd_TMF_d0_c0_1ef_Sup(const double *parm) {
2552
  AIR_UNUSED(parm);
2553
4
  return 1;
2554
}
2555
2556
static double
2557
_nrrd_TMF_d0_c0_1ef_1_d(double x, const double *parm) {
2558
  int i;
2559
2560
  AIR_UNUSED(parm); /* TMF_d0_c0_1ef */
2561
480024
  x += 1;
2562
240012
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
2563
240012
  x -= i;
2564
720036
  return TMF_d0_c0_1ef(parm[0], i, x);
2565
}
2566
2567
static float
2568
_nrrd_TMF_d0_c0_1ef_1_f(float x, const double *parm) {
2569
  int i;
2570
2571
  AIR_UNUSED(parm); /* TMF_d0_c0_1ef */
2572
480000
  x += 1;
2573
240000
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
2574
240000
  x -= AIR_CAST(float, i);
2575
720000
  return AIR_CAST(float, TMF_d0_c0_1ef(parm[0], i, x));
2576
}
2577
2578
static void
2579
_nrrd_TMF_d0_c0_1ef_N_d(double *f, const double *x, size_t len, const double *parm) {
2580
  double t;
2581
  size_t I;
2582
  int i;
2583
2584
  AIR_UNUSED(parm); /* TMF_d0_c0_1ef */
2585
480006
  for (I=0; I<len; I++) {
2586
240000
    t = x[I] + 1;
2587
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
2588
240000
    t -= i;
2589
720000
    f[I] = TMF_d0_c0_1ef(parm[0], i, t);
2590
  }
2591
2
}
2592
2593
static void
2594
_nrrd_TMF_d0_c0_1ef_N_f(float *f, const float *x, size_t len, const double *parm) {
2595
  float t;
2596
  size_t I;
2597
  int i;
2598
2599
  AIR_UNUSED(parm); /* TMF_d0_c0_1ef */
2600
480006
  for (I=0; I<len; I++) {
2601
240000
    t = x[I] + 1;
2602
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
2603
240000
    t -= AIR_CAST(float, i);
2604
720000
    f[I] = AIR_CAST(float, TMF_d0_c0_1ef(parm[0], i, t));
2605
  }
2606
2
}
2607
2608
static NrrdKernel
2609
_nrrdKernel_TMF_d0_c0_1ef = {
2610
  "TMF_d0_c0_1ef",
2611
  1, _nrrd_TMF_d0_c0_1ef_Sup, _nrrd_TMF_d0_c0_1ef_Int,
2612
  _nrrd_TMF_d0_c0_1ef_1_f,  _nrrd_TMF_d0_c0_1ef_N_f,
2613
  _nrrd_TMF_d0_c0_1ef_1_d,  _nrrd_TMF_d0_c0_1ef_N_d
2614
};
2615
2616
2617
/* ------------------------ TMF_d0_c0_2ef --------------------- */
2618
2619
static double _nrrd_TMF_d0_c0_2ef_Int(const double *parm) {
2620
  AIR_UNUSED(parm);
2621
4
  return 1.0;
2622
}
2623
2624
static double _nrrd_TMF_d0_c0_2ef_Sup(const double *parm) {
2625
  AIR_UNUSED(parm);
2626
4
  return 1;
2627
}
2628
2629
static double
2630
_nrrd_TMF_d0_c0_2ef_1_d(double x, const double *parm) {
2631
  int i;
2632
2633
  AIR_UNUSED(parm); /* TMF_d0_c0_2ef */
2634
480024
  x += 1;
2635
240012
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
2636
240012
  x -= i;
2637
720036
  return TMF_d0_c0_2ef(parm[0], i, x);
2638
}
2639
2640
static float
2641
_nrrd_TMF_d0_c0_2ef_1_f(float x, const double *parm) {
2642
  int i;
2643
2644
  AIR_UNUSED(parm); /* TMF_d0_c0_2ef */
2645
480000
  x += 1;
2646
240000
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
2647
240000
  x -= AIR_CAST(float, i);
2648
720000
  return AIR_CAST(float, TMF_d0_c0_2ef(parm[0], i, x));
2649
}
2650
2651
static void
2652
_nrrd_TMF_d0_c0_2ef_N_d(double *f, const double *x, size_t len, const double *parm) {
2653
  double t;
2654
  size_t I;
2655
  int i;
2656
2657
  AIR_UNUSED(parm); /* TMF_d0_c0_2ef */
2658
480006
  for (I=0; I<len; I++) {
2659
240000
    t = x[I] + 1;
2660
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
2661
240000
    t -= i;
2662
720000
    f[I] = TMF_d0_c0_2ef(parm[0], i, t);
2663
  }
2664
2
}
2665
2666
static void
2667
_nrrd_TMF_d0_c0_2ef_N_f(float *f, const float *x, size_t len, const double *parm) {
2668
  float t;
2669
  size_t I;
2670
  int i;
2671
2672
  AIR_UNUSED(parm); /* TMF_d0_c0_2ef */
2673
480006
  for (I=0; I<len; I++) {
2674
240000
    t = x[I] + 1;
2675
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
2676
240000
    t -= AIR_CAST(float, i);
2677
720000
    f[I] = AIR_CAST(float, TMF_d0_c0_2ef(parm[0], i, t));
2678
  }
2679
2
}
2680
2681
static NrrdKernel
2682
_nrrdKernel_TMF_d0_c0_2ef = {
2683
  "TMF_d0_c0_2ef",
2684
  1, _nrrd_TMF_d0_c0_2ef_Sup, _nrrd_TMF_d0_c0_2ef_Int,
2685
  _nrrd_TMF_d0_c0_2ef_1_f,  _nrrd_TMF_d0_c0_2ef_N_f,
2686
  _nrrd_TMF_d0_c0_2ef_1_d,  _nrrd_TMF_d0_c0_2ef_N_d
2687
};
2688
2689
2690
/* ------------------------ TMF_d0_c0_3ef --------------------- */
2691
2692
static double _nrrd_TMF_d0_c0_3ef_Int(const double *parm) {
2693
  AIR_UNUSED(parm);
2694
4
  return 1.0;
2695
}
2696
2697
static double _nrrd_TMF_d0_c0_3ef_Sup(const double *parm) {
2698
  AIR_UNUSED(parm);
2699
4
  return 2;
2700
}
2701
2702
static double
2703
_nrrd_TMF_d0_c0_3ef_1_d(double x, const double *parm) {
2704
  int i;
2705
2706
  AIR_UNUSED(parm); /* TMF_d0_c0_3ef */
2707
480024
  x += 2;
2708
240012
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
2709
240012
  x -= i;
2710


1080060
  return TMF_d0_c0_3ef(parm[0], i, x);
2711
}
2712
2713
static float
2714
_nrrd_TMF_d0_c0_3ef_1_f(float x, const double *parm) {
2715
  int i;
2716
2717
  AIR_UNUSED(parm); /* TMF_d0_c0_3ef */
2718
480000
  x += 2;
2719
240000
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
2720
240000
  x -= AIR_CAST(float, i);
2721


1080000
  return AIR_CAST(float, TMF_d0_c0_3ef(parm[0], i, x));
2722
}
2723
2724
static void
2725
_nrrd_TMF_d0_c0_3ef_N_d(double *f, const double *x, size_t len, const double *parm) {
2726
  double t;
2727
  size_t I;
2728
  int i;
2729
2730
  AIR_UNUSED(parm); /* TMF_d0_c0_3ef */
2731
480006
  for (I=0; I<len; I++) {
2732
240000
    t = x[I] + 2;
2733
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
2734
240000
    t -= i;
2735


1080000
    f[I] = TMF_d0_c0_3ef(parm[0], i, t);
2736
  }
2737
2
}
2738
2739
static void
2740
_nrrd_TMF_d0_c0_3ef_N_f(float *f, const float *x, size_t len, const double *parm) {
2741
  float t;
2742
  size_t I;
2743
  int i;
2744
2745
  AIR_UNUSED(parm); /* TMF_d0_c0_3ef */
2746
480006
  for (I=0; I<len; I++) {
2747
240000
    t = x[I] + 2;
2748
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
2749
240000
    t -= AIR_CAST(float, i);
2750


1080000
    f[I] = AIR_CAST(float, TMF_d0_c0_3ef(parm[0], i, t));
2751
  }
2752
2
}
2753
2754
static NrrdKernel
2755
_nrrdKernel_TMF_d0_c0_3ef = {
2756
  "TMF_d0_c0_3ef",
2757
  1, _nrrd_TMF_d0_c0_3ef_Sup, _nrrd_TMF_d0_c0_3ef_Int,
2758
  _nrrd_TMF_d0_c0_3ef_1_f,  _nrrd_TMF_d0_c0_3ef_N_f,
2759
  _nrrd_TMF_d0_c0_3ef_1_d,  _nrrd_TMF_d0_c0_3ef_N_d
2760
};
2761
2762
2763
/* ------------------------ TMF_d0_c0_4ef --------------------- */
2764
2765
static double _nrrd_TMF_d0_c0_4ef_Int(const double *parm) {
2766
  AIR_UNUSED(parm);
2767
4
  return 1.0;
2768
}
2769
2770
static double _nrrd_TMF_d0_c0_4ef_Sup(const double *parm) {
2771
  AIR_UNUSED(parm);
2772
4
  return 2;
2773
}
2774
2775
static double
2776
_nrrd_TMF_d0_c0_4ef_1_d(double x, const double *parm) {
2777
  int i;
2778
2779
  AIR_UNUSED(parm); /* TMF_d0_c0_4ef */
2780
480024
  x += 2;
2781
240012
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
2782
240012
  x -= i;
2783


1080060
  return TMF_d0_c0_4ef(parm[0], i, x);
2784
}
2785
2786
static float
2787
_nrrd_TMF_d0_c0_4ef_1_f(float x, const double *parm) {
2788
  int i;
2789
2790
  AIR_UNUSED(parm); /* TMF_d0_c0_4ef */
2791
480000
  x += 2;
2792
240000
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
2793
240000
  x -= AIR_CAST(float, i);
2794


1080000
  return AIR_CAST(float, TMF_d0_c0_4ef(parm[0], i, x));
2795
}
2796
2797
static void
2798
_nrrd_TMF_d0_c0_4ef_N_d(double *f, const double *x, size_t len, const double *parm) {
2799
  double t;
2800
  size_t I;
2801
  int i;
2802
2803
  AIR_UNUSED(parm); /* TMF_d0_c0_4ef */
2804
480006
  for (I=0; I<len; I++) {
2805
240000
    t = x[I] + 2;
2806
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
2807
240000
    t -= i;
2808


1080000
    f[I] = TMF_d0_c0_4ef(parm[0], i, t);
2809
  }
2810
2
}
2811
2812
static void
2813
_nrrd_TMF_d0_c0_4ef_N_f(float *f, const float *x, size_t len, const double *parm) {
2814
  float t;
2815
  size_t I;
2816
  int i;
2817
2818
  AIR_UNUSED(parm); /* TMF_d0_c0_4ef */
2819
480006
  for (I=0; I<len; I++) {
2820
240000
    t = x[I] + 2;
2821
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
2822
240000
    t -= AIR_CAST(float, i);
2823


1080000
    f[I] = AIR_CAST(float, TMF_d0_c0_4ef(parm[0], i, t));
2824
  }
2825
2
}
2826
2827
static NrrdKernel
2828
_nrrdKernel_TMF_d0_c0_4ef = {
2829
  "TMF_d0_c0_4ef",
2830
  1, _nrrd_TMF_d0_c0_4ef_Sup, _nrrd_TMF_d0_c0_4ef_Int,
2831
  _nrrd_TMF_d0_c0_4ef_1_f,  _nrrd_TMF_d0_c0_4ef_N_f,
2832
  _nrrd_TMF_d0_c0_4ef_1_d,  _nrrd_TMF_d0_c0_4ef_N_d
2833
};
2834
2835
2836
/* ------------------------ TMF_d0_c1_1ef --------------------- */
2837
2838
static double _nrrd_TMF_d0_c1_1ef_Int(const double *parm) {
2839
  AIR_UNUSED(parm);
2840
4
  return 1.0;
2841
}
2842
2843
static double _nrrd_TMF_d0_c1_1ef_Sup(const double *parm) {
2844
  AIR_UNUSED(parm);
2845
4
  return 1;
2846
}
2847
2848
static double
2849
_nrrd_TMF_d0_c1_1ef_1_d(double x, const double *parm) {
2850
  int i;
2851
2852
  AIR_UNUSED(parm); /* TMF_d0_c1_1ef */
2853
480024
  x += 1;
2854
240012
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
2855
240012
  x -= i;
2856

840036
  return TMF_d0_c1_1ef(parm[0], i, x);
2857
}
2858
2859
static float
2860
_nrrd_TMF_d0_c1_1ef_1_f(float x, const double *parm) {
2861
  int i;
2862
2863
  AIR_UNUSED(parm); /* TMF_d0_c1_1ef */
2864
480000
  x += 1;
2865
240000
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
2866
240000
  x -= AIR_CAST(float, i);
2867

840000
  return AIR_CAST(float, TMF_d0_c1_1ef(parm[0], i, x));
2868
}
2869
2870
static void
2871
_nrrd_TMF_d0_c1_1ef_N_d(double *f, const double *x, size_t len, const double *parm) {
2872
  double t;
2873
  size_t I;
2874
  int i;
2875
2876
  AIR_UNUSED(parm); /* TMF_d0_c1_1ef */
2877
480006
  for (I=0; I<len; I++) {
2878
240000
    t = x[I] + 1;
2879
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
2880
240000
    t -= i;
2881

840000
    f[I] = TMF_d0_c1_1ef(parm[0], i, t);
2882
  }
2883
2
}
2884
2885
static void
2886
_nrrd_TMF_d0_c1_1ef_N_f(float *f, const float *x, size_t len, const double *parm) {
2887
  float t;
2888
  size_t I;
2889
  int i;
2890
2891
  AIR_UNUSED(parm); /* TMF_d0_c1_1ef */
2892
480006
  for (I=0; I<len; I++) {
2893
240000
    t = x[I] + 1;
2894
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
2895
240000
    t -= AIR_CAST(float, i);
2896

840000
    f[I] = AIR_CAST(float, TMF_d0_c1_1ef(parm[0], i, t));
2897
  }
2898
2
}
2899
2900
static NrrdKernel
2901
_nrrdKernel_TMF_d0_c1_1ef = {
2902
  "TMF_d0_c1_1ef",
2903
  1, _nrrd_TMF_d0_c1_1ef_Sup, _nrrd_TMF_d0_c1_1ef_Int,
2904
  _nrrd_TMF_d0_c1_1ef_1_f,  _nrrd_TMF_d0_c1_1ef_N_f,
2905
  _nrrd_TMF_d0_c1_1ef_1_d,  _nrrd_TMF_d0_c1_1ef_N_d
2906
};
2907
2908
2909
/* ------------------------ TMF_d0_c1_2ef --------------------- */
2910
2911
static double _nrrd_TMF_d0_c1_2ef_Int(const double *parm) {
2912
  AIR_UNUSED(parm);
2913
4
  return 1.0;
2914
}
2915
2916
static double _nrrd_TMF_d0_c1_2ef_Sup(const double *parm) {
2917
  AIR_UNUSED(parm);
2918
4
  return 2;
2919
}
2920
2921
static double
2922
_nrrd_TMF_d0_c1_2ef_1_d(double x, const double *parm) {
2923
  int i;
2924
2925
  AIR_UNUSED(parm); /* TMF_d0_c1_2ef */
2926
480024
  x += 2;
2927
240012
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
2928
240012
  x -= i;
2929


1080060
  return TMF_d0_c1_2ef(parm[0], i, x);
2930
}
2931
2932
static float
2933
_nrrd_TMF_d0_c1_2ef_1_f(float x, const double *parm) {
2934
  int i;
2935
2936
  AIR_UNUSED(parm); /* TMF_d0_c1_2ef */
2937
480000
  x += 2;
2938
240000
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
2939
240000
  x -= AIR_CAST(float, i);
2940


1080000
  return AIR_CAST(float, TMF_d0_c1_2ef(parm[0], i, x));
2941
}
2942
2943
static void
2944
_nrrd_TMF_d0_c1_2ef_N_d(double *f, const double *x, size_t len, const double *parm) {
2945
  double t;
2946
  size_t I;
2947
  int i;
2948
2949
  AIR_UNUSED(parm); /* TMF_d0_c1_2ef */
2950
480006
  for (I=0; I<len; I++) {
2951
240000
    t = x[I] + 2;
2952
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
2953
240000
    t -= i;
2954


1080000
    f[I] = TMF_d0_c1_2ef(parm[0], i, t);
2955
  }
2956
2
}
2957
2958
static void
2959
_nrrd_TMF_d0_c1_2ef_N_f(float *f, const float *x, size_t len, const double *parm) {
2960
  float t;
2961
  size_t I;
2962
  int i;
2963
2964
  AIR_UNUSED(parm); /* TMF_d0_c1_2ef */
2965
480006
  for (I=0; I<len; I++) {
2966
240000
    t = x[I] + 2;
2967
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
2968
240000
    t -= AIR_CAST(float, i);
2969


1080000
    f[I] = AIR_CAST(float, TMF_d0_c1_2ef(parm[0], i, t));
2970
  }
2971
2
}
2972
2973
static NrrdKernel
2974
_nrrdKernel_TMF_d0_c1_2ef = {
2975
  "TMF_d0_c1_2ef",
2976
  1, _nrrd_TMF_d0_c1_2ef_Sup, _nrrd_TMF_d0_c1_2ef_Int,
2977
  _nrrd_TMF_d0_c1_2ef_1_f,  _nrrd_TMF_d0_c1_2ef_N_f,
2978
  _nrrd_TMF_d0_c1_2ef_1_d,  _nrrd_TMF_d0_c1_2ef_N_d
2979
};
2980
2981
2982
/* ------------------------ TMF_d0_c1_3ef --------------------- */
2983
2984
static double _nrrd_TMF_d0_c1_3ef_Int(const double *parm) {
2985
  AIR_UNUSED(parm);
2986
4
  return 1.0;
2987
}
2988
2989
static double _nrrd_TMF_d0_c1_3ef_Sup(const double *parm) {
2990
  AIR_UNUSED(parm);
2991
4
  return 2;
2992
}
2993
2994
static double
2995
_nrrd_TMF_d0_c1_3ef_1_d(double x, const double *parm) {
2996
  int i;
2997
2998
  AIR_UNUSED(parm); /* TMF_d0_c1_3ef */
2999
480024
  x += 2;
3000
240012
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
3001
240012
  x -= i;
3002


1080060
  return TMF_d0_c1_3ef(parm[0], i, x);
3003
}
3004
3005
static float
3006
_nrrd_TMF_d0_c1_3ef_1_f(float x, const double *parm) {
3007
  int i;
3008
3009
  AIR_UNUSED(parm); /* TMF_d0_c1_3ef */
3010
480000
  x += 2;
3011
240000
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
3012
240000
  x -= AIR_CAST(float, i);
3013


1080000
  return AIR_CAST(float, TMF_d0_c1_3ef(parm[0], i, x));
3014
}
3015
3016
static void
3017
_nrrd_TMF_d0_c1_3ef_N_d(double *f, const double *x, size_t len, const double *parm) {
3018
  double t;
3019
  size_t I;
3020
  int i;
3021
3022
  AIR_UNUSED(parm); /* TMF_d0_c1_3ef */
3023
480006
  for (I=0; I<len; I++) {
3024
240000
    t = x[I] + 2;
3025
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
3026
240000
    t -= i;
3027


1080000
    f[I] = TMF_d0_c1_3ef(parm[0], i, t);
3028
  }
3029
2
}
3030
3031
static void
3032
_nrrd_TMF_d0_c1_3ef_N_f(float *f, const float *x, size_t len, const double *parm) {
3033
  float t;
3034
  size_t I;
3035
  int i;
3036
3037
  AIR_UNUSED(parm); /* TMF_d0_c1_3ef */
3038
480006
  for (I=0; I<len; I++) {
3039
240000
    t = x[I] + 2;
3040
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
3041
240000
    t -= AIR_CAST(float, i);
3042


1080000
    f[I] = AIR_CAST(float, TMF_d0_c1_3ef(parm[0], i, t));
3043
  }
3044
2
}
3045
3046
static NrrdKernel
3047
_nrrdKernel_TMF_d0_c1_3ef = {
3048
  "TMF_d0_c1_3ef",
3049
  1, _nrrd_TMF_d0_c1_3ef_Sup, _nrrd_TMF_d0_c1_3ef_Int,
3050
  _nrrd_TMF_d0_c1_3ef_1_f,  _nrrd_TMF_d0_c1_3ef_N_f,
3051
  _nrrd_TMF_d0_c1_3ef_1_d,  _nrrd_TMF_d0_c1_3ef_N_d
3052
};
3053
3054
3055
/* ------------------------ TMF_d0_c1_4ef --------------------- */
3056
3057
static double _nrrd_TMF_d0_c1_4ef_Int(const double *parm) {
3058
  AIR_UNUSED(parm);
3059
4
  return 1.0;
3060
}
3061
3062
static double _nrrd_TMF_d0_c1_4ef_Sup(const double *parm) {
3063
  AIR_UNUSED(parm);
3064
4
  return 3;
3065
}
3066
3067
static double
3068
_nrrd_TMF_d0_c1_4ef_1_d(double x, const double *parm) {
3069
  int i;
3070
3071
  AIR_UNUSED(parm); /* TMF_d0_c1_4ef */
3072
480024
  x += 3;
3073
240012
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
3074
240012
  x -= i;
3075



1320084
  return TMF_d0_c1_4ef(parm[0], i, x);
3076
}
3077
3078
static float
3079
_nrrd_TMF_d0_c1_4ef_1_f(float x, const double *parm) {
3080
  int i;
3081
3082
  AIR_UNUSED(parm); /* TMF_d0_c1_4ef */
3083
480000
  x += 3;
3084
240000
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
3085
240000
  x -= AIR_CAST(float, i);
3086



1320000
  return AIR_CAST(float, TMF_d0_c1_4ef(parm[0], i, x));
3087
}
3088
3089
static void
3090
_nrrd_TMF_d0_c1_4ef_N_d(double *f, const double *x, size_t len, const double *parm) {
3091
  double t;
3092
  size_t I;
3093
  int i;
3094
3095
  AIR_UNUSED(parm); /* TMF_d0_c1_4ef */
3096
480006
  for (I=0; I<len; I++) {
3097
240000
    t = x[I] + 3;
3098
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
3099
240000
    t -= i;
3100



1320000
    f[I] = TMF_d0_c1_4ef(parm[0], i, t);
3101
  }
3102
2
}
3103
3104
static void
3105
_nrrd_TMF_d0_c1_4ef_N_f(float *f, const float *x, size_t len, const double *parm) {
3106
  float t;
3107
  size_t I;
3108
  int i;
3109
3110
  AIR_UNUSED(parm); /* TMF_d0_c1_4ef */
3111
480006
  for (I=0; I<len; I++) {
3112
240000
    t = x[I] + 3;
3113
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
3114
240000
    t -= AIR_CAST(float, i);
3115



1320000
    f[I] = AIR_CAST(float, TMF_d0_c1_4ef(parm[0], i, t));
3116
  }
3117
2
}
3118
3119
static NrrdKernel
3120
_nrrdKernel_TMF_d0_c1_4ef = {
3121
  "TMF_d0_c1_4ef",
3122
  1, _nrrd_TMF_d0_c1_4ef_Sup, _nrrd_TMF_d0_c1_4ef_Int,
3123
  _nrrd_TMF_d0_c1_4ef_1_f,  _nrrd_TMF_d0_c1_4ef_N_f,
3124
  _nrrd_TMF_d0_c1_4ef_1_d,  _nrrd_TMF_d0_c1_4ef_N_d
3125
};
3126
3127
3128
/* ------------------------ TMF_d0_c2_1ef --------------------- */
3129
3130
static double _nrrd_TMF_d0_c2_1ef_Int(const double *parm) {
3131
  AIR_UNUSED(parm);
3132
4
  return 1.0;
3133
}
3134
3135
static double _nrrd_TMF_d0_c2_1ef_Sup(const double *parm) {
3136
  AIR_UNUSED(parm);
3137
4
  return 1;
3138
}
3139
3140
static double
3141
_nrrd_TMF_d0_c2_1ef_1_d(double x, const double *parm) {
3142
  int i;
3143
3144
  AIR_UNUSED(parm); /* TMF_d0_c2_1ef */
3145
480024
  x += 1;
3146
240012
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
3147
240012
  x -= i;
3148

840036
  return TMF_d0_c2_1ef(parm[0], i, x);
3149
}
3150
3151
static float
3152
_nrrd_TMF_d0_c2_1ef_1_f(float x, const double *parm) {
3153
  int i;
3154
3155
  AIR_UNUSED(parm); /* TMF_d0_c2_1ef */
3156
480000
  x += 1;
3157
240000
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
3158
240000
  x -= AIR_CAST(float, i);
3159

840000
  return AIR_CAST(float, TMF_d0_c2_1ef(parm[0], i, x));
3160
}
3161
3162
static void
3163
_nrrd_TMF_d0_c2_1ef_N_d(double *f, const double *x, size_t len, const double *parm) {
3164
  double t;
3165
  size_t I;
3166
  int i;
3167
3168
  AIR_UNUSED(parm); /* TMF_d0_c2_1ef */
3169
480006
  for (I=0; I<len; I++) {
3170
240000
    t = x[I] + 1;
3171
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
3172
240000
    t -= i;
3173

840000
    f[I] = TMF_d0_c2_1ef(parm[0], i, t);
3174
  }
3175
2
}
3176
3177
static void
3178
_nrrd_TMF_d0_c2_1ef_N_f(float *f, const float *x, size_t len, const double *parm) {
3179
  float t;
3180
  size_t I;
3181
  int i;
3182
3183
  AIR_UNUSED(parm); /* TMF_d0_c2_1ef */
3184
480006
  for (I=0; I<len; I++) {
3185
240000
    t = x[I] + 1;
3186
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
3187
240000
    t -= AIR_CAST(float, i);
3188

840000
    f[I] = AIR_CAST(float, TMF_d0_c2_1ef(parm[0], i, t));
3189
  }
3190
2
}
3191
3192
static NrrdKernel
3193
_nrrdKernel_TMF_d0_c2_1ef = {
3194
  "TMF_d0_c2_1ef",
3195
  1, _nrrd_TMF_d0_c2_1ef_Sup, _nrrd_TMF_d0_c2_1ef_Int,
3196
  _nrrd_TMF_d0_c2_1ef_1_f,  _nrrd_TMF_d0_c2_1ef_N_f,
3197
  _nrrd_TMF_d0_c2_1ef_1_d,  _nrrd_TMF_d0_c2_1ef_N_d
3198
};
3199
3200
3201
/* ------------------------ TMF_d0_c2_2ef --------------------- */
3202
3203
static double _nrrd_TMF_d0_c2_2ef_Int(const double *parm) {
3204
  AIR_UNUSED(parm);
3205
4
  return 1.0;
3206
}
3207
3208
static double _nrrd_TMF_d0_c2_2ef_Sup(const double *parm) {
3209
  AIR_UNUSED(parm);
3210
4
  return 2;
3211
}
3212
3213
static double
3214
_nrrd_TMF_d0_c2_2ef_1_d(double x, const double *parm) {
3215
  int i;
3216
3217
  AIR_UNUSED(parm); /* TMF_d0_c2_2ef */
3218
480024
  x += 2;
3219
240012
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
3220
240012
  x -= i;
3221


1080060
  return TMF_d0_c2_2ef(parm[0], i, x);
3222
}
3223
3224
static float
3225
_nrrd_TMF_d0_c2_2ef_1_f(float x, const double *parm) {
3226
  int i;
3227
3228
  AIR_UNUSED(parm); /* TMF_d0_c2_2ef */
3229
480000
  x += 2;
3230
240000
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
3231
240000
  x -= AIR_CAST(float, i);
3232


1080000
  return AIR_CAST(float, TMF_d0_c2_2ef(parm[0], i, x));
3233
}
3234
3235
static void
3236
_nrrd_TMF_d0_c2_2ef_N_d(double *f, const double *x, size_t len, const double *parm) {
3237
  double t;
3238
  size_t I;
3239
  int i;
3240
3241
  AIR_UNUSED(parm); /* TMF_d0_c2_2ef */
3242
480006
  for (I=0; I<len; I++) {
3243
240000
    t = x[I] + 2;
3244
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
3245
240000
    t -= i;
3246


1080000
    f[I] = TMF_d0_c2_2ef(parm[0], i, t);
3247
  }
3248
2
}
3249
3250
static void
3251
_nrrd_TMF_d0_c2_2ef_N_f(float *f, const float *x, size_t len, const double *parm) {
3252
  float t;
3253
  size_t I;
3254
  int i;
3255
3256
  AIR_UNUSED(parm); /* TMF_d0_c2_2ef */
3257
480006
  for (I=0; I<len; I++) {
3258
240000
    t = x[I] + 2;
3259
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
3260
240000
    t -= AIR_CAST(float, i);
3261


1080000
    f[I] = AIR_CAST(float, TMF_d0_c2_2ef(parm[0], i, t));
3262
  }
3263
2
}
3264
3265
static NrrdKernel
3266
_nrrdKernel_TMF_d0_c2_2ef = {
3267
  "TMF_d0_c2_2ef",
3268
  1, _nrrd_TMF_d0_c2_2ef_Sup, _nrrd_TMF_d0_c2_2ef_Int,
3269
  _nrrd_TMF_d0_c2_2ef_1_f,  _nrrd_TMF_d0_c2_2ef_N_f,
3270
  _nrrd_TMF_d0_c2_2ef_1_d,  _nrrd_TMF_d0_c2_2ef_N_d
3271
};
3272
3273
3274
/* ------------------------ TMF_d0_c2_3ef --------------------- */
3275
3276
static double _nrrd_TMF_d0_c2_3ef_Int(const double *parm) {
3277
  AIR_UNUSED(parm);
3278
4
  return 1.0;
3279
}
3280
3281
static double _nrrd_TMF_d0_c2_3ef_Sup(const double *parm) {
3282
  AIR_UNUSED(parm);
3283
4
  return 2;
3284
}
3285
3286
static double
3287
_nrrd_TMF_d0_c2_3ef_1_d(double x, const double *parm) {
3288
  int i;
3289
3290
  AIR_UNUSED(parm); /* TMF_d0_c2_3ef */
3291
480024
  x += 2;
3292
240012
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
3293
240012
  x -= i;
3294


1080060
  return TMF_d0_c2_3ef(parm[0], i, x);
3295
}
3296
3297
static float
3298
_nrrd_TMF_d0_c2_3ef_1_f(float x, const double *parm) {
3299
  int i;
3300
3301
  AIR_UNUSED(parm); /* TMF_d0_c2_3ef */
3302
480000
  x += 2;
3303
240000
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
3304
240000
  x -= AIR_CAST(float, i);
3305


1080000
  return AIR_CAST(float, TMF_d0_c2_3ef(parm[0], i, x));
3306
}
3307
3308
static void
3309
_nrrd_TMF_d0_c2_3ef_N_d(double *f, const double *x, size_t len, const double *parm) {
3310
  double t;
3311
  size_t I;
3312
  int i;
3313
3314
  AIR_UNUSED(parm); /* TMF_d0_c2_3ef */
3315
480006
  for (I=0; I<len; I++) {
3316
240000
    t = x[I] + 2;
3317
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
3318
240000
    t -= i;
3319


1080000
    f[I] = TMF_d0_c2_3ef(parm[0], i, t);
3320
  }
3321
2
}
3322
3323
static void
3324
_nrrd_TMF_d0_c2_3ef_N_f(float *f, const float *x, size_t len, const double *parm) {
3325
  float t;
3326
  size_t I;
3327
  int i;
3328
3329
  AIR_UNUSED(parm); /* TMF_d0_c2_3ef */
3330
480006
  for (I=0; I<len; I++) {
3331
240000
    t = x[I] + 2;
3332
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
3333
240000
    t -= AIR_CAST(float, i);
3334


1080000
    f[I] = AIR_CAST(float, TMF_d0_c2_3ef(parm[0], i, t));
3335
  }
3336
2
}
3337
3338
static NrrdKernel
3339
_nrrdKernel_TMF_d0_c2_3ef = {
3340
  "TMF_d0_c2_3ef",
3341
  1, _nrrd_TMF_d0_c2_3ef_Sup, _nrrd_TMF_d0_c2_3ef_Int,
3342
  _nrrd_TMF_d0_c2_3ef_1_f,  _nrrd_TMF_d0_c2_3ef_N_f,
3343
  _nrrd_TMF_d0_c2_3ef_1_d,  _nrrd_TMF_d0_c2_3ef_N_d
3344
};
3345
3346
3347
/* ------------------------ TMF_d0_c2_4ef --------------------- */
3348
3349
static double _nrrd_TMF_d0_c2_4ef_Int(const double *parm) {
3350
  AIR_UNUSED(parm);
3351
4
  return 1.0;
3352
}
3353
3354
static double _nrrd_TMF_d0_c2_4ef_Sup(const double *parm) {
3355
  AIR_UNUSED(parm);
3356
4
  return 3;
3357
}
3358
3359
static double
3360
_nrrd_TMF_d0_c2_4ef_1_d(double x, const double *parm) {
3361
  int i;
3362
3363
  AIR_UNUSED(parm); /* TMF_d0_c2_4ef */
3364
480024
  x += 3;
3365
240012
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
3366
240012
  x -= i;
3367



1320084
  return TMF_d0_c2_4ef(parm[0], i, x);
3368
}
3369
3370
static float
3371
_nrrd_TMF_d0_c2_4ef_1_f(float x, const double *parm) {
3372
  int i;
3373
3374
  AIR_UNUSED(parm); /* TMF_d0_c2_4ef */
3375
480000
  x += 3;
3376
240000
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
3377
240000
  x -= AIR_CAST(float, i);
3378



1320000
  return AIR_CAST(float, TMF_d0_c2_4ef(parm[0], i, x));
3379
}
3380
3381
static void
3382
_nrrd_TMF_d0_c2_4ef_N_d(double *f, const double *x, size_t len, const double *parm) {
3383
  double t;
3384
  size_t I;
3385
  int i;
3386
3387
  AIR_UNUSED(parm); /* TMF_d0_c2_4ef */
3388
480006
  for (I=0; I<len; I++) {
3389
240000
    t = x[I] + 3;
3390
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
3391
240000
    t -= i;
3392



1320000
    f[I] = TMF_d0_c2_4ef(parm[0], i, t);
3393
  }
3394
2
}
3395
3396
static void
3397
_nrrd_TMF_d0_c2_4ef_N_f(float *f, const float *x, size_t len, const double *parm) {
3398
  float t;
3399
  size_t I;
3400
  int i;
3401
3402
  AIR_UNUSED(parm); /* TMF_d0_c2_4ef */
3403
480006
  for (I=0; I<len; I++) {
3404
240000
    t = x[I] + 3;
3405
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
3406
240000
    t -= AIR_CAST(float, i);
3407



1320000
    f[I] = AIR_CAST(float, TMF_d0_c2_4ef(parm[0], i, t));
3408
  }
3409
2
}
3410
3411
static NrrdKernel
3412
_nrrdKernel_TMF_d0_c2_4ef = {
3413
  "TMF_d0_c2_4ef",
3414
  1, _nrrd_TMF_d0_c2_4ef_Sup, _nrrd_TMF_d0_c2_4ef_Int,
3415
  _nrrd_TMF_d0_c2_4ef_1_f,  _nrrd_TMF_d0_c2_4ef_N_f,
3416
  _nrrd_TMF_d0_c2_4ef_1_d,  _nrrd_TMF_d0_c2_4ef_N_d
3417
};
3418
3419
3420
/* ------------------------ TMF_d0_c3_1ef --------------------- */
3421
3422
static double _nrrd_TMF_d0_c3_1ef_Int(const double *parm) {
3423
  AIR_UNUSED(parm);
3424
4
  return 1.0;
3425
}
3426
3427
static double _nrrd_TMF_d0_c3_1ef_Sup(const double *parm) {
3428
  AIR_UNUSED(parm);
3429
4
  return 1;
3430
}
3431
3432
static double
3433
_nrrd_TMF_d0_c3_1ef_1_d(double x, const double *parm) {
3434
  int i;
3435
3436
  AIR_UNUSED(parm); /* TMF_d0_c3_1ef */
3437
480024
  x += 1;
3438
240012
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
3439
240012
  x -= i;
3440

840036
  return TMF_d0_c3_1ef(parm[0], i, x);
3441
}
3442
3443
static float
3444
_nrrd_TMF_d0_c3_1ef_1_f(float x, const double *parm) {
3445
  int i;
3446
3447
  AIR_UNUSED(parm); /* TMF_d0_c3_1ef */
3448
480000
  x += 1;
3449
240000
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
3450
240000
  x -= AIR_CAST(float, i);
3451

840000
  return AIR_CAST(float, TMF_d0_c3_1ef(parm[0], i, x));
3452
}
3453
3454
static void
3455
_nrrd_TMF_d0_c3_1ef_N_d(double *f, const double *x, size_t len, const double *parm) {
3456
  double t;
3457
  size_t I;
3458
  int i;
3459
3460
  AIR_UNUSED(parm); /* TMF_d0_c3_1ef */
3461
480006
  for (I=0; I<len; I++) {
3462
240000
    t = x[I] + 1;
3463
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
3464
240000
    t -= i;
3465

840000
    f[I] = TMF_d0_c3_1ef(parm[0], i, t);
3466
  }
3467
2
}
3468
3469
static void
3470
_nrrd_TMF_d0_c3_1ef_N_f(float *f, const float *x, size_t len, const double *parm) {
3471
  float t;
3472
  size_t I;
3473
  int i;
3474
3475
  AIR_UNUSED(parm); /* TMF_d0_c3_1ef */
3476
480006
  for (I=0; I<len; I++) {
3477
240000
    t = x[I] + 1;
3478
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
3479
240000
    t -= AIR_CAST(float, i);
3480

840000
    f[I] = AIR_CAST(float, TMF_d0_c3_1ef(parm[0], i, t));
3481
  }
3482
2
}
3483
3484
static NrrdKernel
3485
_nrrdKernel_TMF_d0_c3_1ef = {
3486
  "TMF_d0_c3_1ef",
3487
  1, _nrrd_TMF_d0_c3_1ef_Sup, _nrrd_TMF_d0_c3_1ef_Int,
3488
  _nrrd_TMF_d0_c3_1ef_1_f,  _nrrd_TMF_d0_c3_1ef_N_f,
3489
  _nrrd_TMF_d0_c3_1ef_1_d,  _nrrd_TMF_d0_c3_1ef_N_d
3490
};
3491
3492
3493
/* ------------------------ TMF_d0_c3_2ef --------------------- */
3494
3495
static double _nrrd_TMF_d0_c3_2ef_Int(const double *parm) {
3496
  AIR_UNUSED(parm);
3497
4
  return 1.0;
3498
}
3499
3500
static double _nrrd_TMF_d0_c3_2ef_Sup(const double *parm) {
3501
  AIR_UNUSED(parm);
3502
4
  return 2;
3503
}
3504
3505
static double
3506
_nrrd_TMF_d0_c3_2ef_1_d(double x, const double *parm) {
3507
  int i;
3508
3509
  AIR_UNUSED(parm); /* TMF_d0_c3_2ef */
3510
480024
  x += 2;
3511
240012
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
3512
240012
  x -= i;
3513


1080060
  return TMF_d0_c3_2ef(parm[0], i, x);
3514
}
3515
3516
static float
3517
_nrrd_TMF_d0_c3_2ef_1_f(float x, const double *parm) {
3518
  int i;
3519
3520
  AIR_UNUSED(parm); /* TMF_d0_c3_2ef */
3521
480000
  x += 2;
3522
240000
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
3523
240000
  x -= AIR_CAST(float, i);
3524


1080000
  return AIR_CAST(float, TMF_d0_c3_2ef(parm[0], i, x));
3525
}
3526
3527
static void
3528
_nrrd_TMF_d0_c3_2ef_N_d(double *f, const double *x, size_t len, const double *parm) {
3529
  double t;
3530
  size_t I;
3531
  int i;
3532
3533
  AIR_UNUSED(parm); /* TMF_d0_c3_2ef */
3534
480006
  for (I=0; I<len; I++) {
3535
240000
    t = x[I] + 2;
3536
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
3537
240000
    t -= i;
3538


1080000
    f[I] = TMF_d0_c3_2ef(parm[0], i, t);
3539
  }
3540
2
}
3541
3542
static void
3543
_nrrd_TMF_d0_c3_2ef_N_f(float *f, const float *x, size_t len, const double *parm) {
3544
  float t;
3545
  size_t I;
3546
  int i;
3547
3548
  AIR_UNUSED(parm); /* TMF_d0_c3_2ef */
3549
480006
  for (I=0; I<len; I++) {
3550
240000
    t = x[I] + 2;
3551
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
3552
240000
    t -= AIR_CAST(float, i);
3553


1080000
    f[I] = AIR_CAST(float, TMF_d0_c3_2ef(parm[0], i, t));
3554
  }
3555
2
}
3556
3557
static NrrdKernel
3558
_nrrdKernel_TMF_d0_c3_2ef = {
3559
  "TMF_d0_c3_2ef",
3560
  1, _nrrd_TMF_d0_c3_2ef_Sup, _nrrd_TMF_d0_c3_2ef_Int,
3561
  _nrrd_TMF_d0_c3_2ef_1_f,  _nrrd_TMF_d0_c3_2ef_N_f,
3562
  _nrrd_TMF_d0_c3_2ef_1_d,  _nrrd_TMF_d0_c3_2ef_N_d
3563
};
3564
3565
3566
/* ------------------------ TMF_d0_c3_3ef --------------------- */
3567
3568
static double _nrrd_TMF_d0_c3_3ef_Int(const double *parm) {
3569
  AIR_UNUSED(parm);
3570
4
  return 1.0;
3571
}
3572
3573
static double _nrrd_TMF_d0_c3_3ef_Sup(const double *parm) {
3574
  AIR_UNUSED(parm);
3575
4
  return 2;
3576
}
3577
3578
static double
3579
_nrrd_TMF_d0_c3_3ef_1_d(double x, const double *parm) {
3580
  int i;
3581
3582
  AIR_UNUSED(parm); /* TMF_d0_c3_3ef */
3583
480024
  x += 2;
3584
240012
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
3585
240012
  x -= i;
3586


1080060
  return TMF_d0_c3_3ef(parm[0], i, x);
3587
}
3588
3589
static float
3590
_nrrd_TMF_d0_c3_3ef_1_f(float x, const double *parm) {
3591
  int i;
3592
3593
  AIR_UNUSED(parm); /* TMF_d0_c3_3ef */
3594
480000
  x += 2;
3595
240000
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
3596
240000
  x -= AIR_CAST(float, i);
3597


1080000
  return AIR_CAST(float, TMF_d0_c3_3ef(parm[0], i, x));
3598
}
3599
3600
static void
3601
_nrrd_TMF_d0_c3_3ef_N_d(double *f, const double *x, size_t len, const double *parm) {
3602
  double t;
3603
  size_t I;
3604
  int i;
3605
3606
  AIR_UNUSED(parm); /* TMF_d0_c3_3ef */
3607
480006
  for (I=0; I<len; I++) {
3608
240000
    t = x[I] + 2;
3609
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
3610
240000
    t -= i;
3611


1080000
    f[I] = TMF_d0_c3_3ef(parm[0], i, t);
3612
  }
3613
2
}
3614
3615
static void
3616
_nrrd_TMF_d0_c3_3ef_N_f(float *f, const float *x, size_t len, const double *parm) {
3617
  float t;
3618
  size_t I;
3619
  int i;
3620
3621
  AIR_UNUSED(parm); /* TMF_d0_c3_3ef */
3622
480006
  for (I=0; I<len; I++) {
3623
240000
    t = x[I] + 2;
3624
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
3625
240000
    t -= AIR_CAST(float, i);
3626


1080000
    f[I] = AIR_CAST(float, TMF_d0_c3_3ef(parm[0], i, t));
3627
  }
3628
2
}
3629
3630
static NrrdKernel
3631
_nrrdKernel_TMF_d0_c3_3ef = {
3632
  "TMF_d0_c3_3ef",
3633
  1, _nrrd_TMF_d0_c3_3ef_Sup, _nrrd_TMF_d0_c3_3ef_Int,
3634
  _nrrd_TMF_d0_c3_3ef_1_f,  _nrrd_TMF_d0_c3_3ef_N_f,
3635
  _nrrd_TMF_d0_c3_3ef_1_d,  _nrrd_TMF_d0_c3_3ef_N_d
3636
};
3637
3638
3639
/* ------------------------ TMF_d0_c3_4ef --------------------- */
3640
3641
static double _nrrd_TMF_d0_c3_4ef_Int(const double *parm) {
3642
  AIR_UNUSED(parm);
3643
4
  return 1.0;
3644
}
3645
3646
static double _nrrd_TMF_d0_c3_4ef_Sup(const double *parm) {
3647
  AIR_UNUSED(parm);
3648
4
  return 3;
3649
}
3650
3651
static double
3652
_nrrd_TMF_d0_c3_4ef_1_d(double x, const double *parm) {
3653
  int i;
3654
3655
  AIR_UNUSED(parm); /* TMF_d0_c3_4ef */
3656
480024
  x += 3;
3657
240012
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
3658
240012
  x -= i;
3659



1320084
  return TMF_d0_c3_4ef(parm[0], i, x);
3660
}
3661
3662
static float
3663
_nrrd_TMF_d0_c3_4ef_1_f(float x, const double *parm) {
3664
  int i;
3665
3666
  AIR_UNUSED(parm); /* TMF_d0_c3_4ef */
3667
480000
  x += 3;
3668
240000
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
3669
240000
  x -= AIR_CAST(float, i);
3670



1320000
  return AIR_CAST(float, TMF_d0_c3_4ef(parm[0], i, x));
3671
}
3672
3673
static void
3674
_nrrd_TMF_d0_c3_4ef_N_d(double *f, const double *x, size_t len, const double *parm) {
3675
  double t;
3676
  size_t I;
3677
  int i;
3678
3679
  AIR_UNUSED(parm); /* TMF_d0_c3_4ef */
3680
480006
  for (I=0; I<len; I++) {
3681
240000
    t = x[I] + 3;
3682
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
3683
240000
    t -= i;
3684



1320000
    f[I] = TMF_d0_c3_4ef(parm[0], i, t);
3685
  }
3686
2
}
3687
3688
static void
3689
_nrrd_TMF_d0_c3_4ef_N_f(float *f, const float *x, size_t len, const double *parm) {
3690
  float t;
3691
  size_t I;
3692
  int i;
3693
3694
  AIR_UNUSED(parm); /* TMF_d0_c3_4ef */
3695
480006
  for (I=0; I<len; I++) {
3696
240000
    t = x[I] + 3;
3697
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
3698
240000
    t -= AIR_CAST(float, i);
3699



1320000
    f[I] = AIR_CAST(float, TMF_d0_c3_4ef(parm[0], i, t));
3700
  }
3701
2
}
3702
3703
static NrrdKernel
3704
_nrrdKernel_TMF_d0_c3_4ef = {
3705
  "TMF_d0_c3_4ef",
3706
  1, _nrrd_TMF_d0_c3_4ef_Sup, _nrrd_TMF_d0_c3_4ef_Int,
3707
  _nrrd_TMF_d0_c3_4ef_1_f,  _nrrd_TMF_d0_c3_4ef_N_f,
3708
  _nrrd_TMF_d0_c3_4ef_1_d,  _nrrd_TMF_d0_c3_4ef_N_d
3709
};
3710
3711
3712
/* ------------------------ TMF_d1_cn_1ef --------------------- */
3713
3714
static double _nrrd_TMF_d1_cn_1ef_Int(const double *parm) {
3715
  AIR_UNUSED(parm);
3716
4
  return 0.0;
3717
}
3718
3719
static double _nrrd_TMF_d1_cn_1ef_Sup(const double *parm) {
3720
  AIR_UNUSED(parm);
3721
4
  return 1;
3722
}
3723
3724
static double
3725
_nrrd_TMF_d1_cn_1ef_1_d(double x, const double *parm) {
3726
  int i;
3727
3728
  AIR_UNUSED(parm); /* TMF_d1_cn_1ef */
3729
480024
  x += 1;
3730
240012
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
3731
240012
  x -= i;
3732
600036
  return TMF_d1_cn_1ef(parm[0], i, x);
3733
}
3734
3735
static float
3736
_nrrd_TMF_d1_cn_1ef_1_f(float x, const double *parm) {
3737
  int i;
3738
3739
  AIR_UNUSED(parm); /* TMF_d1_cn_1ef */
3740
480000
  x += 1;
3741
240000
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
3742
240000
  x -= AIR_CAST(float, i);
3743
600000
  return AIR_CAST(float, TMF_d1_cn_1ef(parm[0], i, x));
3744
}
3745
3746
static void
3747
_nrrd_TMF_d1_cn_1ef_N_d(double *f, const double *x, size_t len, const double *parm) {
3748
  double t;
3749
  size_t I;
3750
  int i;
3751
3752
  AIR_UNUSED(parm); /* TMF_d1_cn_1ef */
3753
480006
  for (I=0; I<len; I++) {
3754
240000
    t = x[I] + 1;
3755
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
3756
240000
    t -= i;
3757
600000
    f[I] = TMF_d1_cn_1ef(parm[0], i, t);
3758
  }
3759
2
}
3760
3761
static void
3762
_nrrd_TMF_d1_cn_1ef_N_f(float *f, const float *x, size_t len, const double *parm) {
3763
  float t;
3764
  size_t I;
3765
  int i;
3766
3767
  AIR_UNUSED(parm); /* TMF_d1_cn_1ef */
3768
480006
  for (I=0; I<len; I++) {
3769
240000
    t = x[I] + 1;
3770
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
3771
240000
    t -= AIR_CAST(float, i);
3772
600000
    f[I] = AIR_CAST(float, TMF_d1_cn_1ef(parm[0], i, t));
3773
  }
3774
2
}
3775
3776
static NrrdKernel
3777
_nrrdKernel_TMF_d1_cn_1ef = {
3778
  "TMF_d1_cn_1ef",
3779
  1, _nrrd_TMF_d1_cn_1ef_Sup, _nrrd_TMF_d1_cn_1ef_Int,
3780
  _nrrd_TMF_d1_cn_1ef_1_f,  _nrrd_TMF_d1_cn_1ef_N_f,
3781
  _nrrd_TMF_d1_cn_1ef_1_d,  _nrrd_TMF_d1_cn_1ef_N_d
3782
};
3783
3784
3785
/* ------------------------ TMF_d1_cn_2ef --------------------- */
3786
3787
static double _nrrd_TMF_d1_cn_2ef_Int(const double *parm) {
3788
  AIR_UNUSED(parm);
3789
4
  return 0.0;
3790
}
3791
3792
static double _nrrd_TMF_d1_cn_2ef_Sup(const double *parm) {
3793
  AIR_UNUSED(parm);
3794
4
  return 2;
3795
}
3796
3797
static double
3798
_nrrd_TMF_d1_cn_2ef_1_d(double x, const double *parm) {
3799
  int i;
3800
3801
3802
480024
  x += 2;
3803
240012
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
3804
240012
  x -= i;
3805


1080060
  return TMF_d1_cn_2ef(parm[0], i, x);
3806
}
3807
3808
static float
3809
_nrrd_TMF_d1_cn_2ef_1_f(float x, const double *parm) {
3810
  int i;
3811
3812
3813
480000
  x += 2;
3814
240000
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
3815
240000
  x -= AIR_CAST(float, i);
3816


1080000
  return AIR_CAST(float, TMF_d1_cn_2ef(parm[0], i, x));
3817
}
3818
3819
static void
3820
_nrrd_TMF_d1_cn_2ef_N_d(double *f, const double *x, size_t len, const double *parm) {
3821
  double t;
3822
  size_t I;
3823
  int i;
3824
3825
3826
480006
  for (I=0; I<len; I++) {
3827
240000
    t = x[I] + 2;
3828
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
3829
240000
    t -= i;
3830


1080000
    f[I] = TMF_d1_cn_2ef(parm[0], i, t);
3831
  }
3832
2
}
3833
3834
static void
3835
_nrrd_TMF_d1_cn_2ef_N_f(float *f, const float *x, size_t len, const double *parm) {
3836
  float t;
3837
  size_t I;
3838
  int i;
3839
3840
3841
480006
  for (I=0; I<len; I++) {
3842
240000
    t = x[I] + 2;
3843
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
3844
240000
    t -= AIR_CAST(float, i);
3845


1080000
    f[I] = AIR_CAST(float, TMF_d1_cn_2ef(parm[0], i, t));
3846
  }
3847
2
}
3848
3849
static NrrdKernel
3850
_nrrdKernel_TMF_d1_cn_2ef = {
3851
  "TMF_d1_cn_2ef",
3852
  1, _nrrd_TMF_d1_cn_2ef_Sup, _nrrd_TMF_d1_cn_2ef_Int,
3853
  _nrrd_TMF_d1_cn_2ef_1_f,  _nrrd_TMF_d1_cn_2ef_N_f,
3854
  _nrrd_TMF_d1_cn_2ef_1_d,  _nrrd_TMF_d1_cn_2ef_N_d
3855
};
3856
3857
3858
/* ------------------------ TMF_d1_cn_3ef --------------------- */
3859
3860
static double _nrrd_TMF_d1_cn_3ef_Int(const double *parm) {
3861
  AIR_UNUSED(parm);
3862
4
  return 0.0;
3863
}
3864
3865
static double _nrrd_TMF_d1_cn_3ef_Sup(const double *parm) {
3866
  AIR_UNUSED(parm);
3867
4
  return 2;
3868
}
3869
3870
static double
3871
_nrrd_TMF_d1_cn_3ef_1_d(double x, const double *parm) {
3872
  int i;
3873
3874
  AIR_UNUSED(parm); /* TMF_d1_cn_3ef */
3875
480024
  x += 2;
3876
240012
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
3877
240012
  x -= i;
3878


1080060
  return TMF_d1_cn_3ef(parm[0], i, x);
3879
}
3880
3881
static float
3882
_nrrd_TMF_d1_cn_3ef_1_f(float x, const double *parm) {
3883
  int i;
3884
3885
  AIR_UNUSED(parm); /* TMF_d1_cn_3ef */
3886
480000
  x += 2;
3887
240000
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
3888
240000
  x -= AIR_CAST(float, i);
3889


1080000
  return AIR_CAST(float, TMF_d1_cn_3ef(parm[0], i, x));
3890
}
3891
3892
static void
3893
_nrrd_TMF_d1_cn_3ef_N_d(double *f, const double *x, size_t len, const double *parm) {
3894
  double t;
3895
  size_t I;
3896
  int i;
3897
3898
  AIR_UNUSED(parm); /* TMF_d1_cn_3ef */
3899
480006
  for (I=0; I<len; I++) {
3900
240000
    t = x[I] + 2;
3901
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
3902
240000
    t -= i;
3903


1080000
    f[I] = TMF_d1_cn_3ef(parm[0], i, t);
3904
  }
3905
2
}
3906
3907
static void
3908
_nrrd_TMF_d1_cn_3ef_N_f(float *f, const float *x, size_t len, const double *parm) {
3909
  float t;
3910
  size_t I;
3911
  int i;
3912
3913
  AIR_UNUSED(parm); /* TMF_d1_cn_3ef */
3914
480006
  for (I=0; I<len; I++) {
3915
240000
    t = x[I] + 2;
3916
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
3917
240000
    t -= AIR_CAST(float, i);
3918


1080000
    f[I] = AIR_CAST(float, TMF_d1_cn_3ef(parm[0], i, t));
3919
  }
3920
2
}
3921
3922
static NrrdKernel
3923
_nrrdKernel_TMF_d1_cn_3ef = {
3924
  "TMF_d1_cn_3ef",
3925
  1, _nrrd_TMF_d1_cn_3ef_Sup, _nrrd_TMF_d1_cn_3ef_Int,
3926
  _nrrd_TMF_d1_cn_3ef_1_f,  _nrrd_TMF_d1_cn_3ef_N_f,
3927
  _nrrd_TMF_d1_cn_3ef_1_d,  _nrrd_TMF_d1_cn_3ef_N_d
3928
};
3929
3930
3931
/* ------------------------ TMF_d1_cn_4ef --------------------- */
3932
3933
static double _nrrd_TMF_d1_cn_4ef_Int(const double *parm) {
3934
  AIR_UNUSED(parm);
3935
4
  return 0.0;
3936
}
3937
3938
static double _nrrd_TMF_d1_cn_4ef_Sup(const double *parm) {
3939
  AIR_UNUSED(parm);
3940
4
  return 3;
3941
}
3942
3943
static double
3944
_nrrd_TMF_d1_cn_4ef_1_d(double x, const double *parm) {
3945
  int i;
3946
3947
3948
480024
  x += 3;
3949
240012
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
3950
240012
  x -= i;
3951



1320084
  return TMF_d1_cn_4ef(parm[0], i, x);
3952
}
3953
3954
static float
3955
_nrrd_TMF_d1_cn_4ef_1_f(float x, const double *parm) {
3956
  int i;
3957
3958
3959
480000
  x += 3;
3960
240000
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
3961
240000
  x -= AIR_CAST(float, i);
3962



1320000
  return AIR_CAST(float, TMF_d1_cn_4ef(parm[0], i, x));
3963
}
3964
3965
static void
3966
_nrrd_TMF_d1_cn_4ef_N_d(double *f, const double *x, size_t len, const double *parm) {
3967
  double t;
3968
  size_t I;
3969
  int i;
3970
3971
3972
480006
  for (I=0; I<len; I++) {
3973
240000
    t = x[I] + 3;
3974
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
3975
240000
    t -= i;
3976



1320000
    f[I] = TMF_d1_cn_4ef(parm[0], i, t);
3977
  }
3978
2
}
3979
3980
static void
3981
_nrrd_TMF_d1_cn_4ef_N_f(float *f, const float *x, size_t len, const double *parm) {
3982
  float t;
3983
  size_t I;
3984
  int i;
3985
3986
3987
480006
  for (I=0; I<len; I++) {
3988
240000
    t = x[I] + 3;
3989
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
3990
240000
    t -= AIR_CAST(float, i);
3991



1320000
    f[I] = AIR_CAST(float, TMF_d1_cn_4ef(parm[0], i, t));
3992
  }
3993
2
}
3994
3995
static NrrdKernel
3996
_nrrdKernel_TMF_d1_cn_4ef = {
3997
  "TMF_d1_cn_4ef",
3998
  1, _nrrd_TMF_d1_cn_4ef_Sup, _nrrd_TMF_d1_cn_4ef_Int,
3999
  _nrrd_TMF_d1_cn_4ef_1_f,  _nrrd_TMF_d1_cn_4ef_N_f,
4000
  _nrrd_TMF_d1_cn_4ef_1_d,  _nrrd_TMF_d1_cn_4ef_N_d
4001
};
4002
4003
4004
/* ------------------------ TMF_d1_c0_1ef --------------------- */
4005
4006
static double _nrrd_TMF_d1_c0_1ef_Int(const double *parm) {
4007
  AIR_UNUSED(parm);
4008
4
  return 0.0;
4009
}
4010
4011
static double _nrrd_TMF_d1_c0_1ef_Sup(const double *parm) {
4012
  AIR_UNUSED(parm);
4013
4
  return 2;
4014
}
4015
4016
static double
4017
_nrrd_TMF_d1_c0_1ef_1_d(double x, const double *parm) {
4018
  int i;
4019
4020
  AIR_UNUSED(parm); /* TMF_d1_c0_1ef */
4021
480024
  x += 2;
4022
240012
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
4023
240012
  x -= i;
4024


1080060
  return TMF_d1_c0_1ef(parm[0], i, x);
4025
}
4026
4027
static float
4028
_nrrd_TMF_d1_c0_1ef_1_f(float x, const double *parm) {
4029
  int i;
4030
4031
  AIR_UNUSED(parm); /* TMF_d1_c0_1ef */
4032
480000
  x += 2;
4033
240000
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
4034
240000
  x -= AIR_CAST(float, i);
4035


1080000
  return AIR_CAST(float, TMF_d1_c0_1ef(parm[0], i, x));
4036
}
4037
4038
static void
4039
_nrrd_TMF_d1_c0_1ef_N_d(double *f, const double *x, size_t len, const double *parm) {
4040
  double t;
4041
  size_t I;
4042
  int i;
4043
4044
  AIR_UNUSED(parm); /* TMF_d1_c0_1ef */
4045
480006
  for (I=0; I<len; I++) {
4046
240000
    t = x[I] + 2;
4047
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
4048
240000
    t -= i;
4049


1080000
    f[I] = TMF_d1_c0_1ef(parm[0], i, t);
4050
  }
4051
2
}
4052
4053
static void
4054
_nrrd_TMF_d1_c0_1ef_N_f(float *f, const float *x, size_t len, const double *parm) {
4055
  float t;
4056
  size_t I;
4057
  int i;
4058
4059
  AIR_UNUSED(parm); /* TMF_d1_c0_1ef */
4060
480006
  for (I=0; I<len; I++) {
4061
240000
    t = x[I] + 2;
4062
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
4063
240000
    t -= AIR_CAST(float, i);
4064


1080000
    f[I] = AIR_CAST(float, TMF_d1_c0_1ef(parm[0], i, t));
4065
  }
4066
2
}
4067
4068
static NrrdKernel
4069
_nrrdKernel_TMF_d1_c0_1ef = {
4070
  "TMF_d1_c0_1ef",
4071
  1, _nrrd_TMF_d1_c0_1ef_Sup, _nrrd_TMF_d1_c0_1ef_Int,
4072
  _nrrd_TMF_d1_c0_1ef_1_f,  _nrrd_TMF_d1_c0_1ef_N_f,
4073
  _nrrd_TMF_d1_c0_1ef_1_d,  _nrrd_TMF_d1_c0_1ef_N_d
4074
};
4075
4076
4077
/* ------------------------ TMF_d1_c0_2ef --------------------- */
4078
4079
static double _nrrd_TMF_d1_c0_2ef_Int(const double *parm) {
4080
  AIR_UNUSED(parm);
4081
4
  return 0.0;
4082
}
4083
4084
static double _nrrd_TMF_d1_c0_2ef_Sup(const double *parm) {
4085
  AIR_UNUSED(parm);
4086
4
  return 2;
4087
}
4088
4089
static double
4090
_nrrd_TMF_d1_c0_2ef_1_d(double x, const double *parm) {
4091
  int i;
4092
4093
  AIR_UNUSED(parm); /* TMF_d1_c0_2ef */
4094
480024
  x += 2;
4095
240012
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
4096
240012
  x -= i;
4097


1080060
  return TMF_d1_c0_2ef(parm[0], i, x);
4098
}
4099
4100
static float
4101
_nrrd_TMF_d1_c0_2ef_1_f(float x, const double *parm) {
4102
  int i;
4103
4104
  AIR_UNUSED(parm); /* TMF_d1_c0_2ef */
4105
480000
  x += 2;
4106
240000
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
4107
240000
  x -= AIR_CAST(float, i);
4108


1080000
  return AIR_CAST(float, TMF_d1_c0_2ef(parm[0], i, x));
4109
}
4110
4111
static void
4112
_nrrd_TMF_d1_c0_2ef_N_d(double *f, const double *x, size_t len, const double *parm) {
4113
  double t;
4114
  size_t I;
4115
  int i;
4116
4117
  AIR_UNUSED(parm); /* TMF_d1_c0_2ef */
4118
480006
  for (I=0; I<len; I++) {
4119
240000
    t = x[I] + 2;
4120
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
4121
240000
    t -= i;
4122


1080000
    f[I] = TMF_d1_c0_2ef(parm[0], i, t);
4123
  }
4124
2
}
4125
4126
static void
4127
_nrrd_TMF_d1_c0_2ef_N_f(float *f, const float *x, size_t len, const double *parm) {
4128
  float t;
4129
  size_t I;
4130
  int i;
4131
4132
  AIR_UNUSED(parm); /* TMF_d1_c0_2ef */
4133
480006
  for (I=0; I<len; I++) {
4134
240000
    t = x[I] + 2;
4135
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
4136
240000
    t -= AIR_CAST(float, i);
4137


1080000
    f[I] = AIR_CAST(float, TMF_d1_c0_2ef(parm[0], i, t));
4138
  }
4139
2
}
4140
4141
static NrrdKernel
4142
_nrrdKernel_TMF_d1_c0_2ef = {
4143
  "TMF_d1_c0_2ef",
4144
  1, _nrrd_TMF_d1_c0_2ef_Sup, _nrrd_TMF_d1_c0_2ef_Int,
4145
  _nrrd_TMF_d1_c0_2ef_1_f,  _nrrd_TMF_d1_c0_2ef_N_f,
4146
  _nrrd_TMF_d1_c0_2ef_1_d,  _nrrd_TMF_d1_c0_2ef_N_d
4147
};
4148
4149
4150
/* ------------------------ TMF_d1_c0_3ef --------------------- */
4151
4152
static double _nrrd_TMF_d1_c0_3ef_Int(const double *parm) {
4153
  AIR_UNUSED(parm);
4154
4
  return 0.0;
4155
}
4156
4157
static double _nrrd_TMF_d1_c0_3ef_Sup(const double *parm) {
4158
  AIR_UNUSED(parm);
4159
4
  return 3;
4160
}
4161
4162
static double
4163
_nrrd_TMF_d1_c0_3ef_1_d(double x, const double *parm) {
4164
  int i;
4165
4166
4167
480024
  x += 3;
4168
240012
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
4169
240012
  x -= i;
4170



1320084
  return TMF_d1_c0_3ef(parm[0], i, x);
4171
}
4172
4173
static float
4174
_nrrd_TMF_d1_c0_3ef_1_f(float x, const double *parm) {
4175
  int i;
4176
4177
4178
480000
  x += 3;
4179
240000
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
4180
240000
  x -= AIR_CAST(float, i);
4181



1320000
  return AIR_CAST(float, TMF_d1_c0_3ef(parm[0], i, x));
4182
}
4183
4184
static void
4185
_nrrd_TMF_d1_c0_3ef_N_d(double *f, const double *x, size_t len, const double *parm) {
4186
  double t;
4187
  size_t I;
4188
  int i;
4189
4190
4191
480006
  for (I=0; I<len; I++) {
4192
240000
    t = x[I] + 3;
4193
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
4194
240000
    t -= i;
4195



1320000
    f[I] = TMF_d1_c0_3ef(parm[0], i, t);
4196
  }
4197
2
}
4198
4199
static void
4200
_nrrd_TMF_d1_c0_3ef_N_f(float *f, const float *x, size_t len, const double *parm) {
4201
  float t;
4202
  size_t I;
4203
  int i;
4204
4205
4206
480006
  for (I=0; I<len; I++) {
4207
240000
    t = x[I] + 3;
4208
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
4209
240000
    t -= AIR_CAST(float, i);
4210



1320000
    f[I] = AIR_CAST(float, TMF_d1_c0_3ef(parm[0], i, t));
4211
  }
4212
2
}
4213
4214
static NrrdKernel
4215
_nrrdKernel_TMF_d1_c0_3ef = {
4216
  "TMF_d1_c0_3ef",
4217
  1, _nrrd_TMF_d1_c0_3ef_Sup, _nrrd_TMF_d1_c0_3ef_Int,
4218
  _nrrd_TMF_d1_c0_3ef_1_f,  _nrrd_TMF_d1_c0_3ef_N_f,
4219
  _nrrd_TMF_d1_c0_3ef_1_d,  _nrrd_TMF_d1_c0_3ef_N_d
4220
};
4221
4222
4223
/* ------------------------ TMF_d1_c0_4ef --------------------- */
4224
4225
static double _nrrd_TMF_d1_c0_4ef_Int(const double *parm) {
4226
  AIR_UNUSED(parm);
4227
4
  return 0.0;
4228
}
4229
4230
static double _nrrd_TMF_d1_c0_4ef_Sup(const double *parm) {
4231
  AIR_UNUSED(parm);
4232
4
  return 3;
4233
}
4234
4235
static double
4236
_nrrd_TMF_d1_c0_4ef_1_d(double x, const double *parm) {
4237
  int i;
4238
4239
4240
480024
  x += 3;
4241
240012
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
4242
240012
  x -= i;
4243



1320084
  return TMF_d1_c0_4ef(parm[0], i, x);
4244
}
4245
4246
static float
4247
_nrrd_TMF_d1_c0_4ef_1_f(float x, const double *parm) {
4248
  int i;
4249
4250
4251
480000
  x += 3;
4252
240000
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
4253
240000
  x -= AIR_CAST(float, i);
4254



1320000
  return AIR_CAST(float, TMF_d1_c0_4ef(parm[0], i, x));
4255
}
4256
4257
static void
4258
_nrrd_TMF_d1_c0_4ef_N_d(double *f, const double *x, size_t len, const double *parm) {
4259
  double t;
4260
  size_t I;
4261
  int i;
4262
4263
4264
480006
  for (I=0; I<len; I++) {
4265
240000
    t = x[I] + 3;
4266
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
4267
240000
    t -= i;
4268



1320000
    f[I] = TMF_d1_c0_4ef(parm[0], i, t);
4269
  }
4270
2
}
4271
4272
static void
4273
_nrrd_TMF_d1_c0_4ef_N_f(float *f, const float *x, size_t len, const double *parm) {
4274
  float t;
4275
  size_t I;
4276
  int i;
4277
4278
4279
480006
  for (I=0; I<len; I++) {
4280
240000
    t = x[I] + 3;
4281
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
4282
240000
    t -= AIR_CAST(float, i);
4283



1320000
    f[I] = AIR_CAST(float, TMF_d1_c0_4ef(parm[0], i, t));
4284
  }
4285
2
}
4286
4287
static NrrdKernel
4288
_nrrdKernel_TMF_d1_c0_4ef = {
4289
  "TMF_d1_c0_4ef",
4290
  1, _nrrd_TMF_d1_c0_4ef_Sup, _nrrd_TMF_d1_c0_4ef_Int,
4291
  _nrrd_TMF_d1_c0_4ef_1_f,  _nrrd_TMF_d1_c0_4ef_N_f,
4292
  _nrrd_TMF_d1_c0_4ef_1_d,  _nrrd_TMF_d1_c0_4ef_N_d
4293
};
4294
4295
4296
/* ------------------------ TMF_d1_c1_1ef --------------------- */
4297
4298
static double _nrrd_TMF_d1_c1_1ef_Int(const double *parm) {
4299
  AIR_UNUSED(parm);
4300
4
  return 0.0;
4301
}
4302
4303
static double _nrrd_TMF_d1_c1_1ef_Sup(const double *parm) {
4304
  AIR_UNUSED(parm);
4305
4
  return 2;
4306
}
4307
4308
static double
4309
_nrrd_TMF_d1_c1_1ef_1_d(double x, const double *parm) {
4310
  int i;
4311
4312
  AIR_UNUSED(parm); /* TMF_d1_c1_1ef */
4313
480024
  x += 2;
4314
240012
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
4315
240012
  x -= i;
4316


1080060
  return TMF_d1_c1_1ef(parm[0], i, x);
4317
}
4318
4319
static float
4320
_nrrd_TMF_d1_c1_1ef_1_f(float x, const double *parm) {
4321
  int i;
4322
4323
  AIR_UNUSED(parm); /* TMF_d1_c1_1ef */
4324
480000
  x += 2;
4325
240000
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
4326
240000
  x -= AIR_CAST(float, i);
4327


1080000
  return AIR_CAST(float, TMF_d1_c1_1ef(parm[0], i, x));
4328
}
4329
4330
static void
4331
_nrrd_TMF_d1_c1_1ef_N_d(double *f, const double *x, size_t len, const double *parm) {
4332
  double t;
4333
  size_t I;
4334
  int i;
4335
4336
  AIR_UNUSED(parm); /* TMF_d1_c1_1ef */
4337
480006
  for (I=0; I<len; I++) {
4338
240000
    t = x[I] + 2;
4339
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
4340
240000
    t -= i;
4341


1080000
    f[I] = TMF_d1_c1_1ef(parm[0], i, t);
4342
  }
4343
2
}
4344
4345
static void
4346
_nrrd_TMF_d1_c1_1ef_N_f(float *f, const float *x, size_t len, const double *parm) {
4347
  float t;
4348
  size_t I;
4349
  int i;
4350
4351
  AIR_UNUSED(parm); /* TMF_d1_c1_1ef */
4352
480006
  for (I=0; I<len; I++) {
4353
240000
    t = x[I] + 2;
4354
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
4355
240000
    t -= AIR_CAST(float, i);
4356


1080000
    f[I] = AIR_CAST(float, TMF_d1_c1_1ef(parm[0], i, t));
4357
  }
4358
2
}
4359
4360
static NrrdKernel
4361
_nrrdKernel_TMF_d1_c1_1ef = {
4362
  "TMF_d1_c1_1ef",
4363
  1, _nrrd_TMF_d1_c1_1ef_Sup, _nrrd_TMF_d1_c1_1ef_Int,
4364
  _nrrd_TMF_d1_c1_1ef_1_f,  _nrrd_TMF_d1_c1_1ef_N_f,
4365
  _nrrd_TMF_d1_c1_1ef_1_d,  _nrrd_TMF_d1_c1_1ef_N_d
4366
};
4367
4368
4369
/* ------------------------ TMF_d1_c1_2ef --------------------- */
4370
4371
static double _nrrd_TMF_d1_c1_2ef_Int(const double *parm) {
4372
  AIR_UNUSED(parm);
4373
4
  return 0.0;
4374
}
4375
4376
static double _nrrd_TMF_d1_c1_2ef_Sup(const double *parm) {
4377
  AIR_UNUSED(parm);
4378
4
  return 2;
4379
}
4380
4381
static double
4382
_nrrd_TMF_d1_c1_2ef_1_d(double x, const double *parm) {
4383
  int i;
4384
4385
  AIR_UNUSED(parm); /* TMF_d1_c1_2ef */
4386
480024
  x += 2;
4387
240012
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
4388
240012
  x -= i;
4389


1080060
  return TMF_d1_c1_2ef(parm[0], i, x);
4390
}
4391
4392
static float
4393
_nrrd_TMF_d1_c1_2ef_1_f(float x, const double *parm) {
4394
  int i;
4395
4396
  AIR_UNUSED(parm); /* TMF_d1_c1_2ef */
4397
480000
  x += 2;
4398
240000
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
4399
240000
  x -= AIR_CAST(float, i);
4400


1080000
  return AIR_CAST(float, TMF_d1_c1_2ef(parm[0], i, x));
4401
}
4402
4403
static void
4404
_nrrd_TMF_d1_c1_2ef_N_d(double *f, const double *x, size_t len, const double *parm) {
4405
  double t;
4406
  size_t I;
4407
  int i;
4408
4409
  AIR_UNUSED(parm); /* TMF_d1_c1_2ef */
4410
480006
  for (I=0; I<len; I++) {
4411
240000
    t = x[I] + 2;
4412
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
4413
240000
    t -= i;
4414


1080000
    f[I] = TMF_d1_c1_2ef(parm[0], i, t);
4415
  }
4416
2
}
4417
4418
static void
4419
_nrrd_TMF_d1_c1_2ef_N_f(float *f, const float *x, size_t len, const double *parm) {
4420
  float t;
4421
  size_t I;
4422
  int i;
4423
4424
  AIR_UNUSED(parm); /* TMF_d1_c1_2ef */
4425
480006
  for (I=0; I<len; I++) {
4426
240000
    t = x[I] + 2;
4427
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
4428
240000
    t -= AIR_CAST(float, i);
4429


1080000
    f[I] = AIR_CAST(float, TMF_d1_c1_2ef(parm[0], i, t));
4430
  }
4431
2
}
4432
4433
static NrrdKernel
4434
_nrrdKernel_TMF_d1_c1_2ef = {
4435
  "TMF_d1_c1_2ef",
4436
  1, _nrrd_TMF_d1_c1_2ef_Sup, _nrrd_TMF_d1_c1_2ef_Int,
4437
  _nrrd_TMF_d1_c1_2ef_1_f,  _nrrd_TMF_d1_c1_2ef_N_f,
4438
  _nrrd_TMF_d1_c1_2ef_1_d,  _nrrd_TMF_d1_c1_2ef_N_d
4439
};
4440
4441
4442
/* ------------------------ TMF_d1_c1_3ef --------------------- */
4443
4444
static double _nrrd_TMF_d1_c1_3ef_Int(const double *parm) {
4445
  AIR_UNUSED(parm);
4446
4
  return 0.0;
4447
}
4448
4449
static double _nrrd_TMF_d1_c1_3ef_Sup(const double *parm) {
4450
  AIR_UNUSED(parm);
4451
4
  return 3;
4452
}
4453
4454
static double
4455
_nrrd_TMF_d1_c1_3ef_1_d(double x, const double *parm) {
4456
  int i;
4457
4458
  AIR_UNUSED(parm); /* TMF_d1_c1_3ef */
4459
480024
  x += 3;
4460
240012
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
4461
240012
  x -= i;
4462



1320084
  return TMF_d1_c1_3ef(parm[0], i, x);
4463
}
4464
4465
static float
4466
_nrrd_TMF_d1_c1_3ef_1_f(float x, const double *parm) {
4467
  int i;
4468
4469
  AIR_UNUSED(parm); /* TMF_d1_c1_3ef */
4470
480000
  x += 3;
4471
240000
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
4472
240000
  x -= AIR_CAST(float, i);
4473



1320000
  return AIR_CAST(float, TMF_d1_c1_3ef(parm[0], i, x));
4474
}
4475
4476
static void
4477
_nrrd_TMF_d1_c1_3ef_N_d(double *f, const double *x, size_t len, const double *parm) {
4478
  double t;
4479
  size_t I;
4480
  int i;
4481
4482
  AIR_UNUSED(parm); /* TMF_d1_c1_3ef */
4483
480006
  for (I=0; I<len; I++) {
4484
240000
    t = x[I] + 3;
4485
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
4486
240000
    t -= i;
4487



1320000
    f[I] = TMF_d1_c1_3ef(parm[0], i, t);
4488
  }
4489
2
}
4490
4491
static void
4492
_nrrd_TMF_d1_c1_3ef_N_f(float *f, const float *x, size_t len, const double *parm) {
4493
  float t;
4494
  size_t I;
4495
  int i;
4496
4497
  AIR_UNUSED(parm); /* TMF_d1_c1_3ef */
4498
480006
  for (I=0; I<len; I++) {
4499
240000
    t = x[I] + 3;
4500
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
4501
240000
    t -= AIR_CAST(float, i);
4502



1320000
    f[I] = AIR_CAST(float, TMF_d1_c1_3ef(parm[0], i, t));
4503
  }
4504
2
}
4505
4506
static NrrdKernel
4507
_nrrdKernel_TMF_d1_c1_3ef = {
4508
  "TMF_d1_c1_3ef",
4509
  1, _nrrd_TMF_d1_c1_3ef_Sup, _nrrd_TMF_d1_c1_3ef_Int,
4510
  _nrrd_TMF_d1_c1_3ef_1_f,  _nrrd_TMF_d1_c1_3ef_N_f,
4511
  _nrrd_TMF_d1_c1_3ef_1_d,  _nrrd_TMF_d1_c1_3ef_N_d
4512
};
4513
4514
4515
/* ------------------------ TMF_d1_c1_4ef --------------------- */
4516
4517
static double _nrrd_TMF_d1_c1_4ef_Int(const double *parm) {
4518
  AIR_UNUSED(parm);
4519
4
  return 0.0;
4520
}
4521
4522
static double _nrrd_TMF_d1_c1_4ef_Sup(const double *parm) {
4523
  AIR_UNUSED(parm);
4524
4
  return 3;
4525
}
4526
4527
static double
4528
_nrrd_TMF_d1_c1_4ef_1_d(double x, const double *parm) {
4529
  int i;
4530
4531
  AIR_UNUSED(parm); /* TMF_d1_c1_4ef */
4532
480024
  x += 3;
4533
240012
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
4534
240012
  x -= i;
4535



1320084
  return TMF_d1_c1_4ef(parm[0], i, x);
4536
}
4537
4538
static float
4539
_nrrd_TMF_d1_c1_4ef_1_f(float x, const double *parm) {
4540
  int i;
4541
4542
  AIR_UNUSED(parm); /* TMF_d1_c1_4ef */
4543
480000
  x += 3;
4544
240000
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
4545
240000
  x -= AIR_CAST(float, i);
4546



1320000
  return AIR_CAST(float, TMF_d1_c1_4ef(parm[0], i, x));
4547
}
4548
4549
static void
4550
_nrrd_TMF_d1_c1_4ef_N_d(double *f, const double *x, size_t len, const double *parm) {
4551
  double t;
4552
  size_t I;
4553
  int i;
4554
4555
  AIR_UNUSED(parm); /* TMF_d1_c1_4ef */
4556
480006
  for (I=0; I<len; I++) {
4557
240000
    t = x[I] + 3;
4558
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
4559
240000
    t -= i;
4560



1320000
    f[I] = TMF_d1_c1_4ef(parm[0], i, t);
4561
  }
4562
2
}
4563
4564
static void
4565
_nrrd_TMF_d1_c1_4ef_N_f(float *f, const float *x, size_t len, const double *parm) {
4566
  float t;
4567
  size_t I;
4568
  int i;
4569
4570
  AIR_UNUSED(parm); /* TMF_d1_c1_4ef */
4571
480006
  for (I=0; I<len; I++) {
4572
240000
    t = x[I] + 3;
4573
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
4574
240000
    t -= AIR_CAST(float, i);
4575



1320000
    f[I] = AIR_CAST(float, TMF_d1_c1_4ef(parm[0], i, t));
4576
  }
4577
2
}
4578
4579
static NrrdKernel
4580
_nrrdKernel_TMF_d1_c1_4ef = {
4581
  "TMF_d1_c1_4ef",
4582
  1, _nrrd_TMF_d1_c1_4ef_Sup, _nrrd_TMF_d1_c1_4ef_Int,
4583
  _nrrd_TMF_d1_c1_4ef_1_f,  _nrrd_TMF_d1_c1_4ef_N_f,
4584
  _nrrd_TMF_d1_c1_4ef_1_d,  _nrrd_TMF_d1_c1_4ef_N_d
4585
};
4586
4587
4588
/* ------------------------ TMF_d1_c2_1ef --------------------- */
4589
4590
static double _nrrd_TMF_d1_c2_1ef_Int(const double *parm) {
4591
  AIR_UNUSED(parm);
4592
4
  return 0.0;
4593
}
4594
4595
static double _nrrd_TMF_d1_c2_1ef_Sup(const double *parm) {
4596
  AIR_UNUSED(parm);
4597
4
  return 2;
4598
}
4599
4600
static double
4601
_nrrd_TMF_d1_c2_1ef_1_d(double x, const double *parm) {
4602
  int i;
4603
4604
  AIR_UNUSED(parm); /* TMF_d1_c2_1ef */
4605
480024
  x += 2;
4606
240012
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
4607
240012
  x -= i;
4608


1080060
  return TMF_d1_c2_1ef(parm[0], i, x);
4609
}
4610
4611
static float
4612
_nrrd_TMF_d1_c2_1ef_1_f(float x, const double *parm) {
4613
  int i;
4614
4615
  AIR_UNUSED(parm); /* TMF_d1_c2_1ef */
4616
480000
  x += 2;
4617
240000
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
4618
240000
  x -= AIR_CAST(float, i);
4619


1080000
  return AIR_CAST(float, TMF_d1_c2_1ef(parm[0], i, x));
4620
}
4621
4622
static void
4623
_nrrd_TMF_d1_c2_1ef_N_d(double *f, const double *x, size_t len, const double *parm) {
4624
  double t;
4625
  size_t I;
4626
  int i;
4627
4628
  AIR_UNUSED(parm); /* TMF_d1_c2_1ef */
4629
480006
  for (I=0; I<len; I++) {
4630
240000
    t = x[I] + 2;
4631
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
4632
240000
    t -= i;
4633


1080000
    f[I] = TMF_d1_c2_1ef(parm[0], i, t);
4634
  }
4635
2
}
4636
4637
static void
4638
_nrrd_TMF_d1_c2_1ef_N_f(float *f, const float *x, size_t len, const double *parm) {
4639
  float t;
4640
  size_t I;
4641
  int i;
4642
4643
  AIR_UNUSED(parm); /* TMF_d1_c2_1ef */
4644
480006
  for (I=0; I<len; I++) {
4645
240000
    t = x[I] + 2;
4646
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
4647
240000
    t -= AIR_CAST(float, i);
4648


1080000
    f[I] = AIR_CAST(float, TMF_d1_c2_1ef(parm[0], i, t));
4649
  }
4650
2
}
4651
4652
static NrrdKernel
4653
_nrrdKernel_TMF_d1_c2_1ef = {
4654
  "TMF_d1_c2_1ef",
4655
  1, _nrrd_TMF_d1_c2_1ef_Sup, _nrrd_TMF_d1_c2_1ef_Int,
4656
  _nrrd_TMF_d1_c2_1ef_1_f,  _nrrd_TMF_d1_c2_1ef_N_f,
4657
  _nrrd_TMF_d1_c2_1ef_1_d,  _nrrd_TMF_d1_c2_1ef_N_d
4658
};
4659
4660
4661
/* ------------------------ TMF_d1_c2_2ef --------------------- */
4662
4663
static double _nrrd_TMF_d1_c2_2ef_Int(const double *parm) {
4664
  AIR_UNUSED(parm);
4665
4
  return 0.0;
4666
}
4667
4668
static double _nrrd_TMF_d1_c2_2ef_Sup(const double *parm) {
4669
  AIR_UNUSED(parm);
4670
4
  return 2;
4671
}
4672
4673
static double
4674
_nrrd_TMF_d1_c2_2ef_1_d(double x, const double *parm) {
4675
  int i;
4676
4677
  AIR_UNUSED(parm); /* TMF_d1_c2_2ef */
4678
480024
  x += 2;
4679
240012
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
4680
240012
  x -= i;
4681


1080060
  return TMF_d1_c2_2ef(parm[0], i, x);
4682
}
4683
4684
static float
4685
_nrrd_TMF_d1_c2_2ef_1_f(float x, const double *parm) {
4686
  int i;
4687
4688
  AIR_UNUSED(parm); /* TMF_d1_c2_2ef */
4689
480000
  x += 2;
4690
240000
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
4691
240000
  x -= AIR_CAST(float, i);
4692


1080000
  return AIR_CAST(float, TMF_d1_c2_2ef(parm[0], i, x));
4693
}
4694
4695
static void
4696
_nrrd_TMF_d1_c2_2ef_N_d(double *f, const double *x, size_t len, const double *parm) {
4697
  double t;
4698
  size_t I;
4699
  int i;
4700
4701
  AIR_UNUSED(parm); /* TMF_d1_c2_2ef */
4702
480006
  for (I=0; I<len; I++) {
4703
240000
    t = x[I] + 2;
4704
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
4705
240000
    t -= i;
4706


1080000
    f[I] = TMF_d1_c2_2ef(parm[0], i, t);
4707
  }
4708
2
}
4709
4710
static void
4711
_nrrd_TMF_d1_c2_2ef_N_f(float *f, const float *x, size_t len, const double *parm) {
4712
  float t;
4713
  size_t I;
4714
  int i;
4715
4716
  AIR_UNUSED(parm); /* TMF_d1_c2_2ef */
4717
480006
  for (I=0; I<len; I++) {
4718
240000
    t = x[I] + 2;
4719
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
4720
240000
    t -= AIR_CAST(float, i);
4721


1080000
    f[I] = AIR_CAST(float, TMF_d1_c2_2ef(parm[0], i, t));
4722
  }
4723
2
}
4724
4725
static NrrdKernel
4726
_nrrdKernel_TMF_d1_c2_2ef = {
4727
  "TMF_d1_c2_2ef",
4728
  1, _nrrd_TMF_d1_c2_2ef_Sup, _nrrd_TMF_d1_c2_2ef_Int,
4729
  _nrrd_TMF_d1_c2_2ef_1_f,  _nrrd_TMF_d1_c2_2ef_N_f,
4730
  _nrrd_TMF_d1_c2_2ef_1_d,  _nrrd_TMF_d1_c2_2ef_N_d
4731
};
4732
4733
4734
/* ------------------------ TMF_d1_c2_3ef --------------------- */
4735
4736
static double _nrrd_TMF_d1_c2_3ef_Int(const double *parm) {
4737
  AIR_UNUSED(parm);
4738
4
  return 0.0;
4739
}
4740
4741
static double _nrrd_TMF_d1_c2_3ef_Sup(const double *parm) {
4742
  AIR_UNUSED(parm);
4743
4
  return 3;
4744
}
4745
4746
static double
4747
_nrrd_TMF_d1_c2_3ef_1_d(double x, const double *parm) {
4748
  int i;
4749
4750
  AIR_UNUSED(parm); /* TMF_d1_c2_3ef */
4751
480024
  x += 3;
4752
240012
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
4753
240012
  x -= i;
4754



1320084
  return TMF_d1_c2_3ef(parm[0], i, x);
4755
}
4756
4757
static float
4758
_nrrd_TMF_d1_c2_3ef_1_f(float x, const double *parm) {
4759
  int i;
4760
4761
  AIR_UNUSED(parm); /* TMF_d1_c2_3ef */
4762
480000
  x += 3;
4763
240000
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
4764
240000
  x -= AIR_CAST(float, i);
4765



1320000
  return AIR_CAST(float, TMF_d1_c2_3ef(parm[0], i, x));
4766
}
4767
4768
static void
4769
_nrrd_TMF_d1_c2_3ef_N_d(double *f, const double *x, size_t len, const double *parm) {
4770
  double t;
4771
  size_t I;
4772
  int i;
4773
4774
  AIR_UNUSED(parm); /* TMF_d1_c2_3ef */
4775
480006
  for (I=0; I<len; I++) {
4776
240000
    t = x[I] + 3;
4777
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
4778
240000
    t -= i;
4779



1320000
    f[I] = TMF_d1_c2_3ef(parm[0], i, t);
4780
  }
4781
2
}
4782
4783
static void
4784
_nrrd_TMF_d1_c2_3ef_N_f(float *f, const float *x, size_t len, const double *parm) {
4785
  float t;
4786
  size_t I;
4787
  int i;
4788
4789
  AIR_UNUSED(parm); /* TMF_d1_c2_3ef */
4790
480006
  for (I=0; I<len; I++) {
4791
240000
    t = x[I] + 3;
4792
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
4793
240000
    t -= AIR_CAST(float, i);
4794



1320000
    f[I] = AIR_CAST(float, TMF_d1_c2_3ef(parm[0], i, t));
4795
  }
4796
2
}
4797
4798
static NrrdKernel
4799
_nrrdKernel_TMF_d1_c2_3ef = {
4800
  "TMF_d1_c2_3ef",
4801
  1, _nrrd_TMF_d1_c2_3ef_Sup, _nrrd_TMF_d1_c2_3ef_Int,
4802
  _nrrd_TMF_d1_c2_3ef_1_f,  _nrrd_TMF_d1_c2_3ef_N_f,
4803
  _nrrd_TMF_d1_c2_3ef_1_d,  _nrrd_TMF_d1_c2_3ef_N_d
4804
};
4805
4806
4807
/* ------------------------ TMF_d1_c2_4ef --------------------- */
4808
4809
static double _nrrd_TMF_d1_c2_4ef_Int(const double *parm) {
4810
  AIR_UNUSED(parm);
4811
4
  return 0.0;
4812
}
4813
4814
static double _nrrd_TMF_d1_c2_4ef_Sup(const double *parm) {
4815
  AIR_UNUSED(parm);
4816
4
  return 3;
4817
}
4818
4819
static double
4820
_nrrd_TMF_d1_c2_4ef_1_d(double x, const double *parm) {
4821
  int i;
4822
4823
  AIR_UNUSED(parm); /* TMF_d1_c2_4ef */
4824
480024
  x += 3;
4825
240012
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
4826
240012
  x -= i;
4827



1320084
  return TMF_d1_c2_4ef(parm[0], i, x);
4828
}
4829
4830
static float
4831
_nrrd_TMF_d1_c2_4ef_1_f(float x, const double *parm) {
4832
  int i;
4833
4834
  AIR_UNUSED(parm); /* TMF_d1_c2_4ef */
4835
480000
  x += 3;
4836
240000
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
4837
240000
  x -= AIR_CAST(float, i);
4838



1320000
  return AIR_CAST(float, TMF_d1_c2_4ef(parm[0], i, x));
4839
}
4840
4841
static void
4842
_nrrd_TMF_d1_c2_4ef_N_d(double *f, const double *x, size_t len, const double *parm) {
4843
  double t;
4844
  size_t I;
4845
  int i;
4846
4847
  AIR_UNUSED(parm); /* TMF_d1_c2_4ef */
4848
480006
  for (I=0; I<len; I++) {
4849
240000
    t = x[I] + 3;
4850
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
4851
240000
    t -= i;
4852



1320000
    f[I] = TMF_d1_c2_4ef(parm[0], i, t);
4853
  }
4854
2
}
4855
4856
static void
4857
_nrrd_TMF_d1_c2_4ef_N_f(float *f, const float *x, size_t len, const double *parm) {
4858
  float t;
4859
  size_t I;
4860
  int i;
4861
4862
  AIR_UNUSED(parm); /* TMF_d1_c2_4ef */
4863
480006
  for (I=0; I<len; I++) {
4864
240000
    t = x[I] + 3;
4865
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
4866
240000
    t -= AIR_CAST(float, i);
4867



1320000
    f[I] = AIR_CAST(float, TMF_d1_c2_4ef(parm[0], i, t));
4868
  }
4869
2
}
4870
4871
static NrrdKernel
4872
_nrrdKernel_TMF_d1_c2_4ef = {
4873
  "TMF_d1_c2_4ef",
4874
  1, _nrrd_TMF_d1_c2_4ef_Sup, _nrrd_TMF_d1_c2_4ef_Int,
4875
  _nrrd_TMF_d1_c2_4ef_1_f,  _nrrd_TMF_d1_c2_4ef_N_f,
4876
  _nrrd_TMF_d1_c2_4ef_1_d,  _nrrd_TMF_d1_c2_4ef_N_d
4877
};
4878
4879
4880
/* ------------------------ TMF_d1_c3_1ef --------------------- */
4881
4882
static double _nrrd_TMF_d1_c3_1ef_Int(const double *parm) {
4883
  AIR_UNUSED(parm);
4884
4
  return 0.0;
4885
}
4886
4887
static double _nrrd_TMF_d1_c3_1ef_Sup(const double *parm) {
4888
  AIR_UNUSED(parm);
4889
4
  return 2;
4890
}
4891
4892
static double
4893
_nrrd_TMF_d1_c3_1ef_1_d(double x, const double *parm) {
4894
  int i;
4895
4896
  AIR_UNUSED(parm); /* TMF_d1_c3_1ef */
4897
480024
  x += 2;
4898
240012
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
4899
240012
  x -= i;
4900


1080060
  return TMF_d1_c3_1ef(parm[0], i, x);
4901
}
4902
4903
static float
4904
_nrrd_TMF_d1_c3_1ef_1_f(float x, const double *parm) {
4905
  int i;
4906
4907
  AIR_UNUSED(parm); /* TMF_d1_c3_1ef */
4908
480000
  x += 2;
4909
240000
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
4910
240000
  x -= AIR_CAST(float, i);
4911


1080000
  return AIR_CAST(float, TMF_d1_c3_1ef(parm[0], i, x));
4912
}
4913
4914
static void
4915
_nrrd_TMF_d1_c3_1ef_N_d(double *f, const double *x, size_t len, const double *parm) {
4916
  double t;
4917
  size_t I;
4918
  int i;
4919
4920
  AIR_UNUSED(parm); /* TMF_d1_c3_1ef */
4921
480006
  for (I=0; I<len; I++) {
4922
240000
    t = x[I] + 2;
4923
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
4924
240000
    t -= i;
4925


1080000
    f[I] = TMF_d1_c3_1ef(parm[0], i, t);
4926
  }
4927
2
}
4928
4929
static void
4930
_nrrd_TMF_d1_c3_1ef_N_f(float *f, const float *x, size_t len, const double *parm) {
4931
  float t;
4932
  size_t I;
4933
  int i;
4934
4935
  AIR_UNUSED(parm); /* TMF_d1_c3_1ef */
4936
480006
  for (I=0; I<len; I++) {
4937
240000
    t = x[I] + 2;
4938
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
4939
240000
    t -= AIR_CAST(float, i);
4940


1080000
    f[I] = AIR_CAST(float, TMF_d1_c3_1ef(parm[0], i, t));
4941
  }
4942
2
}
4943
4944
static NrrdKernel
4945
_nrrdKernel_TMF_d1_c3_1ef = {
4946
  "TMF_d1_c3_1ef",
4947
  1, _nrrd_TMF_d1_c3_1ef_Sup, _nrrd_TMF_d1_c3_1ef_Int,
4948
  _nrrd_TMF_d1_c3_1ef_1_f,  _nrrd_TMF_d1_c3_1ef_N_f,
4949
  _nrrd_TMF_d1_c3_1ef_1_d,  _nrrd_TMF_d1_c3_1ef_N_d
4950
};
4951
4952
4953
/* ------------------------ TMF_d1_c3_2ef --------------------- */
4954
4955
static double _nrrd_TMF_d1_c3_2ef_Int(const double *parm) {
4956
  AIR_UNUSED(parm);
4957
4
  return 0.0;
4958
}
4959
4960
static double _nrrd_TMF_d1_c3_2ef_Sup(const double *parm) {
4961
  AIR_UNUSED(parm);
4962
4
  return 2;
4963
}
4964
4965
static double
4966
_nrrd_TMF_d1_c3_2ef_1_d(double x, const double *parm) {
4967
  int i;
4968
4969
  AIR_UNUSED(parm); /* TMF_d1_c3_2ef */
4970
480024
  x += 2;
4971
240012
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
4972
240012
  x -= i;
4973


1080060
  return TMF_d1_c3_2ef(parm[0], i, x);
4974
}
4975
4976
static float
4977
_nrrd_TMF_d1_c3_2ef_1_f(float x, const double *parm) {
4978
  int i;
4979
4980
  AIR_UNUSED(parm); /* TMF_d1_c3_2ef */
4981
480000
  x += 2;
4982
240000
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
4983
240000
  x -= AIR_CAST(float, i);
4984


1080000
  return AIR_CAST(float, TMF_d1_c3_2ef(parm[0], i, x));
4985
}
4986
4987
static void
4988
_nrrd_TMF_d1_c3_2ef_N_d(double *f, const double *x, size_t len, const double *parm) {
4989
  double t;
4990
  size_t I;
4991
  int i;
4992
4993
  AIR_UNUSED(parm); /* TMF_d1_c3_2ef */
4994
480006
  for (I=0; I<len; I++) {
4995
240000
    t = x[I] + 2;
4996
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
4997
240000
    t -= i;
4998


1080000
    f[I] = TMF_d1_c3_2ef(parm[0], i, t);
4999
  }
5000
2
}
5001
5002
static void
5003
_nrrd_TMF_d1_c3_2ef_N_f(float *f, const float *x, size_t len, const double *parm) {
5004
  float t;
5005
  size_t I;
5006
  int i;
5007
5008
  AIR_UNUSED(parm); /* TMF_d1_c3_2ef */
5009
480006
  for (I=0; I<len; I++) {
5010
240000
    t = x[I] + 2;
5011
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
5012
240000
    t -= AIR_CAST(float, i);
5013


1080000
    f[I] = AIR_CAST(float, TMF_d1_c3_2ef(parm[0], i, t));
5014
  }
5015
2
}
5016
5017
static NrrdKernel
5018
_nrrdKernel_TMF_d1_c3_2ef = {
5019
  "TMF_d1_c3_2ef",
5020
  1, _nrrd_TMF_d1_c3_2ef_Sup, _nrrd_TMF_d1_c3_2ef_Int,
5021
  _nrrd_TMF_d1_c3_2ef_1_f,  _nrrd_TMF_d1_c3_2ef_N_f,
5022
  _nrrd_TMF_d1_c3_2ef_1_d,  _nrrd_TMF_d1_c3_2ef_N_d
5023
};
5024
5025
5026
/* ------------------------ TMF_d1_c3_3ef --------------------- */
5027
5028
static double _nrrd_TMF_d1_c3_3ef_Int(const double *parm) {
5029
  AIR_UNUSED(parm);
5030
4
  return 0.0;
5031
}
5032
5033
static double _nrrd_TMF_d1_c3_3ef_Sup(const double *parm) {
5034
  AIR_UNUSED(parm);
5035
4
  return 3;
5036
}
5037
5038
static double
5039
_nrrd_TMF_d1_c3_3ef_1_d(double x, const double *parm) {
5040
  int i;
5041
5042
  AIR_UNUSED(parm); /* TMF_d1_c3_3ef */
5043
480024
  x += 3;
5044
240012
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
5045
240012
  x -= i;
5046



1320084
  return TMF_d1_c3_3ef(parm[0], i, x);
5047
}
5048
5049
static float
5050
_nrrd_TMF_d1_c3_3ef_1_f(float x, const double *parm) {
5051
  int i;
5052
5053
  AIR_UNUSED(parm); /* TMF_d1_c3_3ef */
5054
480000
  x += 3;
5055
240000
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
5056
240000
  x -= AIR_CAST(float, i);
5057



1320000
  return AIR_CAST(float, TMF_d1_c3_3ef(parm[0], i, x));
5058
}
5059
5060
static void
5061
_nrrd_TMF_d1_c3_3ef_N_d(double *f, const double *x, size_t len, const double *parm) {
5062
  double t;
5063
  size_t I;
5064
  int i;
5065
5066
  AIR_UNUSED(parm); /* TMF_d1_c3_3ef */
5067
480006
  for (I=0; I<len; I++) {
5068
240000
    t = x[I] + 3;
5069
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
5070
240000
    t -= i;
5071



1320000
    f[I] = TMF_d1_c3_3ef(parm[0], i, t);
5072
  }
5073
2
}
5074
5075
static void
5076
_nrrd_TMF_d1_c3_3ef_N_f(float *f, const float *x, size_t len, const double *parm) {
5077
  float t;
5078
  size_t I;
5079
  int i;
5080
5081
  AIR_UNUSED(parm); /* TMF_d1_c3_3ef */
5082
480006
  for (I=0; I<len; I++) {
5083
240000
    t = x[I] + 3;
5084
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
5085
240000
    t -= AIR_CAST(float, i);
5086



1320000
    f[I] = AIR_CAST(float, TMF_d1_c3_3ef(parm[0], i, t));
5087
  }
5088
2
}
5089
5090
static NrrdKernel
5091
_nrrdKernel_TMF_d1_c3_3ef = {
5092
  "TMF_d1_c3_3ef",
5093
  1, _nrrd_TMF_d1_c3_3ef_Sup, _nrrd_TMF_d1_c3_3ef_Int,
5094
  _nrrd_TMF_d1_c3_3ef_1_f,  _nrrd_TMF_d1_c3_3ef_N_f,
5095
  _nrrd_TMF_d1_c3_3ef_1_d,  _nrrd_TMF_d1_c3_3ef_N_d
5096
};
5097
5098
5099
/* ------------------------ TMF_d1_c3_4ef --------------------- */
5100
5101
static double _nrrd_TMF_d1_c3_4ef_Int(const double *parm) {
5102
  AIR_UNUSED(parm);
5103
4
  return 0.0;
5104
}
5105
5106
static double _nrrd_TMF_d1_c3_4ef_Sup(const double *parm) {
5107
  AIR_UNUSED(parm);
5108
4
  return 3;
5109
}
5110
5111
static double
5112
_nrrd_TMF_d1_c3_4ef_1_d(double x, const double *parm) {
5113
  int i;
5114
5115
  AIR_UNUSED(parm); /* TMF_d1_c3_4ef */
5116
480024
  x += 3;
5117
240012
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
5118
240012
  x -= i;
5119



1320084
  return TMF_d1_c3_4ef(parm[0], i, x);
5120
}
5121
5122
static float
5123
_nrrd_TMF_d1_c3_4ef_1_f(float x, const double *parm) {
5124
  int i;
5125
5126
  AIR_UNUSED(parm); /* TMF_d1_c3_4ef */
5127
480000
  x += 3;
5128
240000
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
5129
240000
  x -= AIR_CAST(float, i);
5130



1320000
  return AIR_CAST(float, TMF_d1_c3_4ef(parm[0], i, x));
5131
}
5132
5133
static void
5134
_nrrd_TMF_d1_c3_4ef_N_d(double *f, const double *x, size_t len, const double *parm) {
5135
  double t;
5136
  size_t I;
5137
  int i;
5138
5139
  AIR_UNUSED(parm); /* TMF_d1_c3_4ef */
5140
480006
  for (I=0; I<len; I++) {
5141
240000
    t = x[I] + 3;
5142
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
5143
240000
    t -= i;
5144



1320000
    f[I] = TMF_d1_c3_4ef(parm[0], i, t);
5145
  }
5146
2
}
5147
5148
static void
5149
_nrrd_TMF_d1_c3_4ef_N_f(float *f, const float *x, size_t len, const double *parm) {
5150
  float t;
5151
  size_t I;
5152
  int i;
5153
5154
  AIR_UNUSED(parm); /* TMF_d1_c3_4ef */
5155
480006
  for (I=0; I<len; I++) {
5156
240000
    t = x[I] + 3;
5157
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
5158
240000
    t -= AIR_CAST(float, i);
5159



1320000
    f[I] = AIR_CAST(float, TMF_d1_c3_4ef(parm[0], i, t));
5160
  }
5161
2
}
5162
5163
static NrrdKernel
5164
_nrrdKernel_TMF_d1_c3_4ef = {
5165
  "TMF_d1_c3_4ef",
5166
  1, _nrrd_TMF_d1_c3_4ef_Sup, _nrrd_TMF_d1_c3_4ef_Int,
5167
  _nrrd_TMF_d1_c3_4ef_1_f,  _nrrd_TMF_d1_c3_4ef_N_f,
5168
  _nrrd_TMF_d1_c3_4ef_1_d,  _nrrd_TMF_d1_c3_4ef_N_d
5169
};
5170
5171
5172
/* ------------------------ TMF_d2_cn_1ef --------------------- */
5173
5174
static double _nrrd_TMF_d2_cn_1ef_Int(const double *parm) {
5175
  AIR_UNUSED(parm);
5176
4
  return 0.0;
5177
}
5178
5179
static double _nrrd_TMF_d2_cn_1ef_Sup(const double *parm) {
5180
  AIR_UNUSED(parm);
5181
4
  return 2;
5182
}
5183
5184
static double
5185
_nrrd_TMF_d2_cn_1ef_1_d(double x, const double *parm) {
5186
  int i;
5187
5188
  AIR_UNUSED(parm); /* TMF_d2_cn_1ef */
5189
480024
  x += 2;
5190
240012
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
5191
240012
  x -= i;
5192

720048
  return TMF_d2_cn_1ef(parm[0], i, x);
5193
}
5194
5195
static float
5196
_nrrd_TMF_d2_cn_1ef_1_f(float x, const double *parm) {
5197
  int i;
5198
5199
  AIR_UNUSED(parm); /* TMF_d2_cn_1ef */
5200
480000
  x += 2;
5201
240000
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
5202
240000
  x -= AIR_CAST(float, i);
5203

720000
  return AIR_CAST(float, TMF_d2_cn_1ef(parm[0], i, x));
5204
}
5205
5206
static void
5207
_nrrd_TMF_d2_cn_1ef_N_d(double *f, const double *x, size_t len, const double *parm) {
5208
  double t;
5209
  size_t I;
5210
  int i;
5211
5212
  AIR_UNUSED(parm); /* TMF_d2_cn_1ef */
5213
480006
  for (I=0; I<len; I++) {
5214
240000
    t = x[I] + 2;
5215
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
5216
240000
    t -= i;
5217

720000
    f[I] = TMF_d2_cn_1ef(parm[0], i, t);
5218
  }
5219
2
}
5220
5221
static void
5222
_nrrd_TMF_d2_cn_1ef_N_f(float *f, const float *x, size_t len, const double *parm) {
5223
  float t;
5224
  size_t I;
5225
  int i;
5226
5227
  AIR_UNUSED(parm); /* TMF_d2_cn_1ef */
5228
480006
  for (I=0; I<len; I++) {
5229
240000
    t = x[I] + 2;
5230
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
5231
240000
    t -= AIR_CAST(float, i);
5232

720000
    f[I] = AIR_CAST(float, TMF_d2_cn_1ef(parm[0], i, t));
5233
  }
5234
2
}
5235
5236
static NrrdKernel
5237
_nrrdKernel_TMF_d2_cn_1ef = {
5238
  "TMF_d2_cn_1ef",
5239
  1, _nrrd_TMF_d2_cn_1ef_Sup, _nrrd_TMF_d2_cn_1ef_Int,
5240
  _nrrd_TMF_d2_cn_1ef_1_f,  _nrrd_TMF_d2_cn_1ef_N_f,
5241
  _nrrd_TMF_d2_cn_1ef_1_d,  _nrrd_TMF_d2_cn_1ef_N_d
5242
};
5243
5244
5245
/* ------------------------ TMF_d2_cn_2ef --------------------- */
5246
5247
static double _nrrd_TMF_d2_cn_2ef_Int(const double *parm) {
5248
  AIR_UNUSED(parm);
5249
4
  return 0.0;
5250
}
5251
5252
static double _nrrd_TMF_d2_cn_2ef_Sup(const double *parm) {
5253
  AIR_UNUSED(parm);
5254
4
  return 2;
5255
}
5256
5257
static double
5258
_nrrd_TMF_d2_cn_2ef_1_d(double x, const double *parm) {
5259
  int i;
5260
5261
  AIR_UNUSED(parm); /* TMF_d2_cn_2ef */
5262
480024
  x += 2;
5263
240012
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
5264
240012
  x -= i;
5265


1080060
  return TMF_d2_cn_2ef(parm[0], i, x);
5266
}
5267
5268
static float
5269
_nrrd_TMF_d2_cn_2ef_1_f(float x, const double *parm) {
5270
  int i;
5271
5272
  AIR_UNUSED(parm); /* TMF_d2_cn_2ef */
5273
480000
  x += 2;
5274
240000
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
5275
240000
  x -= AIR_CAST(float, i);
5276


1080000
  return AIR_CAST(float, TMF_d2_cn_2ef(parm[0], i, x));
5277
}
5278
5279
static void
5280
_nrrd_TMF_d2_cn_2ef_N_d(double *f, const double *x, size_t len, const double *parm) {
5281
  double t;
5282
  size_t I;
5283
  int i;
5284
5285
  AIR_UNUSED(parm); /* TMF_d2_cn_2ef */
5286
480006
  for (I=0; I<len; I++) {
5287
240000
    t = x[I] + 2;
5288
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
5289
240000
    t -= i;
5290


1080000
    f[I] = TMF_d2_cn_2ef(parm[0], i, t);
5291
  }
5292
2
}
5293
5294
static void
5295
_nrrd_TMF_d2_cn_2ef_N_f(float *f, const float *x, size_t len, const double *parm) {
5296
  float t;
5297
  size_t I;
5298
  int i;
5299
5300
  AIR_UNUSED(parm); /* TMF_d2_cn_2ef */
5301
480006
  for (I=0; I<len; I++) {
5302
240000
    t = x[I] + 2;
5303
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
5304
240000
    t -= AIR_CAST(float, i);
5305


1080000
    f[I] = AIR_CAST(float, TMF_d2_cn_2ef(parm[0], i, t));
5306
  }
5307
2
}
5308
5309
static NrrdKernel
5310
_nrrdKernel_TMF_d2_cn_2ef = {
5311
  "TMF_d2_cn_2ef",
5312
  1, _nrrd_TMF_d2_cn_2ef_Sup, _nrrd_TMF_d2_cn_2ef_Int,
5313
  _nrrd_TMF_d2_cn_2ef_1_f,  _nrrd_TMF_d2_cn_2ef_N_f,
5314
  _nrrd_TMF_d2_cn_2ef_1_d,  _nrrd_TMF_d2_cn_2ef_N_d
5315
};
5316
5317
5318
/* ------------------------ TMF_d2_cn_3ef --------------------- */
5319
5320
static double _nrrd_TMF_d2_cn_3ef_Int(const double *parm) {
5321
  AIR_UNUSED(parm);
5322
4
  return 0.0;
5323
}
5324
5325
static double _nrrd_TMF_d2_cn_3ef_Sup(const double *parm) {
5326
  AIR_UNUSED(parm);
5327
4
  return 3;
5328
}
5329
5330
static double
5331
_nrrd_TMF_d2_cn_3ef_1_d(double x, const double *parm) {
5332
  int i;
5333
5334
5335
480024
  x += 3;
5336
240012
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
5337
240012
  x -= i;
5338



1320084
  return TMF_d2_cn_3ef(parm[0], i, x);
5339
}
5340
5341
static float
5342
_nrrd_TMF_d2_cn_3ef_1_f(float x, const double *parm) {
5343
  int i;
5344
5345
5346
480000
  x += 3;
5347
240000
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
5348
240000
  x -= AIR_CAST(float, i);
5349



1320000
  return AIR_CAST(float, TMF_d2_cn_3ef(parm[0], i, x));
5350
}
5351
5352
static void
5353
_nrrd_TMF_d2_cn_3ef_N_d(double *f, const double *x, size_t len, const double *parm) {
5354
  double t;
5355
  size_t I;
5356
  int i;
5357
5358
5359
480006
  for (I=0; I<len; I++) {
5360
240000
    t = x[I] + 3;
5361
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
5362
240000
    t -= i;
5363



1320000
    f[I] = TMF_d2_cn_3ef(parm[0], i, t);
5364
  }
5365
2
}
5366
5367
static void
5368
_nrrd_TMF_d2_cn_3ef_N_f(float *f, const float *x, size_t len, const double *parm) {
5369
  float t;
5370
  size_t I;
5371
  int i;
5372
5373
5374
480006
  for (I=0; I<len; I++) {
5375
240000
    t = x[I] + 3;
5376
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
5377
240000
    t -= AIR_CAST(float, i);
5378



1320000
    f[I] = AIR_CAST(float, TMF_d2_cn_3ef(parm[0], i, t));
5379
  }
5380
2
}
5381
5382
static NrrdKernel
5383
_nrrdKernel_TMF_d2_cn_3ef = {
5384
  "TMF_d2_cn_3ef",
5385
  1, _nrrd_TMF_d2_cn_3ef_Sup, _nrrd_TMF_d2_cn_3ef_Int,
5386
  _nrrd_TMF_d2_cn_3ef_1_f,  _nrrd_TMF_d2_cn_3ef_N_f,
5387
  _nrrd_TMF_d2_cn_3ef_1_d,  _nrrd_TMF_d2_cn_3ef_N_d
5388
};
5389
5390
5391
/* ------------------------ TMF_d2_cn_4ef --------------------- */
5392
5393
static double _nrrd_TMF_d2_cn_4ef_Int(const double *parm) {
5394
  AIR_UNUSED(parm);
5395
4
  return 0.0;
5396
}
5397
5398
static double _nrrd_TMF_d2_cn_4ef_Sup(const double *parm) {
5399
  AIR_UNUSED(parm);
5400
4
  return 3;
5401
}
5402
5403
static double
5404
_nrrd_TMF_d2_cn_4ef_1_d(double x, const double *parm) {
5405
  int i;
5406
5407
  AIR_UNUSED(parm); /* TMF_d2_cn_4ef */
5408
480024
  x += 3;
5409
240012
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
5410
240012
  x -= i;
5411



1320084
  return TMF_d2_cn_4ef(parm[0], i, x);
5412
}
5413
5414
static float
5415
_nrrd_TMF_d2_cn_4ef_1_f(float x, const double *parm) {
5416
  int i;
5417
5418
  AIR_UNUSED(parm); /* TMF_d2_cn_4ef */
5419
480000
  x += 3;
5420
240000
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
5421
240000
  x -= AIR_CAST(float, i);
5422



1320000
  return AIR_CAST(float, TMF_d2_cn_4ef(parm[0], i, x));
5423
}
5424
5425
static void
5426
_nrrd_TMF_d2_cn_4ef_N_d(double *f, const double *x, size_t len, const double *parm) {
5427
  double t;
5428
  size_t I;
5429
  int i;
5430
5431
  AIR_UNUSED(parm); /* TMF_d2_cn_4ef */
5432
480006
  for (I=0; I<len; I++) {
5433
240000
    t = x[I] + 3;
5434
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
5435
240000
    t -= i;
5436



1320000
    f[I] = TMF_d2_cn_4ef(parm[0], i, t);
5437
  }
5438
2
}
5439
5440
static void
5441
_nrrd_TMF_d2_cn_4ef_N_f(float *f, const float *x, size_t len, const double *parm) {
5442
  float t;
5443
  size_t I;
5444
  int i;
5445
5446
  AIR_UNUSED(parm); /* TMF_d2_cn_4ef */
5447
480006
  for (I=0; I<len; I++) {
5448
240000
    t = x[I] + 3;
5449
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
5450
240000
    t -= AIR_CAST(float, i);
5451



1320000
    f[I] = AIR_CAST(float, TMF_d2_cn_4ef(parm[0], i, t));
5452
  }
5453
2
}
5454
5455
static NrrdKernel
5456
_nrrdKernel_TMF_d2_cn_4ef = {
5457
  "TMF_d2_cn_4ef",
5458
  1, _nrrd_TMF_d2_cn_4ef_Sup, _nrrd_TMF_d2_cn_4ef_Int,
5459
  _nrrd_TMF_d2_cn_4ef_1_f,  _nrrd_TMF_d2_cn_4ef_N_f,
5460
  _nrrd_TMF_d2_cn_4ef_1_d,  _nrrd_TMF_d2_cn_4ef_N_d
5461
};
5462
5463
5464
/* ------------------------ TMF_d2_c0_1ef --------------------- */
5465
5466
static double _nrrd_TMF_d2_c0_1ef_Int(const double *parm) {
5467
  AIR_UNUSED(parm);
5468
4
  return 0.0;
5469
}
5470
5471
static double _nrrd_TMF_d2_c0_1ef_Sup(const double *parm) {
5472
  AIR_UNUSED(parm);
5473
4
  return 2;
5474
}
5475
5476
static double
5477
_nrrd_TMF_d2_c0_1ef_1_d(double x, const double *parm) {
5478
  int i;
5479
5480
  AIR_UNUSED(parm); /* TMF_d2_c0_1ef */
5481
480024
  x += 2;
5482
240012
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
5483
240012
  x -= i;
5484


1080060
  return TMF_d2_c0_1ef(parm[0], i, x);
5485
}
5486
5487
static float
5488
_nrrd_TMF_d2_c0_1ef_1_f(float x, const double *parm) {
5489
  int i;
5490
5491
  AIR_UNUSED(parm); /* TMF_d2_c0_1ef */
5492
480000
  x += 2;
5493
240000
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
5494
240000
  x -= AIR_CAST(float, i);
5495


1080000
  return AIR_CAST(float, TMF_d2_c0_1ef(parm[0], i, x));
5496
}
5497
5498
static void
5499
_nrrd_TMF_d2_c0_1ef_N_d(double *f, const double *x, size_t len, const double *parm) {
5500
  double t;
5501
  size_t I;
5502
  int i;
5503
5504
  AIR_UNUSED(parm); /* TMF_d2_c0_1ef */
5505
480006
  for (I=0; I<len; I++) {
5506
240000
    t = x[I] + 2;
5507
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
5508
240000
    t -= i;
5509


1080000
    f[I] = TMF_d2_c0_1ef(parm[0], i, t);
5510
  }
5511
2
}
5512
5513
static void
5514
_nrrd_TMF_d2_c0_1ef_N_f(float *f, const float *x, size_t len, const double *parm) {
5515
  float t;
5516
  size_t I;
5517
  int i;
5518
5519
  AIR_UNUSED(parm); /* TMF_d2_c0_1ef */
5520
480006
  for (I=0; I<len; I++) {
5521
240000
    t = x[I] + 2;
5522
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
5523
240000
    t -= AIR_CAST(float, i);
5524


1080000
    f[I] = AIR_CAST(float, TMF_d2_c0_1ef(parm[0], i, t));
5525
  }
5526
2
}
5527
5528
static NrrdKernel
5529
_nrrdKernel_TMF_d2_c0_1ef = {
5530
  "TMF_d2_c0_1ef",
5531
  1, _nrrd_TMF_d2_c0_1ef_Sup, _nrrd_TMF_d2_c0_1ef_Int,
5532
  _nrrd_TMF_d2_c0_1ef_1_f,  _nrrd_TMF_d2_c0_1ef_N_f,
5533
  _nrrd_TMF_d2_c0_1ef_1_d,  _nrrd_TMF_d2_c0_1ef_N_d
5534
};
5535
5536
5537
/* ------------------------ TMF_d2_c0_2ef --------------------- */
5538
5539
static double _nrrd_TMF_d2_c0_2ef_Int(const double *parm) {
5540
  AIR_UNUSED(parm);
5541
4
  return 0.0;
5542
}
5543
5544
static double _nrrd_TMF_d2_c0_2ef_Sup(const double *parm) {
5545
  AIR_UNUSED(parm);
5546
4
  return 2;
5547
}
5548
5549
static double
5550
_nrrd_TMF_d2_c0_2ef_1_d(double x, const double *parm) {
5551
  int i;
5552
5553
  AIR_UNUSED(parm); /* TMF_d2_c0_2ef */
5554
480024
  x += 2;
5555
240012
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
5556
240012
  x -= i;
5557


1080060
  return TMF_d2_c0_2ef(parm[0], i, x);
5558
}
5559
5560
static float
5561
_nrrd_TMF_d2_c0_2ef_1_f(float x, const double *parm) {
5562
  int i;
5563
5564
  AIR_UNUSED(parm); /* TMF_d2_c0_2ef */
5565
480000
  x += 2;
5566
240000
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
5567
240000
  x -= AIR_CAST(float, i);
5568


1080000
  return AIR_CAST(float, TMF_d2_c0_2ef(parm[0], i, x));
5569
}
5570
5571
static void
5572
_nrrd_TMF_d2_c0_2ef_N_d(double *f, const double *x, size_t len, const double *parm) {
5573
  double t;
5574
  size_t I;
5575
  int i;
5576
5577
  AIR_UNUSED(parm); /* TMF_d2_c0_2ef */
5578
480006
  for (I=0; I<len; I++) {
5579
240000
    t = x[I] + 2;
5580
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
5581
240000
    t -= i;
5582


1080000
    f[I] = TMF_d2_c0_2ef(parm[0], i, t);
5583
  }
5584
2
}
5585
5586
static void
5587
_nrrd_TMF_d2_c0_2ef_N_f(float *f, const float *x, size_t len, const double *parm) {
5588
  float t;
5589
  size_t I;
5590
  int i;
5591
5592
  AIR_UNUSED(parm); /* TMF_d2_c0_2ef */
5593
480006
  for (I=0; I<len; I++) {
5594
240000
    t = x[I] + 2;
5595
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
5596
240000
    t -= AIR_CAST(float, i);
5597


1080000
    f[I] = AIR_CAST(float, TMF_d2_c0_2ef(parm[0], i, t));
5598
  }
5599
2
}
5600
5601
static NrrdKernel
5602
_nrrdKernel_TMF_d2_c0_2ef = {
5603
  "TMF_d2_c0_2ef",
5604
  1, _nrrd_TMF_d2_c0_2ef_Sup, _nrrd_TMF_d2_c0_2ef_Int,
5605
  _nrrd_TMF_d2_c0_2ef_1_f,  _nrrd_TMF_d2_c0_2ef_N_f,
5606
  _nrrd_TMF_d2_c0_2ef_1_d,  _nrrd_TMF_d2_c0_2ef_N_d
5607
};
5608
5609
5610
/* ------------------------ TMF_d2_c0_3ef --------------------- */
5611
5612
static double _nrrd_TMF_d2_c0_3ef_Int(const double *parm) {
5613
  AIR_UNUSED(parm);
5614
4
  return 0.0;
5615
}
5616
5617
static double _nrrd_TMF_d2_c0_3ef_Sup(const double *parm) {
5618
  AIR_UNUSED(parm);
5619
4
  return 3;
5620
}
5621
5622
static double
5623
_nrrd_TMF_d2_c0_3ef_1_d(double x, const double *parm) {
5624
  int i;
5625
5626
  AIR_UNUSED(parm); /* TMF_d2_c0_3ef */
5627
480024
  x += 3;
5628
240012
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
5629
240012
  x -= i;
5630



1320084
  return TMF_d2_c0_3ef(parm[0], i, x);
5631
}
5632
5633
static float
5634
_nrrd_TMF_d2_c0_3ef_1_f(float x, const double *parm) {
5635
  int i;
5636
5637
  AIR_UNUSED(parm); /* TMF_d2_c0_3ef */
5638
480000
  x += 3;
5639
240000
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
5640
240000
  x -= AIR_CAST(float, i);
5641



1320000
  return AIR_CAST(float, TMF_d2_c0_3ef(parm[0], i, x));
5642
}
5643
5644
static void
5645
_nrrd_TMF_d2_c0_3ef_N_d(double *f, const double *x, size_t len, const double *parm) {
5646
  double t;
5647
  size_t I;
5648
  int i;
5649
5650
  AIR_UNUSED(parm); /* TMF_d2_c0_3ef */
5651
480006
  for (I=0; I<len; I++) {
5652
240000
    t = x[I] + 3;
5653
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
5654
240000
    t -= i;
5655



1320000
    f[I] = TMF_d2_c0_3ef(parm[0], i, t);
5656
  }
5657
2
}
5658
5659
static void
5660
_nrrd_TMF_d2_c0_3ef_N_f(float *f, const float *x, size_t len, const double *parm) {
5661
  float t;
5662
  size_t I;
5663
  int i;
5664
5665
  AIR_UNUSED(parm); /* TMF_d2_c0_3ef */
5666
480006
  for (I=0; I<len; I++) {
5667
240000
    t = x[I] + 3;
5668
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
5669
240000
    t -= AIR_CAST(float, i);
5670



1320000
    f[I] = AIR_CAST(float, TMF_d2_c0_3ef(parm[0], i, t));
5671
  }
5672
2
}
5673
5674
static NrrdKernel
5675
_nrrdKernel_TMF_d2_c0_3ef = {
5676
  "TMF_d2_c0_3ef",
5677
  1, _nrrd_TMF_d2_c0_3ef_Sup, _nrrd_TMF_d2_c0_3ef_Int,
5678
  _nrrd_TMF_d2_c0_3ef_1_f,  _nrrd_TMF_d2_c0_3ef_N_f,
5679
  _nrrd_TMF_d2_c0_3ef_1_d,  _nrrd_TMF_d2_c0_3ef_N_d
5680
};
5681
5682
5683
/* ------------------------ TMF_d2_c0_4ef --------------------- */
5684
5685
static double _nrrd_TMF_d2_c0_4ef_Int(const double *parm) {
5686
  AIR_UNUSED(parm);
5687
4
  return 0.0;
5688
}
5689
5690
static double _nrrd_TMF_d2_c0_4ef_Sup(const double *parm) {
5691
  AIR_UNUSED(parm);
5692
4
  return 3;
5693
}
5694
5695
static double
5696
_nrrd_TMF_d2_c0_4ef_1_d(double x, const double *parm) {
5697
  int i;
5698
5699
  AIR_UNUSED(parm); /* TMF_d2_c0_4ef */
5700
480024
  x += 3;
5701
240012
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
5702
240012
  x -= i;
5703



1320084
  return TMF_d2_c0_4ef(parm[0], i, x);
5704
}
5705
5706
static float
5707
_nrrd_TMF_d2_c0_4ef_1_f(float x, const double *parm) {
5708
  int i;
5709
5710
  AIR_UNUSED(parm); /* TMF_d2_c0_4ef */
5711
480000
  x += 3;
5712
240000
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
5713
240000
  x -= AIR_CAST(float, i);
5714



1320000
  return AIR_CAST(float, TMF_d2_c0_4ef(parm[0], i, x));
5715
}
5716
5717
static void
5718
_nrrd_TMF_d2_c0_4ef_N_d(double *f, const double *x, size_t len, const double *parm) {
5719
  double t;
5720
  size_t I;
5721
  int i;
5722
5723
  AIR_UNUSED(parm); /* TMF_d2_c0_4ef */
5724
480006
  for (I=0; I<len; I++) {
5725
240000
    t = x[I] + 3;
5726
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
5727
240000
    t -= i;
5728



1320000
    f[I] = TMF_d2_c0_4ef(parm[0], i, t);
5729
  }
5730
2
}
5731
5732
static void
5733
_nrrd_TMF_d2_c0_4ef_N_f(float *f, const float *x, size_t len, const double *parm) {
5734
  float t;
5735
  size_t I;
5736
  int i;
5737
5738
  AIR_UNUSED(parm); /* TMF_d2_c0_4ef */
5739
480006
  for (I=0; I<len; I++) {
5740
240000
    t = x[I] + 3;
5741
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
5742
240000
    t -= AIR_CAST(float, i);
5743



1320000
    f[I] = AIR_CAST(float, TMF_d2_c0_4ef(parm[0], i, t));
5744
  }
5745
2
}
5746
5747
static NrrdKernel
5748
_nrrdKernel_TMF_d2_c0_4ef = {
5749
  "TMF_d2_c0_4ef",
5750
  1, _nrrd_TMF_d2_c0_4ef_Sup, _nrrd_TMF_d2_c0_4ef_Int,
5751
  _nrrd_TMF_d2_c0_4ef_1_f,  _nrrd_TMF_d2_c0_4ef_N_f,
5752
  _nrrd_TMF_d2_c0_4ef_1_d,  _nrrd_TMF_d2_c0_4ef_N_d
5753
};
5754
5755
5756
/* ------------------------ TMF_d2_c1_1ef --------------------- */
5757
5758
static double _nrrd_TMF_d2_c1_1ef_Int(const double *parm) {
5759
  AIR_UNUSED(parm);
5760
4
  return 0.0;
5761
}
5762
5763
static double _nrrd_TMF_d2_c1_1ef_Sup(const double *parm) {
5764
  AIR_UNUSED(parm);
5765
4
  return 2;
5766
}
5767
5768
static double
5769
_nrrd_TMF_d2_c1_1ef_1_d(double x, const double *parm) {
5770
  int i;
5771
5772
  AIR_UNUSED(parm); /* TMF_d2_c1_1ef */
5773
480024
  x += 2;
5774
240012
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
5775
240012
  x -= i;
5776


1080060
  return TMF_d2_c1_1ef(parm[0], i, x);
5777
}
5778
5779
static float
5780
_nrrd_TMF_d2_c1_1ef_1_f(float x, const double *parm) {
5781
  int i;
5782
5783
  AIR_UNUSED(parm); /* TMF_d2_c1_1ef */
5784
480000
  x += 2;
5785
240000
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
5786
240000
  x -= AIR_CAST(float, i);
5787


1080000
  return AIR_CAST(float, TMF_d2_c1_1ef(parm[0], i, x));
5788
}
5789
5790
static void
5791
_nrrd_TMF_d2_c1_1ef_N_d(double *f, const double *x, size_t len, const double *parm) {
5792
  double t;
5793
  size_t I;
5794
  int i;
5795
5796
  AIR_UNUSED(parm); /* TMF_d2_c1_1ef */
5797
480006
  for (I=0; I<len; I++) {
5798
240000
    t = x[I] + 2;
5799
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
5800
240000
    t -= i;
5801


1080000
    f[I] = TMF_d2_c1_1ef(parm[0], i, t);
5802
  }
5803
2
}
5804
5805
static void
5806
_nrrd_TMF_d2_c1_1ef_N_f(float *f, const float *x, size_t len, const double *parm) {
5807
  float t;
5808
  size_t I;
5809
  int i;
5810
5811
  AIR_UNUSED(parm); /* TMF_d2_c1_1ef */
5812
480006
  for (I=0; I<len; I++) {
5813
240000
    t = x[I] + 2;
5814
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
5815
240000
    t -= AIR_CAST(float, i);
5816


1080000
    f[I] = AIR_CAST(float, TMF_d2_c1_1ef(parm[0], i, t));
5817
  }
5818
2
}
5819
5820
static NrrdKernel
5821
_nrrdKernel_TMF_d2_c1_1ef = {
5822
  "TMF_d2_c1_1ef",
5823
  1, _nrrd_TMF_d2_c1_1ef_Sup, _nrrd_TMF_d2_c1_1ef_Int,
5824
  _nrrd_TMF_d2_c1_1ef_1_f,  _nrrd_TMF_d2_c1_1ef_N_f,
5825
  _nrrd_TMF_d2_c1_1ef_1_d,  _nrrd_TMF_d2_c1_1ef_N_d
5826
};
5827
5828
5829
/* ------------------------ TMF_d2_c1_2ef --------------------- */
5830
5831
static double _nrrd_TMF_d2_c1_2ef_Int(const double *parm) {
5832
  AIR_UNUSED(parm);
5833
4
  return 0.0;
5834
}
5835
5836
static double _nrrd_TMF_d2_c1_2ef_Sup(const double *parm) {
5837
  AIR_UNUSED(parm);
5838
4
  return 3;
5839
}
5840
5841
static double
5842
_nrrd_TMF_d2_c1_2ef_1_d(double x, const double *parm) {
5843
  int i;
5844
5845
  AIR_UNUSED(parm); /* TMF_d2_c1_2ef */
5846
480024
  x += 3;
5847
240012
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
5848
240012
  x -= i;
5849



1320084
  return TMF_d2_c1_2ef(parm[0], i, x);
5850
}
5851
5852
static float
5853
_nrrd_TMF_d2_c1_2ef_1_f(float x, const double *parm) {
5854
  int i;
5855
5856
  AIR_UNUSED(parm); /* TMF_d2_c1_2ef */
5857
480000
  x += 3;
5858
240000
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
5859
240000
  x -= AIR_CAST(float, i);
5860



1320000
  return AIR_CAST(float, TMF_d2_c1_2ef(parm[0], i, x));
5861
}
5862
5863
static void
5864
_nrrd_TMF_d2_c1_2ef_N_d(double *f, const double *x, size_t len, const double *parm) {
5865
  double t;
5866
  size_t I;
5867
  int i;
5868
5869
  AIR_UNUSED(parm); /* TMF_d2_c1_2ef */
5870
480006
  for (I=0; I<len; I++) {
5871
240000
    t = x[I] + 3;
5872
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
5873
240000
    t -= i;
5874



1320000
    f[I] = TMF_d2_c1_2ef(parm[0], i, t);
5875
  }
5876
2
}
5877
5878
static void
5879
_nrrd_TMF_d2_c1_2ef_N_f(float *f, const float *x, size_t len, const double *parm) {
5880
  float t;
5881
  size_t I;
5882
  int i;
5883
5884
  AIR_UNUSED(parm); /* TMF_d2_c1_2ef */
5885
480006
  for (I=0; I<len; I++) {
5886
240000
    t = x[I] + 3;
5887
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
5888
240000
    t -= AIR_CAST(float, i);
5889



1320000
    f[I] = AIR_CAST(float, TMF_d2_c1_2ef(parm[0], i, t));
5890
  }
5891
2
}
5892
5893
static NrrdKernel
5894
_nrrdKernel_TMF_d2_c1_2ef = {
5895
  "TMF_d2_c1_2ef",
5896
  1, _nrrd_TMF_d2_c1_2ef_Sup, _nrrd_TMF_d2_c1_2ef_Int,
5897
  _nrrd_TMF_d2_c1_2ef_1_f,  _nrrd_TMF_d2_c1_2ef_N_f,
5898
  _nrrd_TMF_d2_c1_2ef_1_d,  _nrrd_TMF_d2_c1_2ef_N_d
5899
};
5900
5901
5902
/* ------------------------ TMF_d2_c1_3ef --------------------- */
5903
5904
static double _nrrd_TMF_d2_c1_3ef_Int(const double *parm) {
5905
  AIR_UNUSED(parm);
5906
4
  return 0.0;
5907
}
5908
5909
static double _nrrd_TMF_d2_c1_3ef_Sup(const double *parm) {
5910
  AIR_UNUSED(parm);
5911
4
  return 3;
5912
}
5913
5914
static double
5915
_nrrd_TMF_d2_c1_3ef_1_d(double x, const double *parm) {
5916
  int i;
5917
5918
  AIR_UNUSED(parm); /* TMF_d2_c1_3ef */
5919
480024
  x += 3;
5920
240012
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
5921
240012
  x -= i;
5922



1320084
  return TMF_d2_c1_3ef(parm[0], i, x);
5923
}
5924
5925
static float
5926
_nrrd_TMF_d2_c1_3ef_1_f(float x, const double *parm) {
5927
  int i;
5928
5929
  AIR_UNUSED(parm); /* TMF_d2_c1_3ef */
5930
480000
  x += 3;
5931
240000
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
5932
240000
  x -= AIR_CAST(float, i);
5933



1320000
  return AIR_CAST(float, TMF_d2_c1_3ef(parm[0], i, x));
5934
}
5935
5936
static void
5937
_nrrd_TMF_d2_c1_3ef_N_d(double *f, const double *x, size_t len, const double *parm) {
5938
  double t;
5939
  size_t I;
5940
  int i;
5941
5942
  AIR_UNUSED(parm); /* TMF_d2_c1_3ef */
5943
480006
  for (I=0; I<len; I++) {
5944
240000
    t = x[I] + 3;
5945
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
5946
240000
    t -= i;
5947



1320000
    f[I] = TMF_d2_c1_3ef(parm[0], i, t);
5948
  }
5949
2
}
5950
5951
static void
5952
_nrrd_TMF_d2_c1_3ef_N_f(float *f, const float *x, size_t len, const double *parm) {
5953
  float t;
5954
  size_t I;
5955
  int i;
5956
5957
  AIR_UNUSED(parm); /* TMF_d2_c1_3ef */
5958
480006
  for (I=0; I<len; I++) {
5959
240000
    t = x[I] + 3;
5960
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
5961
240000
    t -= AIR_CAST(float, i);
5962



1320000
    f[I] = AIR_CAST(float, TMF_d2_c1_3ef(parm[0], i, t));
5963
  }
5964
2
}
5965
5966
static NrrdKernel
5967
_nrrdKernel_TMF_d2_c1_3ef = {
5968
  "TMF_d2_c1_3ef",
5969
  1, _nrrd_TMF_d2_c1_3ef_Sup, _nrrd_TMF_d2_c1_3ef_Int,
5970
  _nrrd_TMF_d2_c1_3ef_1_f,  _nrrd_TMF_d2_c1_3ef_N_f,
5971
  _nrrd_TMF_d2_c1_3ef_1_d,  _nrrd_TMF_d2_c1_3ef_N_d
5972
};
5973
5974
5975
/* ------------------------ TMF_d2_c1_4ef --------------------- */
5976
5977
static double _nrrd_TMF_d2_c1_4ef_Int(const double *parm) {
5978
  AIR_UNUSED(parm);
5979
4
  return 0.0;
5980
}
5981
5982
static double _nrrd_TMF_d2_c1_4ef_Sup(const double *parm) {
5983
  AIR_UNUSED(parm);
5984
4
  return 4;
5985
}
5986
5987
static double
5988
_nrrd_TMF_d2_c1_4ef_1_d(double x, const double *parm) {
5989
  int i;
5990
5991
5992
480024
  x += 4;
5993
240012
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
5994
240012
  x -= i;
5995




1560108
  return TMF_d2_c1_4ef(parm[0], i, x);
5996
}
5997
5998
static float
5999
_nrrd_TMF_d2_c1_4ef_1_f(float x, const double *parm) {
6000
  int i;
6001
6002
6003
480000
  x += 4;
6004
240000
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
6005
240000
  x -= AIR_CAST(float, i);
6006




1560000
  return AIR_CAST(float, TMF_d2_c1_4ef(parm[0], i, x));
6007
}
6008
6009
static void
6010
_nrrd_TMF_d2_c1_4ef_N_d(double *f, const double *x, size_t len, const double *parm) {
6011
  double t;
6012
  size_t I;
6013
  int i;
6014
6015
6016
480006
  for (I=0; I<len; I++) {
6017
240000
    t = x[I] + 4;
6018
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
6019
240000
    t -= i;
6020




1560000
    f[I] = TMF_d2_c1_4ef(parm[0], i, t);
6021
  }
6022
2
}
6023
6024
static void
6025
_nrrd_TMF_d2_c1_4ef_N_f(float *f, const float *x, size_t len, const double *parm) {
6026
  float t;
6027
  size_t I;
6028
  int i;
6029
6030
6031
480006
  for (I=0; I<len; I++) {
6032
240000
    t = x[I] + 4;
6033
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
6034
240000
    t -= AIR_CAST(float, i);
6035




1560000
    f[I] = AIR_CAST(float, TMF_d2_c1_4ef(parm[0], i, t));
6036
  }
6037
2
}
6038
6039
static NrrdKernel
6040
_nrrdKernel_TMF_d2_c1_4ef = {
6041
  "TMF_d2_c1_4ef",
6042
  1, _nrrd_TMF_d2_c1_4ef_Sup, _nrrd_TMF_d2_c1_4ef_Int,
6043
  _nrrd_TMF_d2_c1_4ef_1_f,  _nrrd_TMF_d2_c1_4ef_N_f,
6044
  _nrrd_TMF_d2_c1_4ef_1_d,  _nrrd_TMF_d2_c1_4ef_N_d
6045
};
6046
6047
6048
/* ------------------------ TMF_d2_c2_1ef --------------------- */
6049
6050
static double _nrrd_TMF_d2_c2_1ef_Int(const double *parm) {
6051
  AIR_UNUSED(parm);
6052
4
  return 0.0;
6053
}
6054
6055
static double _nrrd_TMF_d2_c2_1ef_Sup(const double *parm) {
6056
  AIR_UNUSED(parm);
6057
4
  return 2;
6058
}
6059
6060
static double
6061
_nrrd_TMF_d2_c2_1ef_1_d(double x, const double *parm) {
6062
  int i;
6063
6064
  AIR_UNUSED(parm); /* TMF_d2_c2_1ef */
6065
480024
  x += 2;
6066
240012
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
6067
240012
  x -= i;
6068


1080060
  return TMF_d2_c2_1ef(parm[0], i, x);
6069
}
6070
6071
static float
6072
_nrrd_TMF_d2_c2_1ef_1_f(float x, const double *parm) {
6073
  int i;
6074
6075
  AIR_UNUSED(parm); /* TMF_d2_c2_1ef */
6076
480000
  x += 2;
6077
240000
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
6078
240000
  x -= AIR_CAST(float, i);
6079


1080000
  return AIR_CAST(float, TMF_d2_c2_1ef(parm[0], i, x));
6080
}
6081
6082
static void
6083
_nrrd_TMF_d2_c2_1ef_N_d(double *f, const double *x, size_t len, const double *parm) {
6084
  double t;
6085
  size_t I;
6086
  int i;
6087
6088
  AIR_UNUSED(parm); /* TMF_d2_c2_1ef */
6089
480006
  for (I=0; I<len; I++) {
6090
240000
    t = x[I] + 2;
6091
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
6092
240000
    t -= i;
6093


1080000
    f[I] = TMF_d2_c2_1ef(parm[0], i, t);
6094
  }
6095
2
}
6096
6097
static void
6098
_nrrd_TMF_d2_c2_1ef_N_f(float *f, const float *x, size_t len, const double *parm) {
6099
  float t;
6100
  size_t I;
6101
  int i;
6102
6103
  AIR_UNUSED(parm); /* TMF_d2_c2_1ef */
6104
480006
  for (I=0; I<len; I++) {
6105
240000
    t = x[I] + 2;
6106
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
6107
240000
    t -= AIR_CAST(float, i);
6108


1080000
    f[I] = AIR_CAST(float, TMF_d2_c2_1ef(parm[0], i, t));
6109
  }
6110
2
}
6111
6112
static NrrdKernel
6113
_nrrdKernel_TMF_d2_c2_1ef = {
6114
  "TMF_d2_c2_1ef",
6115
  1, _nrrd_TMF_d2_c2_1ef_Sup, _nrrd_TMF_d2_c2_1ef_Int,
6116
  _nrrd_TMF_d2_c2_1ef_1_f,  _nrrd_TMF_d2_c2_1ef_N_f,
6117
  _nrrd_TMF_d2_c2_1ef_1_d,  _nrrd_TMF_d2_c2_1ef_N_d
6118
};
6119
6120
6121
/* ------------------------ TMF_d2_c2_2ef --------------------- */
6122
6123
static double _nrrd_TMF_d2_c2_2ef_Int(const double *parm) {
6124
  AIR_UNUSED(parm);
6125
4
  return 0.0;
6126
}
6127
6128
static double _nrrd_TMF_d2_c2_2ef_Sup(const double *parm) {
6129
  AIR_UNUSED(parm);
6130
4
  return 3;
6131
}
6132
6133
static double
6134
_nrrd_TMF_d2_c2_2ef_1_d(double x, const double *parm) {
6135
  int i;
6136
6137
  AIR_UNUSED(parm); /* TMF_d2_c2_2ef */
6138
480024
  x += 3;
6139
240012
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
6140
240012
  x -= i;
6141



1320084
  return TMF_d2_c2_2ef(parm[0], i, x);
6142
}
6143
6144
static float
6145
_nrrd_TMF_d2_c2_2ef_1_f(float x, const double *parm) {
6146
  int i;
6147
6148
  AIR_UNUSED(parm); /* TMF_d2_c2_2ef */
6149
480000
  x += 3;
6150
240000
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
6151
240000
  x -= AIR_CAST(float, i);
6152



1320000
  return AIR_CAST(float, TMF_d2_c2_2ef(parm[0], i, x));
6153
}
6154
6155
static void
6156
_nrrd_TMF_d2_c2_2ef_N_d(double *f, const double *x, size_t len, const double *parm) {
6157
  double t;
6158
  size_t I;
6159
  int i;
6160
6161
  AIR_UNUSED(parm); /* TMF_d2_c2_2ef */
6162
480006
  for (I=0; I<len; I++) {
6163
240000
    t = x[I] + 3;
6164
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
6165
240000
    t -= i;
6166



1320000
    f[I] = TMF_d2_c2_2ef(parm[0], i, t);
6167
  }
6168
2
}
6169
6170
static void
6171
_nrrd_TMF_d2_c2_2ef_N_f(float *f, const float *x, size_t len, const double *parm) {
6172
  float t;
6173
  size_t I;
6174
  int i;
6175
6176
  AIR_UNUSED(parm); /* TMF_d2_c2_2ef */
6177
480006
  for (I=0; I<len; I++) {
6178
240000
    t = x[I] + 3;
6179
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
6180
240000
    t -= AIR_CAST(float, i);
6181



1320000
    f[I] = AIR_CAST(float, TMF_d2_c2_2ef(parm[0], i, t));
6182
  }
6183
2
}
6184
6185
static NrrdKernel
6186
_nrrdKernel_TMF_d2_c2_2ef = {
6187
  "TMF_d2_c2_2ef",
6188
  1, _nrrd_TMF_d2_c2_2ef_Sup, _nrrd_TMF_d2_c2_2ef_Int,
6189
  _nrrd_TMF_d2_c2_2ef_1_f,  _nrrd_TMF_d2_c2_2ef_N_f,
6190
  _nrrd_TMF_d2_c2_2ef_1_d,  _nrrd_TMF_d2_c2_2ef_N_d
6191
};
6192
6193
6194
/* ------------------------ TMF_d2_c2_3ef --------------------- */
6195
6196
static double _nrrd_TMF_d2_c2_3ef_Int(const double *parm) {
6197
  AIR_UNUSED(parm);
6198
4
  return 0.0;
6199
}
6200
6201
static double _nrrd_TMF_d2_c2_3ef_Sup(const double *parm) {
6202
  AIR_UNUSED(parm);
6203
4
  return 3;
6204
}
6205
6206
static double
6207
_nrrd_TMF_d2_c2_3ef_1_d(double x, const double *parm) {
6208
  int i;
6209
6210
  AIR_UNUSED(parm); /* TMF_d2_c2_3ef */
6211
480024
  x += 3;
6212
240012
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
6213
240012
  x -= i;
6214



1320084
  return TMF_d2_c2_3ef(parm[0], i, x);
6215
}
6216
6217
static float
6218
_nrrd_TMF_d2_c2_3ef_1_f(float x, const double *parm) {
6219
  int i;
6220
6221
  AIR_UNUSED(parm); /* TMF_d2_c2_3ef */
6222
480000
  x += 3;
6223
240000
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
6224
240000
  x -= AIR_CAST(float, i);
6225



1320000
  return AIR_CAST(float, TMF_d2_c2_3ef(parm[0], i, x));
6226
}
6227
6228
static void
6229
_nrrd_TMF_d2_c2_3ef_N_d(double *f, const double *x, size_t len, const double *parm) {
6230
  double t;
6231
  size_t I;
6232
  int i;
6233
6234
  AIR_UNUSED(parm); /* TMF_d2_c2_3ef */
6235
480006
  for (I=0; I<len; I++) {
6236
240000
    t = x[I] + 3;
6237
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
6238
240000
    t -= i;
6239



1320000
    f[I] = TMF_d2_c2_3ef(parm[0], i, t);
6240
  }
6241
2
}
6242
6243
static void
6244
_nrrd_TMF_d2_c2_3ef_N_f(float *f, const float *x, size_t len, const double *parm) {
6245
  float t;
6246
  size_t I;
6247
  int i;
6248
6249
  AIR_UNUSED(parm); /* TMF_d2_c2_3ef */
6250
480006
  for (I=0; I<len; I++) {
6251
240000
    t = x[I] + 3;
6252
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
6253
240000
    t -= AIR_CAST(float, i);
6254



1320000
    f[I] = AIR_CAST(float, TMF_d2_c2_3ef(parm[0], i, t));
6255
  }
6256
2
}
6257
6258
static NrrdKernel
6259
_nrrdKernel_TMF_d2_c2_3ef = {
6260
  "TMF_d2_c2_3ef",
6261
  1, _nrrd_TMF_d2_c2_3ef_Sup, _nrrd_TMF_d2_c2_3ef_Int,
6262
  _nrrd_TMF_d2_c2_3ef_1_f,  _nrrd_TMF_d2_c2_3ef_N_f,
6263
  _nrrd_TMF_d2_c2_3ef_1_d,  _nrrd_TMF_d2_c2_3ef_N_d
6264
};
6265
6266
6267
/* ------------------------ TMF_d2_c2_4ef --------------------- */
6268
6269
static double _nrrd_TMF_d2_c2_4ef_Int(const double *parm) {
6270
  AIR_UNUSED(parm);
6271
4
  return 0.0;
6272
}
6273
6274
static double _nrrd_TMF_d2_c2_4ef_Sup(const double *parm) {
6275
  AIR_UNUSED(parm);
6276
4
  return 4;
6277
}
6278
6279
static double
6280
_nrrd_TMF_d2_c2_4ef_1_d(double x, const double *parm) {
6281
  int i;
6282
6283
  AIR_UNUSED(parm); /* TMF_d2_c2_4ef */
6284
480024
  x += 4;
6285
240012
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
6286
240012
  x -= i;
6287




1560108
  return TMF_d2_c2_4ef(parm[0], i, x);
6288
}
6289
6290
static float
6291
_nrrd_TMF_d2_c2_4ef_1_f(float x, const double *parm) {
6292
  int i;
6293
6294
  AIR_UNUSED(parm); /* TMF_d2_c2_4ef */
6295
480000
  x += 4;
6296
240000
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
6297
240000
  x -= AIR_CAST(float, i);
6298




1560000
  return AIR_CAST(float, TMF_d2_c2_4ef(parm[0], i, x));
6299
}
6300
6301
static void
6302
_nrrd_TMF_d2_c2_4ef_N_d(double *f, const double *x, size_t len, const double *parm) {
6303
  double t;
6304
  size_t I;
6305
  int i;
6306
6307
  AIR_UNUSED(parm); /* TMF_d2_c2_4ef */
6308
480006
  for (I=0; I<len; I++) {
6309
240000
    t = x[I] + 4;
6310
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
6311
240000
    t -= i;
6312




1560000
    f[I] = TMF_d2_c2_4ef(parm[0], i, t);
6313
  }
6314
2
}
6315
6316
static void
6317
_nrrd_TMF_d2_c2_4ef_N_f(float *f, const float *x, size_t len, const double *parm) {
6318
  float t;
6319
  size_t I;
6320
  int i;
6321
6322
  AIR_UNUSED(parm); /* TMF_d2_c2_4ef */
6323
480006
  for (I=0; I<len; I++) {
6324
240000
    t = x[I] + 4;
6325
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
6326
240000
    t -= AIR_CAST(float, i);
6327




1560000
    f[I] = AIR_CAST(float, TMF_d2_c2_4ef(parm[0], i, t));
6328
  }
6329
2
}
6330
6331
static NrrdKernel
6332
_nrrdKernel_TMF_d2_c2_4ef = {
6333
  "TMF_d2_c2_4ef",
6334
  1, _nrrd_TMF_d2_c2_4ef_Sup, _nrrd_TMF_d2_c2_4ef_Int,
6335
  _nrrd_TMF_d2_c2_4ef_1_f,  _nrrd_TMF_d2_c2_4ef_N_f,
6336
  _nrrd_TMF_d2_c2_4ef_1_d,  _nrrd_TMF_d2_c2_4ef_N_d
6337
};
6338
6339
6340
/* ------------------------ TMF_d2_c3_1ef --------------------- */
6341
6342
static double _nrrd_TMF_d2_c3_1ef_Int(const double *parm) {
6343
  AIR_UNUSED(parm);
6344
4
  return 0.0;
6345
}
6346
6347
static double _nrrd_TMF_d2_c3_1ef_Sup(const double *parm) {
6348
  AIR_UNUSED(parm);
6349
4
  return 2;
6350
}
6351
6352
static double
6353
_nrrd_TMF_d2_c3_1ef_1_d(double x, const double *parm) {
6354
  int i;
6355
6356
  AIR_UNUSED(parm); /* TMF_d2_c3_1ef */
6357
480024
  x += 2;
6358
240012
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
6359
240012
  x -= i;
6360


1080060
  return TMF_d2_c3_1ef(parm[0], i, x);
6361
}
6362
6363
static float
6364
_nrrd_TMF_d2_c3_1ef_1_f(float x, const double *parm) {
6365
  int i;
6366
6367
  AIR_UNUSED(parm); /* TMF_d2_c3_1ef */
6368
480000
  x += 2;
6369
240000
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
6370
240000
  x -= AIR_CAST(float, i);
6371


1080000
  return AIR_CAST(float, TMF_d2_c3_1ef(parm[0], i, x));
6372
}
6373
6374
static void
6375
_nrrd_TMF_d2_c3_1ef_N_d(double *f, const double *x, size_t len, const double *parm) {
6376
  double t;
6377
  size_t I;
6378
  int i;
6379
6380
  AIR_UNUSED(parm); /* TMF_d2_c3_1ef */
6381
480006
  for (I=0; I<len; I++) {
6382
240000
    t = x[I] + 2;
6383
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
6384
240000
    t -= i;
6385


1080000
    f[I] = TMF_d2_c3_1ef(parm[0], i, t);
6386
  }
6387
2
}
6388
6389
static void
6390
_nrrd_TMF_d2_c3_1ef_N_f(float *f, const float *x, size_t len, const double *parm) {
6391
  float t;
6392
  size_t I;
6393
  int i;
6394
6395
  AIR_UNUSED(parm); /* TMF_d2_c3_1ef */
6396
480006
  for (I=0; I<len; I++) {
6397
240000
    t = x[I] + 2;
6398
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
6399
240000
    t -= AIR_CAST(float, i);
6400


1080000
    f[I] = AIR_CAST(float, TMF_d2_c3_1ef(parm[0], i, t));
6401
  }
6402
2
}
6403
6404
static NrrdKernel
6405
_nrrdKernel_TMF_d2_c3_1ef = {
6406
  "TMF_d2_c3_1ef",
6407
  1, _nrrd_TMF_d2_c3_1ef_Sup, _nrrd_TMF_d2_c3_1ef_Int,
6408
  _nrrd_TMF_d2_c3_1ef_1_f,  _nrrd_TMF_d2_c3_1ef_N_f,
6409
  _nrrd_TMF_d2_c3_1ef_1_d,  _nrrd_TMF_d2_c3_1ef_N_d
6410
};
6411
6412
6413
/* ------------------------ TMF_d2_c3_2ef --------------------- */
6414
6415
static double _nrrd_TMF_d2_c3_2ef_Int(const double *parm) {
6416
  AIR_UNUSED(parm);
6417
4
  return 0.0;
6418
}
6419
6420
static double _nrrd_TMF_d2_c3_2ef_Sup(const double *parm) {
6421
  AIR_UNUSED(parm);
6422
4
  return 3;
6423
}
6424
6425
static double
6426
_nrrd_TMF_d2_c3_2ef_1_d(double x, const double *parm) {
6427
  int i;
6428
6429
  AIR_UNUSED(parm); /* TMF_d2_c3_2ef */
6430
480024
  x += 3;
6431
240012
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
6432
240012
  x -= i;
6433



1320084
  return TMF_d2_c3_2ef(parm[0], i, x);
6434
}
6435
6436
static float
6437
_nrrd_TMF_d2_c3_2ef_1_f(float x, const double *parm) {
6438
  int i;
6439
6440
  AIR_UNUSED(parm); /* TMF_d2_c3_2ef */
6441
480000
  x += 3;
6442
240000
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
6443
240000
  x -= AIR_CAST(float, i);
6444



1320000
  return AIR_CAST(float, TMF_d2_c3_2ef(parm[0], i, x));
6445
}
6446
6447
static void
6448
_nrrd_TMF_d2_c3_2ef_N_d(double *f, const double *x, size_t len, const double *parm) {
6449
  double t;
6450
  size_t I;
6451
  int i;
6452
6453
  AIR_UNUSED(parm); /* TMF_d2_c3_2ef */
6454
480006
  for (I=0; I<len; I++) {
6455
240000
    t = x[I] + 3;
6456
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
6457
240000
    t -= i;
6458



1320000
    f[I] = TMF_d2_c3_2ef(parm[0], i, t);
6459
  }
6460
2
}
6461
6462
static void
6463
_nrrd_TMF_d2_c3_2ef_N_f(float *f, const float *x, size_t len, const double *parm) {
6464
  float t;
6465
  size_t I;
6466
  int i;
6467
6468
  AIR_UNUSED(parm); /* TMF_d2_c3_2ef */
6469
480006
  for (I=0; I<len; I++) {
6470
240000
    t = x[I] + 3;
6471
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
6472
240000
    t -= AIR_CAST(float, i);
6473



1320000
    f[I] = AIR_CAST(float, TMF_d2_c3_2ef(parm[0], i, t));
6474
  }
6475
2
}
6476
6477
static NrrdKernel
6478
_nrrdKernel_TMF_d2_c3_2ef = {
6479
  "TMF_d2_c3_2ef",
6480
  1, _nrrd_TMF_d2_c3_2ef_Sup, _nrrd_TMF_d2_c3_2ef_Int,
6481
  _nrrd_TMF_d2_c3_2ef_1_f,  _nrrd_TMF_d2_c3_2ef_N_f,
6482
  _nrrd_TMF_d2_c3_2ef_1_d,  _nrrd_TMF_d2_c3_2ef_N_d
6483
};
6484
6485
6486
/* ------------------------ TMF_d2_c3_3ef --------------------- */
6487
6488
static double _nrrd_TMF_d2_c3_3ef_Int(const double *parm) {
6489
  AIR_UNUSED(parm);
6490
4
  return 0.0;
6491
}
6492
6493
static double _nrrd_TMF_d2_c3_3ef_Sup(const double *parm) {
6494
  AIR_UNUSED(parm);
6495
4
  return 3;
6496
}
6497
6498
static double
6499
_nrrd_TMF_d2_c3_3ef_1_d(double x, const double *parm) {
6500
  int i;
6501
6502
  AIR_UNUSED(parm); /* TMF_d2_c3_3ef */
6503
480024
  x += 3;
6504
240012
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
6505
240012
  x -= i;
6506



1320084
  return TMF_d2_c3_3ef(parm[0], i, x);
6507
}
6508
6509
static float
6510
_nrrd_TMF_d2_c3_3ef_1_f(float x, const double *parm) {
6511
  int i;
6512
6513
  AIR_UNUSED(parm); /* TMF_d2_c3_3ef */
6514
480000
  x += 3;
6515
240000
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
6516
240000
  x -= AIR_CAST(float, i);
6517



1320000
  return AIR_CAST(float, TMF_d2_c3_3ef(parm[0], i, x));
6518
}
6519
6520
static void
6521
_nrrd_TMF_d2_c3_3ef_N_d(double *f, const double *x, size_t len, const double *parm) {
6522
  double t;
6523
  size_t I;
6524
  int i;
6525
6526
  AIR_UNUSED(parm); /* TMF_d2_c3_3ef */
6527
480006
  for (I=0; I<len; I++) {
6528
240000
    t = x[I] + 3;
6529
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
6530
240000
    t -= i;
6531



1320000
    f[I] = TMF_d2_c3_3ef(parm[0], i, t);
6532
  }
6533
2
}
6534
6535
static void
6536
_nrrd_TMF_d2_c3_3ef_N_f(float *f, const float *x, size_t len, const double *parm) {
6537
  float t;
6538
  size_t I;
6539
  int i;
6540
6541
  AIR_UNUSED(parm); /* TMF_d2_c3_3ef */
6542
480006
  for (I=0; I<len; I++) {
6543
240000
    t = x[I] + 3;
6544
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
6545
240000
    t -= AIR_CAST(float, i);
6546



1320000
    f[I] = AIR_CAST(float, TMF_d2_c3_3ef(parm[0], i, t));
6547
  }
6548
2
}
6549
6550
static NrrdKernel
6551
_nrrdKernel_TMF_d2_c3_3ef = {
6552
  "TMF_d2_c3_3ef",
6553
  1, _nrrd_TMF_d2_c3_3ef_Sup, _nrrd_TMF_d2_c3_3ef_Int,
6554
  _nrrd_TMF_d2_c3_3ef_1_f,  _nrrd_TMF_d2_c3_3ef_N_f,
6555
  _nrrd_TMF_d2_c3_3ef_1_d,  _nrrd_TMF_d2_c3_3ef_N_d
6556
};
6557
6558
6559
/* ------------------------ TMF_d2_c3_4ef --------------------- */
6560
6561
static double _nrrd_TMF_d2_c3_4ef_Int(const double *parm) {
6562
  AIR_UNUSED(parm);
6563
4
  return 0.0;
6564
}
6565
6566
static double _nrrd_TMF_d2_c3_4ef_Sup(const double *parm) {
6567
  AIR_UNUSED(parm);
6568
4
  return 4;
6569
}
6570
6571
static double
6572
_nrrd_TMF_d2_c3_4ef_1_d(double x, const double *parm) {
6573
  int i;
6574
6575
  AIR_UNUSED(parm); /* TMF_d2_c3_4ef */
6576
480024
  x += 4;
6577
240012
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
6578
240012
  x -= i;
6579




1560108
  return TMF_d2_c3_4ef(parm[0], i, x);
6580
}
6581
6582
static float
6583
_nrrd_TMF_d2_c3_4ef_1_f(float x, const double *parm) {
6584
  int i;
6585
6586
  AIR_UNUSED(parm); /* TMF_d2_c3_4ef */
6587
480000
  x += 4;
6588
240000
  i = (int)((x<0) ? x-1 : x); /* HEY scrutinize cast */
6589
240000
  x -= AIR_CAST(float, i);
6590




1560000
  return AIR_CAST(float, TMF_d2_c3_4ef(parm[0], i, x));
6591
}
6592
6593
static void
6594
_nrrd_TMF_d2_c3_4ef_N_d(double *f, const double *x, size_t len, const double *parm) {
6595
  double t;
6596
  size_t I;
6597
  int i;
6598
6599
  AIR_UNUSED(parm); /* TMF_d2_c3_4ef */
6600
480006
  for (I=0; I<len; I++) {
6601
240000
    t = x[I] + 4;
6602
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
6603
240000
    t -= i;
6604




1560000
    f[I] = TMF_d2_c3_4ef(parm[0], i, t);
6605
  }
6606
2
}
6607
6608
static void
6609
_nrrd_TMF_d2_c3_4ef_N_f(float *f, const float *x, size_t len, const double *parm) {
6610
  float t;
6611
  size_t I;
6612
  int i;
6613
6614
  AIR_UNUSED(parm); /* TMF_d2_c3_4ef */
6615
480006
  for (I=0; I<len; I++) {
6616
240000
    t = x[I] + 4;
6617
240000
    i = (int)((t<0) ? t-1 : t); /* HEY scrutinize cast */
6618
240000
    t -= AIR_CAST(float, i);
6619




1560000
    f[I] = AIR_CAST(float, TMF_d2_c3_4ef(parm[0], i, t));
6620
  }
6621
2
}
6622
6623
static NrrdKernel
6624
_nrrdKernel_TMF_d2_c3_4ef = {
6625
  "TMF_d2_c3_4ef",
6626
  1, _nrrd_TMF_d2_c3_4ef_Sup, _nrrd_TMF_d2_c3_4ef_Int,
6627
  _nrrd_TMF_d2_c3_4ef_1_f,  _nrrd_TMF_d2_c3_4ef_N_f,
6628
  _nrrd_TMF_d2_c3_4ef_1_d,  _nrrd_TMF_d2_c3_4ef_N_d
6629
};
6630
6631
6632
NrrdKernel *const
6633
nrrdKernelTMF[4][5][5] = {
6634
  {            /* d = n */
6635
    {
6636
       &_nrrdKernel_TMFBAD,
6637
       &_nrrdKernel_TMF_dn_cn_1ef,
6638
       &_nrrdKernel_TMF_dn_cn_2ef,
6639
       &_nrrdKernel_TMF_dn_cn_3ef,
6640
       &_nrrdKernel_TMF_dn_cn_4ef,
6641
    },
6642
    {
6643
       &_nrrdKernel_TMFBAD,
6644
       &_nrrdKernel_TMF_dn_c0_1ef,
6645
       &_nrrdKernel_TMF_dn_c0_2ef,
6646
       &_nrrdKernel_TMF_dn_c0_3ef,
6647
       &_nrrdKernel_TMF_dn_c0_4ef,
6648
    },
6649
    {
6650
       &_nrrdKernel_TMFBAD,
6651
       &_nrrdKernel_TMF_dn_c1_1ef,
6652
       &_nrrdKernel_TMF_dn_c1_2ef,
6653
       &_nrrdKernel_TMF_dn_c1_3ef,
6654
       &_nrrdKernel_TMF_dn_c1_4ef,
6655
    },
6656
    {
6657
       &_nrrdKernel_TMFBAD,
6658
       &_nrrdKernel_TMF_dn_c2_1ef,
6659
       &_nrrdKernel_TMF_dn_c2_2ef,
6660
       &_nrrdKernel_TMF_dn_c2_3ef,
6661
       &_nrrdKernel_TMF_dn_c2_4ef,
6662
    },
6663
    {
6664
       &_nrrdKernel_TMFBAD,
6665
       &_nrrdKernel_TMF_dn_c3_1ef,
6666
       &_nrrdKernel_TMF_dn_c3_2ef,
6667
       &_nrrdKernel_TMF_dn_c3_3ef,
6668
       &_nrrdKernel_TMF_dn_c3_4ef,
6669
    },
6670
  },
6671
  {            /* d = 0 */
6672
    {
6673
       &_nrrdKernel_TMFBAD,
6674
       &_nrrdKernel_TMF_d0_cn_1ef,
6675
       &_nrrdKernel_TMF_d0_cn_2ef,
6676
       &_nrrdKernel_TMF_d0_cn_3ef,
6677
       &_nrrdKernel_TMF_d0_cn_4ef,
6678
    },
6679
    {
6680
       &_nrrdKernel_TMFBAD,
6681
       &_nrrdKernel_TMF_d0_c0_1ef,
6682
       &_nrrdKernel_TMF_d0_c0_2ef,
6683
       &_nrrdKernel_TMF_d0_c0_3ef,
6684
       &_nrrdKernel_TMF_d0_c0_4ef,
6685
    },
6686
    {
6687
       &_nrrdKernel_TMFBAD,
6688
       &_nrrdKernel_TMF_d0_c1_1ef,
6689
       &_nrrdKernel_TMF_d0_c1_2ef,
6690
       &_nrrdKernel_TMF_d0_c1_3ef,
6691
       &_nrrdKernel_TMF_d0_c1_4ef,
6692
    },
6693
    {
6694
       &_nrrdKernel_TMFBAD,
6695
       &_nrrdKernel_TMF_d0_c2_1ef,
6696
       &_nrrdKernel_TMF_d0_c2_2ef,
6697
       &_nrrdKernel_TMF_d0_c2_3ef,
6698
       &_nrrdKernel_TMF_d0_c2_4ef,
6699
    },
6700
    {
6701
       &_nrrdKernel_TMFBAD,
6702
       &_nrrdKernel_TMF_d0_c3_1ef,
6703
       &_nrrdKernel_TMF_d0_c3_2ef,
6704
       &_nrrdKernel_TMF_d0_c3_3ef,
6705
       &_nrrdKernel_TMF_d0_c3_4ef,
6706
    },
6707
  },
6708
  {            /* d = 1 */
6709
    {
6710
       &_nrrdKernel_TMFBAD,
6711
       &_nrrdKernel_TMF_d1_cn_1ef,
6712
       &_nrrdKernel_TMF_d1_cn_2ef,
6713
       &_nrrdKernel_TMF_d1_cn_3ef,
6714
       &_nrrdKernel_TMF_d1_cn_4ef,
6715
    },
6716
    {
6717
       &_nrrdKernel_TMFBAD,
6718
       &_nrrdKernel_TMF_d1_c0_1ef,
6719
       &_nrrdKernel_TMF_d1_c0_2ef,
6720
       &_nrrdKernel_TMF_d1_c0_3ef,
6721
       &_nrrdKernel_TMF_d1_c0_4ef,
6722
    },
6723
    {
6724
       &_nrrdKernel_TMFBAD,
6725
       &_nrrdKernel_TMF_d1_c1_1ef,
6726
       &_nrrdKernel_TMF_d1_c1_2ef,
6727
       &_nrrdKernel_TMF_d1_c1_3ef,
6728
       &_nrrdKernel_TMF_d1_c1_4ef,
6729
    },
6730
    {
6731
       &_nrrdKernel_TMFBAD,
6732
       &_nrrdKernel_TMF_d1_c2_1ef,
6733
       &_nrrdKernel_TMF_d1_c2_2ef,
6734
       &_nrrdKernel_TMF_d1_c2_3ef,
6735
       &_nrrdKernel_TMF_d1_c2_4ef,
6736
    },
6737
    {
6738
       &_nrrdKernel_TMFBAD,
6739
       &_nrrdKernel_TMF_d1_c3_1ef,
6740
       &_nrrdKernel_TMF_d1_c3_2ef,
6741
       &_nrrdKernel_TMF_d1_c3_3ef,
6742
       &_nrrdKernel_TMF_d1_c3_4ef,
6743
    },
6744
  },
6745
  {            /* d = 2 */
6746
    {
6747
       &_nrrdKernel_TMFBAD,
6748
       &_nrrdKernel_TMF_d2_cn_1ef,
6749
       &_nrrdKernel_TMF_d2_cn_2ef,
6750
       &_nrrdKernel_TMF_d2_cn_3ef,
6751
       &_nrrdKernel_TMF_d2_cn_4ef,
6752
    },
6753
    {
6754
       &_nrrdKernel_TMFBAD,
6755
       &_nrrdKernel_TMF_d2_c0_1ef,
6756
       &_nrrdKernel_TMF_d2_c0_2ef,
6757
       &_nrrdKernel_TMF_d2_c0_3ef,
6758
       &_nrrdKernel_TMF_d2_c0_4ef,
6759
    },
6760
    {
6761
       &_nrrdKernel_TMFBAD,
6762
       &_nrrdKernel_TMF_d2_c1_1ef,
6763
       &_nrrdKernel_TMF_d2_c1_2ef,
6764
       &_nrrdKernel_TMF_d2_c1_3ef,
6765
       &_nrrdKernel_TMF_d2_c1_4ef,
6766
    },
6767
    {
6768
       &_nrrdKernel_TMFBAD,
6769
       &_nrrdKernel_TMF_d2_c2_1ef,
6770
       &_nrrdKernel_TMF_d2_c2_2ef,
6771
       &_nrrdKernel_TMF_d2_c2_3ef,
6772
       &_nrrdKernel_TMF_d2_c2_4ef,
6773
    },
6774
    {
6775
       &_nrrdKernel_TMFBAD,
6776
       &_nrrdKernel_TMF_d2_c3_1ef,
6777
       &_nrrdKernel_TMF_d2_c3_2ef,
6778
       &_nrrdKernel_TMF_d2_c3_3ef,
6779
       &_nrrdKernel_TMF_d2_c3_4ef,
6780
    },
6781
  },
6782
};
6783
6784
const unsigned int nrrdKernelTMF_maxD = 2;
6785
const unsigned int nrrdKernelTMF_maxC = 3;
6786
const unsigned int nrrdKernelTMF_maxA = 4;