|
|
1 # ifndef FUNCDEF
2 # include "kfun.h"
3 # endif
4
5
6 # ifdef FUNCDEF
7 FUNCDEF("fabs", kf_fabs, pt_fabs)
8 # else
9 char pt_fabs[] = { C_TYPECHECKED | C_STATIC, T_FLOAT, 1, T_FLOAT };
10
11 /*
12 * NAME: kfun->fabs()
13 * DESCRIPTION: return the absolute value of a float
14 */
15 int kf_fabs(f)
16 frame *f;
17 {
18 xfloat flt;
19
20 i_add_ticks(f, 1);
21 GET_FLT(f->sp, flt);
22 FLT_ABS(flt.high, flt.low);
23 PUT_FLT(f->sp, flt);
24 return 0;
25 }
26 # endif
27
28
29 # ifdef FUNCDEF
30 FUNCDEF("floor", kf_floor, pt_floor)
31 # else
32 char pt_floor[] = { C_TYPECHECKED | C_STATIC, T_FLOAT, 1, T_FLOAT };
33
34 /*
35 * NAME: kfun->floor()
36 * DESCRIPTION: round the argument downwards
37 */
38 int kf_floor(f)
39 register frame *f;
40 {
41 xfloat flt;
42
43 i_add_ticks(f, 1);
44 GET_FLT(f->sp, flt);
45 flt_floor(&flt);
46 PUT_FLT(f->sp, flt);
47 return 0;
48 }
49 # endif
50
51
52 # ifdef FUNCDEF
53 FUNCDEF("ceil", kf_ceil, pt_ceil)
54 # else
55 char pt_ceil[] = { C_TYPECHECKED | C_STATIC, T_FLOAT, 1, T_FLOAT };
56
57 /*
58 * NAME: kfun->ceil()
59 * DESCRIPTION: round the argument upwards
60 */
61 int kf_ceil(f)
62 register frame *f;
63 {
64 xfloat flt;
65
66 i_add_ticks(f, 1);
67 GET_FLT(f->sp, flt);
68 flt_ceil(&flt);
69 PUT_FLT(f->sp, flt);
70 return 0;
71 }
72 # endif
73
74
75 # ifdef FUNCDEF
76 FUNCDEF("fmod", kf_fmod, pt_fmod)
77 # else
78 char pt_fmod[] = { C_TYPECHECKED | C_STATIC, T_FLOAT, 2, T_FLOAT, T_FLOAT };
79
80 /*
81 * NAME: kfun->fmod()
82 * DESCRIPTION: compute fmod
83 */
84 int kf_fmod(f)
85 register frame *f;
86 {
87 xfloat f1, f2;
88
89 i_add_ticks(f, 1);
90 GET_FLT(f->sp, f2);
91 f->sp++;
92 GET_FLT(f->sp, f1);
93 flt_fmod(&f1, &f2);
94 PUT_FLT(f->sp, f1);
95 return 0;
96 }
97 # endif
98
99
100 # ifdef FUNCDEF
101 FUNCDEF("frexp", kf_frexp, pt_frexp)
102 # else
103 char pt_frexp[] = { C_TYPECHECKED | C_STATIC, (1 << REFSHIFT) | T_MIXED, 1,
104 T_FLOAT };
105
106 /*
107 * NAME: kfun->frexp()
108 * DESCRIPTION: split a float into a fraction and an exponent
109 */
110 int kf_frexp(f)
111 register frame *f;
112 {
113 xfloat flt;
114 Int num;
115 array *a;
116
117 i_add_ticks(f, 2);
118 GET_FLT(f->sp, flt);
119 num = flt_frexp(&flt);
120 a = arr_new(f->data, 2L);
121 PUT_FLTVAL(&a->elts[0], flt);
122 PUT_INTVAL(&a->elts[1], num);
123 PUT_ARRVAL(f->sp, a);
124
125 return 0;
126 }
127 # endif
128
129
130 # ifdef FUNCDEF
131 FUNCDEF("ldexp", kf_ldexp, pt_ldexp)
132 # else
133 char pt_ldexp[] = { C_TYPECHECKED | C_STATIC, T_FLOAT, 2, T_FLOAT, T_INT };
134
135 /*
136 * NAME: kfun->ldexp()
137 * DESCRIPTION: make a float from a fraction and an exponent
138 */
139 int kf_ldexp(f)
140 register frame *f;
141 {
142 xfloat flt;
143
144 i_add_ticks(f, 1);
145 GET_FLT(f->sp + 1, flt);
146 flt_ldexp(&flt, f->sp->u.number);
147 f->sp++;
148 PUT_FLT(f->sp, flt);
149 return 0;
150 }
151 # endif
152
153
154 # ifdef FUNCDEF
155 FUNCDEF("modf", kf_modf, pt_modf)
156 # else
157 char pt_modf[] = { C_TYPECHECKED | C_STATIC, (1 << REFSHIFT) | T_FLOAT, 1,
158 T_FLOAT };
159
160 /*
161 * NAME: kfun->modf()
162 * DESCRIPTION: split float into fraction and integer part
163 */
164 int kf_modf(f)
165 register frame *f;
166 {
167 xfloat f1, f2;
168 array *a;
169
170 i_add_ticks(f, 2);
171 GET_FLT(f->sp, f1);
172 flt_modf(&f1, &f2);
173 a = arr_new(f->data, 2L);
174 PUT_FLTVAL(&a->elts[0], f1);
175 PUT_FLTVAL(&a->elts[1], f2);
176 PUT_ARRVAL(f->sp, a);
177
178 return 0;
179 }
180 # endif
181
182
183 # ifdef FUNCDEF
184 FUNCDEF("exp", kf_exp, pt_exp)
185 # else
186 char pt_exp[] = { C_TYPECHECKED | C_STATIC, T_FLOAT, 1, T_FLOAT };
187
188 /*
189 * NAME: kfun->exp()
190 * DESCRIPTION: compute exp
191 */
192 int kf_exp(f)
193 register frame *f;
194 {
195 xfloat flt;
196
197 i_add_ticks(f, 21);
198 GET_FLT(f->sp, flt);
199 flt_exp(&flt);
200 PUT_FLT(f->sp, flt);
201 return 0;
202 }
203 # endif
204
205
206 # ifdef FUNCDEF
207 FUNCDEF("log", kf_log, pt_log)
208 # else
209 char pt_log[] = { C_TYPECHECKED | C_STATIC, T_FLOAT, 1, T_FLOAT };
210
211 /*
212 * NAME: kfun->log()
213 * DESCRIPTION: compute log
214 */
215 int kf_log(f)
216 register frame *f;
217 {
218 xfloat flt;
219
220 i_add_ticks(f, 35);
221 GET_FLT(f->sp, flt);
222 flt_log(&flt);
223 PUT_FLT(f->sp, flt);
224 return 0;
225 }
226 # endif
227
228
229 # ifdef FUNCDEF
230 FUNCDEF("log10", kf_log10, pt_log10)
231 # else
232 char pt_log10[] = { C_TYPECHECKED | C_STATIC, T_FLOAT, 1, T_FLOAT };
233
234 /*
235 * NAME: kfun->log10()
236 * DESCRIPTION: compute log10
237 */
238 int kf_log10(f)
239 register frame *f;
240 {
241 xfloat flt;
242
243 i_add_ticks(f, 41);
244 GET_FLT(f->sp, flt);
245 flt_log10(&flt);
246 PUT_FLT(f->sp, flt);
247 return 0;
248 }
249 # endif
250
251
252 # ifdef FUNCDEF
253 FUNCDEF("pow", kf_pow, pt_pow)
254 # else
255 char pt_pow[] = { C_TYPECHECKED | C_STATIC, T_FLOAT, 2, T_FLOAT, T_FLOAT };
256
257 /*
258 * NAME: kfun->pow()
259 * DESCRIPTION: compute pow
260 */
261 int kf_pow(f)
262 register frame *f;
263 {
264 xfloat f1, f2;
265
266 i_add_ticks(f, 48);
267 GET_FLT(f->sp, f2);
268 f->sp++;
269 GET_FLT(f->sp, f1);
270 flt_pow(&f1, &f2);
271 PUT_FLT(f->sp, f1);
272 return 0;
273 }
274 # endif
275
276
277 # ifdef FUNCDEF
278 FUNCDEF("sqrt", kf_sqrt, pt_sqrt)
279 # else
280 char pt_sqrt[] = { C_TYPECHECKED | C_STATIC, T_FLOAT, 1, T_FLOAT };
281
282 /*
283 * NAME: kfun->sqrt()
284 * DESCRIPTION: compute sqrt
285 */
286 int kf_sqrt(f)
287 register frame *f;
288 {
289 xfloat flt;
290
291 i_add_ticks(f, 11);
292 GET_FLT(f->sp, flt);
293 flt_sqrt(&flt);
294 PUT_FLT(f->sp, flt);
295 return 0;
296 }
297 # endif
298
299
300 # ifdef FUNCDEF
301 FUNCDEF("cos", kf_cos, pt_cos)
302 # else
303 char pt_cos[] = { C_TYPECHECKED | C_STATIC, T_FLOAT, 1, T_FLOAT };
304
305 /*
306 * NAME: kfun->cos()
307 * DESCRIPTION: compute cos
308 */
309 int kf_cos(f)
310 register frame *f;
311 {
312 xfloat flt;
313
314 i_add_ticks(f, 25);
315 GET_FLT(f->sp, flt);
316 flt_cos(&flt);
317 PUT_FLT(f->sp, flt);
318 return 0;
319 }
320 # endif
321
322
323 # ifdef FUNCDEF
324 FUNCDEF("sin", kf_sin, pt_sin)
325 # else
326 char pt_sin[] = { C_TYPECHECKED | C_STATIC, T_FLOAT, 1, T_FLOAT };
327
328 /*
329 * NAME: kfun->sin()
330 * DESCRIPTION: compute sin
331 */
332 int kf_sin(f)
333 register frame *f;
334 {
335 xfloat flt;
336
337 i_add_ticks(f, 25);
338 GET_FLT(f->sp, flt);
339 flt_sin(&flt);
340 PUT_FLT(f->sp, flt);
341 return 0;
342 }
343 # endif
344
345
346 # ifdef FUNCDEF
347 FUNCDEF("tan", kf_tan, pt_tan)
348 # else
349 char pt_tan[] = { C_TYPECHECKED | C_STATIC, T_FLOAT, 1, T_FLOAT };
350
351 /*
352 * NAME: kfun->tan()
353 * DESCRIPTION: compute tan
354 */
355 int kf_tan(f)
356 register frame *f;
357 {
358 xfloat flt;
359
360 i_add_ticks(f, 31);
361 GET_FLT(f->sp, flt);
362 flt_tan(&flt);
363 PUT_FLT(f->sp, flt);
364 return 0;
365 }
366 # endif
367
368
369 # ifdef FUNCDEF
370 FUNCDEF("acos", kf_acos, pt_acos)
371 # else
372 char pt_acos[] = { C_TYPECHECKED | C_STATIC, T_FLOAT, 1, T_FLOAT };
373
374 /*
375 * NAME: kfun->acos()
376 * DESCRIPTION: compute acos
377 */
378 int kf_acos(f)
379 register frame *f;
380 {
381 xfloat flt;
382
383 i_add_ticks(f, 24);
384 GET_FLT(f->sp, flt);
385 flt_acos(&flt);
386 PUT_FLT(f->sp, flt);
387 return 0;
388 }
389 # endif
390
391
392 # ifdef FUNCDEF
393 FUNCDEF("asin", kf_asin, pt_asin)
394 # else
395 char pt_asin[] = { C_TYPECHECKED | C_STATIC, T_FLOAT, 1, T_FLOAT };
396
397 /*
398 * NAME: kfun->asin()
399 * DESCRIPTION: compute asin
400 */
401 int kf_asin(f)
402 register frame *f;
403 {
404 xfloat flt;
405
406 i_add_ticks(f, 24);
407 GET_FLT(f->sp, flt);
408 flt_asin(&flt);
409 PUT_FLT(f->sp, flt);
410 return 0;
411 }
412 # endif
413
414
415 # ifdef FUNCDEF
416 FUNCDEF("atan", kf_atan, pt_atan)
417 # else
418 char pt_atan[] = { C_TYPECHECKED | C_STATIC, T_FLOAT, 1, T_FLOAT };
419
420 /*
421 * NAME: kfun->atan()
422 * DESCRIPTION: compute atan
423 */
424 int kf_atan(f)
425 register frame *f;
426 {
427 xfloat flt;
428
429 i_add_ticks(f, 24);
430 GET_FLT(f->sp, flt);
431 flt_atan(&flt);
432 PUT_FLT(f->sp, flt);
433 return 0;
434 }
435 # endif
436
437
438 # ifdef FUNCDEF
439 FUNCDEF("atan2", kf_atan2, pt_atan2)
440 # else
441 char pt_atan2[] = { C_TYPECHECKED | C_STATIC, T_FLOAT, 2, T_FLOAT, T_FLOAT };
442
443 /*
444 * NAME: kfun->atan2()
445 * DESCRIPTION: compute atan2
446 */
447 int kf_atan2(f)
448 register frame *f;
449 {
450 xfloat f1, f2;
451
452 i_add_ticks(f, 27);
453 GET_FLT(f->sp, f2);
454 f->sp++;
455 GET_FLT(f->sp, f1);
456 flt_atan2(&f1, &f2);
457 PUT_FLT(f->sp, f1);
458 return 0;
459 }
460 # endif
461
462
463 # ifdef FUNCDEF
464 FUNCDEF("cosh", kf_cosh, pt_cosh)
465 # else
466 char pt_cosh[] = { C_TYPECHECKED | C_STATIC, T_FLOAT, 1, T_FLOAT };
467
468 /*
469 * NAME: kfun->cosh()
470 * DESCRIPTION: compute cosh
471 */
472 int kf_cosh(f)
473 register frame *f;
474 {
475 xfloat flt;
476
477 i_add_ticks(f, 24);
478 GET_FLT(f->sp, flt);
479 flt_cosh(&flt);
480 PUT_FLT(f->sp, flt);
481 return 0;
482 }
483 # endif
484
485
486 # ifdef FUNCDEF
487 FUNCDEF("sinh", kf_sinh, pt_sinh)
488 # else
489 char pt_sinh[] = { C_TYPECHECKED | C_STATIC, T_FLOAT, 1, T_FLOAT };
490
491 /*
492 * NAME: kfun->sinh()
493 * DESCRIPTION: compute sinh
494 */
495 int kf_sinh(f)
496 register frame *f;
497 {
498 xfloat flt;
499
500 i_add_ticks(f, 24);
501 GET_FLT(f->sp, flt);
502 flt_sinh(&flt);
503 PUT_FLT(f->sp, flt);
504 return 0;
505 }
506 # endif
507
508
509 # ifdef FUNCDEF
510 FUNCDEF("tanh", kf_tanh, pt_tanh)
511 # else
512 char pt_tanh[] = { C_TYPECHECKED | C_STATIC, T_FLOAT, 1, T_FLOAT };
513
514 /*
515 * NAME: kfun->tanh()
516 * DESCRIPTION: compute tanh
517 */
518 int kf_tanh(f)
519 register frame *f;
520 {
521 xfloat flt;
522
523 i_add_ticks(f, 24);
524 GET_FLT(f->sp, flt);
525 flt_tanh(&flt);
526 PUT_FLT(f->sp, flt);
527 return 0;
528 }
529 # endif
530
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.