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.15 by greg, Wed May 10 15:21:20 2006 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 180 | Line 125 | funset(fname, nargs, assign, fptr)     /* set a library fu
125		char  *fname;
126		int  nargs;
127		int  assign;
128	<	double  (*fptr)();
128	>	double  (*fptr)(char *);
129		{
130		int  oldlibsize = libsize;
131		char *cp;
#	Line 248 | Line 193 | argument(n)                    /* return nth argument for active functi
193		register int  n;
194		{
195		register ACTIVATION  *actp = curact;
196	<	register EPNODE  *ep;
196	>	register EPNODE  *ep = NULL;
197		double  aval;
198
199		if (actp == NULL || --n < 0) {
#	Line 310 | 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 398 | Line 344 | VARDEF  *vp;
344		lasterrno = errno;
345		errno = 0;
346		d = (*lp->f)(lp->fname);
347	<	#ifdef  IEEE
347	>	#ifdef  isnan
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		if (errno == EDOM)
357		wputs(": domain error\n");
#	Line 426 | Line 372 | VARDEF  *vp;
372
373
374		static double
375	<	l_if()                  /* if(cond, then, else) conditional expression */
375	>	l_if(char *nm)          /* if(cond, then, else) conditional expression */
376		/* cond evaluates true if greater than zero */
377		{
378		if (argument(1) > 0.0)
#	Line 437 | Line 383 | l_if()                 /* if(cond, then, else) conditional expressio
383
384
385		static double
386	<	l_select()              /* return argument #(A1+1) */
386	>	l_select(char *nm)      /* 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 453 | Line 399 | l_select()             /* return argument #(A1+1) */
399
400
401		static double
402	<	l_rand()                /* random function between 0 and 1 */
402	>	l_rand(char *nm)                /* random function between 0 and 1 */
403		{
404		double  x;
405
#	Line 466 | Line 412 | l_rand()               /* random function between 0 and 1 */
412
413
414		static double
415	<	l_floor()               /* return largest integer not greater than arg1 */
415	>	l_floor(char *nm)               /* return largest integer not greater than arg1 */
416		{
417		return(floor(argument(1)));
418		}
419
420
421		static double
422	<	l_ceil()                /* return smallest integer not less than arg1 */
422	>	l_ceil(char *nm)                /* return smallest integer not less than arg1 */
423		{
424		return(ceil(argument(1)));
425		}
426
427
428		static double
429	<	l_sqrt()
429	>	l_sqrt(char *nm)
430		{
431		return(sqrt(argument(1)));
432		}
433
434
435		static double
436	<	l_sin()
436	>	l_sin(char *nm)
437		{
438		return(sin(argument(1)));
439		}
440
441
442		static double
443	<	l_cos()
443	>	l_cos(char *nm)
444		{
445		return(cos(argument(1)));
446		}
447
448
449		static double
450	<	l_tan()
450	>	l_tan(char *nm)
451		{
452		return(tan(argument(1)));
453		}
454
455
456		static double
457	<	l_asin()
457	>	l_asin(char *nm)
458		{
459		return(asin(argument(1)));
460		}
461
462
463		static double
464	<	l_acos()
464	>	l_acos(char *nm)
465		{
466		return(acos(argument(1)));
467		}
468
469
470		static double
471	<	l_atan()
471	>	l_atan(char *nm)
472		{
473		return(atan(argument(1)));
474		}
475
476
477		static double
478	<	l_atan2()
478	>	l_atan2(char *nm)
479		{
480		return(atan2(argument(1), argument(2)));
481		}
482
483
484		static double
485	<	l_exp()
485	>	l_exp(char *nm)
486		{
487		return(exp(argument(1)));
488		}
489
490
491		static double
492	<	l_log()
492	>	l_log(char *nm)
493		{
494		return(log(argument(1)));
495		}
496
497
498		static double
499	<	l_log10()
499	>	l_log10(char *nm)
500		{
501		return(log10(argument(1)));
502		}

Diff Legend

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