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 2.8 by greg, Sat Feb 22 02:07:21 2003 UTC vs.
Revision 2.16 by greg, Wed Oct 24 00:39:09 2012 UTC

#	Line 10 | Line 10 | static const char      RCSid[] = "$Id$";
10		*  2/19/03     Eliminated conditional compiles in favor of esupport extern.
11		*/
12
13	<	/* ====================================================================
14	<	* The Radiance Software License, Version 1.0
15	<	*
16	<	* Copyright (c) 1990 - 2002 The Regents of the University of California,
17	<	* through Lawrence Berkeley National Laboratory.   All rights reserved.
18	<	*
19	<	* Redistribution and use in source and binary forms, with or without
20	<	* modification, are permitted provided that the following conditions
21	<	* are met:
22	<	*
23	<	* 1. Redistributions of source code must retain the above copyright
24	<	*         notice, this list of conditions and the following disclaimer.
25	<	*
26	<	* 2. Redistributions in binary form must reproduce the above copyright
27	<	*       notice, this list of conditions and the following disclaimer in
28	<	*       the documentation and/or other materials provided with the
29	<	*       distribution.
30	<	*
31	<	* 3. The end-user documentation included with the redistribution,
32	<	*           if any, must include the following acknowledgment:
33	<	*             "This product includes Radiance software
34	<	*                 (http://radsite.lbl.gov/)
35	<	*                 developed by the Lawrence Berkeley National Laboratory
36	<	*               (http://www.lbl.gov/)."
37	<	*       Alternately, this acknowledgment may appear in the software itself,
38	<	*       if and wherever such third-party acknowledgments normally appear.
39	<	*
40	<	* 4. The names "Radiance," "Lawrence Berkeley National Laboratory"
41	<	*       and "The Regents of the University of California" must
42	<	*       not be used to endorse or promote products derived from this
43	<	*       software without prior written permission. For written
44	<	*       permission, please contact [email protected].
45	<	*
46	<	* 5. Products derived from this software may not be called "Radiance",
47	<	*       nor may "Radiance" appear in their name, without prior written
48	<	*       permission of Lawrence Berkeley National Laboratory.
49	<	*
50	<	* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
51	<	* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
52	<	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
53	<	* DISCLAIMED.   IN NO EVENT SHALL Lawrence Berkeley National Laboratory OR
54	<	* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
55	<	* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
56	<	* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
57	<	* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
58	<	* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
59	<	* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
60	<	* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
61	<	* SUCH DAMAGE.
62	<	* ====================================================================
63	<	*
64	<	* This software consists of voluntary contributions made by many
65	<	* individuals on behalf of Lawrence Berkeley National Laboratory.   For more
66	<	* information on Lawrence Berkeley National Laboratory, please see
67	<	* <http://www.lbl.gov/>.
68	<	*/
13	>	#include "copyright.h"
14
15		#include  <stdio.h>
16	<
16	>	#include  <string.h>
17		#include  <errno.h>
73	–
18		#include  <math.h>
19
20	+	#include  "rterror.h"
21		#include  "calcomp.h"
22
23		/* bits in argument flag (better be right!) */
#	Line 89 | 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();
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();
43	>	static double  l_if(char *), l_select(char *), l_rand(char *);
44	>	static double  l_floor(char *), l_ceil(char *);
45	>	static double  l_sqrt(char *);
46	>	static double  l_sin(char *), l_cos(char *), l_tan(char *);
47	>	static double  l_asin(char *), l_acos(char *), l_atan(char *), l_atan2(char *);
48	>	static double  l_exp(char *), l_log(char *), l_log10(char *);
49
50		/* functions must be listed alphabetically */
51		static LIBR  library[MAXLIB] = {
#	Line 128 | Line 73 | static int  libsize = 16;
73
74
75		int
76	<	fundefined(fname)               /* return # of arguments for function */
77	<	char  *fname;
76	>	fundefined(                     /* return # of arguments for function */
77	>	char  *fname
78	>	)
79		{
80	<	register LIBR  *lp;
81	<	register VARDEF  *vp;
80	>	LIBR  *lp;
81	>	VARDEF  *vp;
82
83		if ((vp = varlookup(fname)) != NULL && vp->def != NULL
84		&& vp->def->v.kid->type == FUNC)
#	Line 145 | Line 91 | char  *fname;
91
92
93		double
94	<	funvalue(fname, n, a)           /* return a function value to the user */
95	<	char  *fname;
96	<	int  n;
97	<	double  *a;
94	>	funvalue(                       /* return a function value to the user */
95	>	char  *fname,
96	>	int  n,
97	>	double  *a
98	>	)
99		{
100		ACTIVATION  act;
101	<	register VARDEF  *vp;
101	>	VARDEF  *vp;
102		double  rval;
103		/* push environment */
104		act.name = fname;
#	Line 176 | Line 123 | double  *a;
123
124
125		void
126	<	funset(fname, nargs, assign, fptr)      /* set a library function */
127	<	char  *fname;
128	<	int  nargs;
129	<	int  assign;
130	<	double  (*fptr)();
126	>	funset(                         /* set a library function */
127	>	char  *fname,
128	>	int  nargs,
129	>	int  assign,
130	>	double  (*fptr)(char *)
131	>	)
132		{
133		int  oldlibsize = libsize;
134		char *cp;
135	<	register LIBR  *lp;
135	>	LIBR  *lp;
136		/* check for context */
137		for (cp = fname; *cp; cp++)
138		;
#	Line 228 | Line 176 | double  (*fptr)();
176
177
178		int
179	<	nargum()                        /* return number of available arguments */
179	>	nargum(void)                    /* return number of available arguments */
180		{
181	<	register int  n;
181	>	int  n;
182
183		if (curact == NULL)
184		return(0);
#	Line 244 | Line 192 | nargum()                       /* return number of available arguments */
192
193
194		double
195	<	argument(n)                     /* return nth argument for active function */
248	<	register int  n;
195	>	argument(int n)                 /* return nth argument for active function */
196		{
197	<	register ACTIVATION  *actp = curact;
198	<	register EPNODE  *ep;
197	>	ACTIVATION  *actp = curact;
198	>	EPNODE  *ep = NULL;
199		double  aval;
200
201		if (actp == NULL || --n < 0) {
#	Line 276 | Line 223 | register int  n;
223
224
225		VARDEF *
226	<	argf(n)                         /* return function def for nth argument */
280	<	int  n;
226	>	argf(int n)                     /* return function def for nth argument */
227		{
228	<	register ACTIVATION  *actp;
229	<	register EPNODE  *ep;
228	>	ACTIVATION  *actp;
229	>	EPNODE  *ep;
230
231		for (actp = curact; actp != NULL; actp = actp->prev) {
232
#	Line 310 | Line 256 | badarg:
256		eputs(actp->name);
257		eputs(": argument not a function\n");
258		quit(1);
259	+	return NULL; /* pro forma return */
260		}
261
262
263		char *
264	<	argfun(n)                       /* return function name for nth argument */
318	<	int  n;
264	>	argfun(int n)                   /* return function name for nth argument */
265		{
266		return(argf(n)->name);
267		}
268
269
270		double
271	<	efunc(ep)                               /* evaluate a function */
326	<	register EPNODE  *ep;
271	>	efunc(EPNODE *ep)                       /* evaluate a function */
272		{
273		ACTIVATION  act;
274		double  alist[ALISTSIZ];
275		double  rval;
276	<	register VARDEF  *dp;
276	>	VARDEF  *dp;
277		/* push environment */
278		dp = resolve(ep->v.kid);
279		act.name = dp->name;
#	Line 349 | Line 294 | register EPNODE  *ep;
294
295
296		LIBR *
297	<	liblookup(fname)                /* look up a library function */
353	<	char  *fname;
297	>	liblookup(char *fname)          /* look up a library function */
298		{
299		int  upper, lower;
300	<	register int  cm, i;
300	>	int  cm, i;
301
302		lower = 0;
303		upper = cm = libsize;
#	Line 378 | Line 322 | char  *fname;
322
323
324		static double
325	<	libfunc(fname, vp)                      /* execute library function */
326	<	char  *fname;
327	<	VARDEF  *vp;
325	>	libfunc(                                /* execute library function */
326	>	char  *fname,
327	>	VARDEF  *vp
328	>	)
329		{
330	<	register LIBR  *lp;
330	>	LIBR  *lp;
331		double  d;
332		int  lasterrno;
333
#	Line 398 | Line 343 | VARDEF  *vp;
343		lasterrno = errno;
344		errno = 0;
345		d = (*lp->f)(lp->fname);
346	<	#ifdef  IEEE
346	>	#ifdef  isnan
347		if (errno == 0)
348		if (isnan(d))
349		errno = EDOM;
350		else if (isinf(d))
351		errno = ERANGE;
352		#endif
353	<	if (errno) {
353	>	if (errno == EDOM || errno == ERANGE) {
354		wputs(fname);
355		if (errno == EDOM)
356		wputs(": domain error\n");
#	Line 426 | Line 371 | VARDEF  *vp;
371
372
373		static double
374	<	l_if()                  /* if(cond, then, else) conditional expression */
374	>	l_if(char *nm)          /* if(cond, then, else) conditional expression */
375		/* cond evaluates true if greater than zero */
376		{
377		if (argument(1) > 0.0)
#	Line 437 | Line 382 | l_if()                 /* if(cond, then, else) conditional expressio
382
383
384		static double
385	<	l_select()              /* return argument #(A1+1) */
385	>	l_select(char *nm)      /* return argument #(A1+1) */
386		{
387	<	register int  n;
387	>	int  n;
388
389	<	n = argument(1) + .5;
389	>	n = (int)(argument(1) + .5);
390		if (n == 0)
391		return(nargum()-1);
392		if (n < 1 || n > nargum()-1) {
#	Line 453 | Line 398 | l_select()             /* return argument #(A1+1) */
398
399
400		static double
401	<	l_rand()                /* random function between 0 and 1 */
401	>	l_rand(char *nm)                /* random function between 0 and 1 */
402		{
403		double  x;
404
#	Line 466 | Line 411 | l_rand()               /* random function between 0 and 1 */
411
412
413		static double
414	<	l_floor()               /* return largest integer not greater than arg1 */
414	>	l_floor(char *nm)               /* return largest integer not greater than arg1 */
415		{
416		return(floor(argument(1)));
417		}
418
419
420		static double
421	<	l_ceil()                /* return smallest integer not less than arg1 */
421	>	l_ceil(char *nm)                /* return smallest integer not less than arg1 */
422		{
423		return(ceil(argument(1)));
424		}
425
426
427		static double
428	<	l_sqrt()
428	>	l_sqrt(char *nm)
429		{
430		return(sqrt(argument(1)));
431		}
432
433
434		static double
435	<	l_sin()
435	>	l_sin(char *nm)
436		{
437		return(sin(argument(1)));
438		}
439
440
441		static double
442	<	l_cos()
442	>	l_cos(char *nm)
443		{
444		return(cos(argument(1)));
445		}
446
447
448		static double
449	<	l_tan()
449	>	l_tan(char *nm)
450		{
451		return(tan(argument(1)));
452		}
453
454
455		static double
456	<	l_asin()
456	>	l_asin(char *nm)
457		{
458		return(asin(argument(1)));
459		}
460
461
462		static double
463	<	l_acos()
463	>	l_acos(char *nm)
464		{
465		return(acos(argument(1)));
466		}
467
468
469		static double
470	<	l_atan()
470	>	l_atan(char *nm)
471		{
472		return(atan(argument(1)));
473		}
474
475
476		static double
477	<	l_atan2()
477	>	l_atan2(char *nm)
478		{
479		return(atan2(argument(1), argument(2)));
480		}
481
482
483		static double
484	<	l_exp()
484	>	l_exp(char *nm)
485		{
486		return(exp(argument(1)));
487		}
488
489
490		static double
491	<	l_log()
491	>	l_log(char *nm)
492		{
493		return(log(argument(1)));
494		}
495
496
497		static double
498	<	l_log10()
498	>	l_log10(char *nm)
499		{
500		return(log10(argument(1)));
501		}

Diff Legend

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