ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/Development/ray/src/common/calfunc.c

Comparing ray/src/common/calfunc.c (file contents):
Revision 1.2 by greg, Tue Jun 26 09:15:13 1990 UTC vs.
Revision 2.12 by schorsch, Thu Jul 17 09:21:29 2003 UTC

#	Line 1 | Line 1
1	–	/* Copyright (c) 1986 Regents of the University of California */
2	–
1		#ifndef lint
2	<	static char SCCSid[] = "$SunId$ LBL";
2	>	static const char       RCSid[] = "$Id$";
3		#endif
6	–
4		/*
5		*  calfunc.c - routines for calcomp using functions.
6		*
7	<	*      The define BIGLIB pulls in a large number of the
11	<	*  available math routines.
12	<	*
13	<	*      If VARIABLE is not defined, only library functions
7	>	*      If VARIABLE is not set, only library functions
8		*  can be accessed.
9		*
10	<	*     4/2/86
10	>	*  2/19/03     Eliminated conditional compiles in favor of esupport extern.
11		*/
12
13	<	#include  <stdio.h>
13	>	#include "copyright.h"
14
15	+	#include  <stdio.h>
16	+	#include  <string.h>
17		#include  <errno.h>
18	+	#include  <math.h>
19
20	+	#include  "rterror.h"
21		#include  "calcomp.h"
22
23	<
23	>	/* bits in argument flag (better be right!) */
24	>	#define  AFLAGSIZ       (8*sizeof(unsigned long))
25		#define  ALISTSIZ       6       /* maximum saved argument list */
26
27		typedef struct activation {
#	Line 35 | Line 34 | typedef struct activation {
34
35		static ACTIVATION  *curact = NULL;
36
37	<	static double  libfunc();
37	>	static double  libfunc(char *fname, VARDEF *vp);
38
39	+	#ifndef  MAXLIB
40		#define  MAXLIB         64      /* maximum number of library functions */
41	+	#endif
42
43		static double  l_if(), l_select(), l_rand();
44		static double  l_floor(), l_ceil();
44	–	#ifdef  BIGLIB
45		static double  l_sqrt();
46		static double  l_sin(), l_cos(), l_tan();
47		static double  l_asin(), l_acos(), l_atan(), l_atan2();
48		static double  l_exp(), l_log(), l_log10();
49	–	#endif
49
51	–	#ifdef  BIGLIB
50		/* functions must be listed alphabetically */
51		static LIBR  library[MAXLIB] = {
52	<	{ "acos", 1, l_acos },
53	<	{ "asin", 1, l_asin },
54	<	{ "atan", 1, l_atan },
55	<	{ "atan2", 2, l_atan2 },
56	<	{ "ceil", 1, l_ceil },
57	<	{ "cos", 1, l_cos },
58	<	{ "exp", 1, l_exp },
59	<	{ "floor", 1, l_floor },
60	<	{ "if", 3, l_if },
61	<	{ "log", 1, l_log },
62	<	{ "log10", 1, l_log10 },
63	<	{ "rand", 1, l_rand },
64	<	{ "select", 1, l_select },
65	<	{ "sin", 1, l_sin },
66	<	{ "sqrt", 1, l_sqrt },
67	<	{ "tan", 1, l_tan },
52	>	{ "acos", 1, ':', l_acos },
53	>	{ "asin", 1, ':', l_asin },
54	>	{ "atan", 1, ':', l_atan },
55	>	{ "atan2", 2, ':', l_atan2 },
56	>	{ "ceil", 1, ':', l_ceil },
57	>	{ "cos", 1, ':', l_cos },
58	>	{ "exp", 1, ':', l_exp },
59	>	{ "floor", 1, ':', l_floor },
60	>	{ "if", 3, ':', l_if },
61	>	{ "log", 1, ':', l_log },
62	>	{ "log10", 1, ':', l_log10 },
63	>	{ "rand", 1, ':', l_rand },
64	>	{ "select", 1, ':', l_select },
65	>	{ "sin", 1, ':', l_sin },
66	>	{ "sqrt", 1, ':', l_sqrt },
67	>	{ "tan", 1, ':', l_tan },
68		};
69
70		static int  libsize = 16;
71
74	–	#else
75	–	/* functions must be listed alphabetically */
76	–	static LIBR  library[MAXLIB] = {
77	–	{ "ceil", 1, l_ceil },
78	–	{ "floor", 1, l_floor },
79	–	{ "if", 3, l_if },
80	–	{ "rand", 1, l_rand },
81	–	{ "select", 1, l_select },
82	–	};
83	–
84	–	static int  libsize = 5;
85	–
86	–	#endif
87	–
88	–	extern char  *savestr(), *emalloc();
89	–
90	–	extern LIBR  *liblookup();
91	–
92	–	extern VARDEF  *argf();
93	–
94	–	#ifdef  VARIABLE
72		#define  resolve(ep)    ((ep)->type==VAR?(ep)->v.ln:argf((ep)->v.chan))
96	–	#else
97	–	#define  resolve(ep)    ((ep)->v.ln)
98	–	#define varlookup(name) NULL
99	–	#endif
73
74
75		int
76		fundefined(fname)               /* return # of arguments for function */
77		char  *fname;
78		{
79	<	LIBR  *lp;
79	>	register LIBR  *lp;
80		register VARDEF  *vp;
81
82	<	if ((vp = varlookup(fname)) == NULL || vp->def == NULL
83	<	|| vp->def->v.kid->type != FUNC)
111	<	if ((lp = liblookup(fname)) == NULL)
112	<	return(0);
113	<	else
114	<	return(lp->nargs);
115	<	else
82	>	if ((vp = varlookup(fname)) != NULL && vp->def != NULL
83	>	&& vp->def->v.kid->type == FUNC)
84		return(nekids(vp->def->v.kid) - 1);
85	+	lp = vp != NULL ? vp->lib : liblookup(fname);
86	+	if (lp == NULL)
87	+	return(0);
88	+	return(lp->nargs);
89		}
90
91
#	Line 130 | Line 102 | double  *a;
102		act.name = fname;
103		act.prev = curact;
104		act.ap = a;
105	<	act.an = (1L<<n)-1;
105	>	if (n >= AFLAGSIZ)
106	>	act.an = ~0;
107	>	else
108	>	act.an = (1L<<n)-1;
109		act.fun = NULL;
110		curact = &act;
111
#	Line 145 | Line 120 | double  *a;
120		}
121
122
123	<	funset(fname, nargs, fptr)              /* set a library function */
123	>	void
124	>	funset(fname, nargs, assign, fptr)      /* set a library function */
125		char  *fname;
126		int  nargs;
127	+	int  assign;
128		double  (*fptr)();
129		{
130	+	int  oldlibsize = libsize;
131	+	char *cp;
132		register LIBR  *lp;
133	<
134	<	if ((lp = liblookup(fname)) == NULL) {
133	>	/* check for context */
134	>	for (cp = fname; *cp; cp++)
135	>	;
136	>	if (cp == fname)
137	>	return;
138	>	if (cp[-1] == CNTXMARK)
139	>	*--cp = '\0';
140	>	if ((lp = liblookup(fname)) == NULL) {      /* insert */
141		if (libsize >= MAXLIB) {
142		eputs("Too many library functons!\n");
143		quit(1);
#	Line 161 | Line 146 | double  (*fptr)();
146		if (strcmp(lp[-1].fname, fname) > 0) {
147		lp[0].fname = lp[-1].fname;
148		lp[0].nargs = lp[-1].nargs;
149	+	lp[0].atyp = lp[-1].atyp;
150		lp[0].f = lp[-1].f;
151		} else
152		break;
153		libsize++;
154		}
155	<	lp[0].fname = fname;                /* string must be static! */
156	<	lp[0].nargs = nargs;
157	<	lp[0].f = fptr;
155	>	if (fptr == NULL) {                         /* delete */
156	>	while (lp < &library[libsize-1]) {
157	>	lp[0].fname = lp[1].fname;
158	>	lp[0].nargs = lp[1].nargs;
159	>	lp[0].atyp = lp[1].atyp;
160	>	lp[0].f = lp[1].f;
161	>	lp++;
162	>	}
163	>	libsize--;
164	>	} else {                                    /* or assign */
165	>	lp[0].fname = fname;            /* string must be static! */
166	>	lp[0].nargs = nargs;
167	>	lp[0].atyp = assign;
168	>	lp[0].f = fptr;
169	>	}
170	>	if (libsize != oldlibsize)
171	>	libupdate(fname);                       /* relink library */
172		}
173
174
#	Line 193 | Line 193 | argument(n)                    /* return nth argument for active functi
193		register int  n;
194		{
195		register ACTIVATION  *actp = curact;
196	<	EPNODE  *ep;
196	>	register EPNODE  *ep;
197		double  aval;
198
199		if (actp == NULL || --n < 0) {
#	Line 201 | Line 201 | register int  n;
201		quit(1);
202		}
203		/* already computed? */
204	<	if (1L<<n & actp->an)
204	>	if (n < AFLAGSIZ && 1L<<n & actp->an)
205		return(actp->ap[n]);
206
207		if (actp->fun == NULL || (ep = ekid(actp->fun, n+1)) == NULL) {
#	Line 220 | Line 220 | register int  n;
220		}
221
222
223	–	#ifdef  VARIABLE
223		VARDEF *
224		argf(n)                         /* return function def for nth argument */
225		int  n;
#	Line 256 | Line 255 | badarg:
255		eputs(actp->name);
256		eputs(": argument not a function\n");
257		quit(1);
258	+	return NULL; /* pro forma return */
259		}
260
261
#	Line 265 | Line 265 | int  n;
265		{
266		return(argf(n)->name);
267		}
268	–	#endif
268
269
270		double
#	Line 319 | Line 318 | char  *fname;
318		}
319
320
322	–	#ifndef  VARIABLE
323	–	VARDEF *
324	–	varinsert(vname)                /* dummy variable insert */
325	–	char  *vname;
326	–	{
327	–	register VARDEF  *vp;
328	–
329	–	vp = (VARDEF *)emalloc(sizeof(VARDEF));
330	–	vp->name = savestr(vname);
331	–	vp->nlinks = 1;
332	–	vp->def = NULL;
333	–	vp->lib = NULL;
334	–	vp->next = NULL;
335	–	return(vp);
336	–	}
337	–
338	–
339	–	varfree(vp)                     /* free dummy variable */
340	–	register VARDEF  *vp;
341	–	{
342	–	freestr(vp->name);
343	–	efree((char *)vp);
344	–	}
345	–	#endif
346	–
347	–
348	–
321		/*
322		*  The following routines are for internal use:
323		*/
#	Line 354 | Line 326 | register VARDEF  *vp;
326		static double
327		libfunc(fname, vp)                      /* execute library function */
328		char  *fname;
329	<	register VARDEF  *vp;
329	>	VARDEF  *vp;
330		{
331	<	VARDEF  dumdef;
331	>	register LIBR  *lp;
332		double  d;
333		int  lasterrno;
334
335	<	if (vp == NULL) {
336	<	vp = &dumdef;
337	<	vp->lib = NULL;
338	<	}
339	<	if (((vp->lib == NULL || strcmp(fname, vp->lib->fname)) &&
368	<	(vp->lib = liblookup(fname)) == NULL) ||
369	<	vp->lib->f == NULL) {
335	>	if (vp != NULL)
336	>	lp = vp->lib;
337	>	else
338	>	lp = liblookup(fname);
339	>	if (lp == NULL) {
340		eputs(fname);
341		eputs(": undefined function\n");
342		quit(1);
343		}
344		lasterrno = errno;
345		errno = 0;
346	<	d = (*vp->lib->f)();
346	>	d = (*lp->f)(lp->fname);
347		#ifdef  IEEE
348	<	if (!finite(d))
349	<	errno = EDOM;
348	>	if (errno == 0)
349	>	if (isnan(d))
350	>	errno = EDOM;
351	>	else if (isinf(d))
352	>	errno = ERANGE;
353		#endif
354	<	if (errno) {
354	>	if (errno == EDOM || errno == ERANGE) {
355		wputs(fname);
356	<	wputs(": bad call\n");
356	>	if (errno == EDOM)
357	>	wputs(": domain error\n");
358	>	else if (errno == ERANGE)
359	>	wputs(": range error\n");
360	>	else
361	>	wputs(": error in call\n");
362		return(0.0);
363		}
364		errno = lasterrno;
#	Line 409 | Line 387 | l_select()             /* return argument #(A1+1) */
387		{
388		register int  n;
389
390	<	n = argument(1) + .5;
390	>	n = (int)(argument(1) + .5);
391		if (n == 0)
392		return(nargum()-1);
393		if (n < 1 || n > nargum()-1) {
#	Line 423 | Line 401 | l_select()             /* return argument #(A1+1) */
401		static double
402		l_rand()                /* random function between 0 and 1 */
403		{
426	–	extern double  floor();
404		double  x;
405
406		x = argument(1);
#	Line 437 | Line 414 | l_rand()               /* random function between 0 and 1 */
414		static double
415		l_floor()               /* return largest integer not greater than arg1 */
416		{
440	–	extern double  floor();
441	–
417		return(floor(argument(1)));
418		}
419
#	Line 446 | Line 421 | l_floor()              /* return largest integer not greater than
421		static double
422		l_ceil()                /* return smallest integer not less than arg1 */
423		{
449	–	extern double  ceil();
450	–
424		return(ceil(argument(1)));
425		}
426
427
455	–	#ifdef  BIGLIB
428		static double
429		l_sqrt()
430		{
459	–	extern double  sqrt();
460	–
431		return(sqrt(argument(1)));
432		}
433
#	Line 465 | Line 435 | l_sqrt()
435		static double
436		l_sin()
437		{
468	–	extern double  sin();
469	–
438		return(sin(argument(1)));
439		}
440
#	Line 474 | Line 442 | l_sin()
442		static double
443		l_cos()
444		{
477	–	extern double  cos();
478	–
445		return(cos(argument(1)));
446		}
447
#	Line 483 | Line 449 | l_cos()
449		static double
450		l_tan()
451		{
486	–	extern double  tan();
487	–
452		return(tan(argument(1)));
453		}
454
#	Line 492 | Line 456 | l_tan()
456		static double
457		l_asin()
458		{
495	–	extern double  asin();
496	–
459		return(asin(argument(1)));
460		}
461
#	Line 501 | Line 463 | l_asin()
463		static double
464		l_acos()
465		{
504	–	extern double  acos();
505	–
466		return(acos(argument(1)));
467		}
468
#	Line 510 | Line 470 | l_acos()
470		static double
471		l_atan()
472		{
513	–	extern double  atan();
514	–
473		return(atan(argument(1)));
474		}
475
#	Line 519 | Line 477 | l_atan()
477		static double
478		l_atan2()
479		{
522	–	extern double  atan2();
523	–
480		return(atan2(argument(1), argument(2)));
481		}
482
#	Line 528 | Line 484 | l_atan2()
484		static double
485		l_exp()
486		{
531	–	extern double  exp();
532	–
487		return(exp(argument(1)));
488		}
489
#	Line 537 | Line 491 | l_exp()
491		static double
492		l_log()
493		{
540	–	extern double  log();
541	–
494		return(log(argument(1)));
495		}
496
#	Line 546 | Line 498 | l_log()
498		static double
499		l_log10()
500		{
549	–	extern double  log10();
550	–
501		return(log10(argument(1)));
502		}
553	–	#endif

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines (old)
>	Changed lines (new)