ViewVC Help

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

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

Comparing ray/src/common/urand.c (file contents):
Revision 2.5 by greg, Sat Feb 22 02:07:22 2003 UTC vs.
Revision 2.13 by greg, Thu Apr 21 02:55:19 2022 UTC

#	Line 5 | Line 5 | static const char      RCSid[] = "$Id$";
5		* Anticorrelated random function due to Christophe Schlick
6		*/
7
8	<	/* ====================================================================
9	<	* The Radiance Software License, Version 1.0
10	<	*
11	<	* Copyright (c) 1990 - 2002 The Regents of the University of California,
12	<	* through Lawrence Berkeley National Laboratory.   All rights reserved.
13	<	*
14	<	* Redistribution and use in source and binary forms, with or without
15	<	* modification, are permitted provided that the following conditions
16	<	* are met:
17	<	*
18	<	* 1. Redistributions of source code must retain the above copyright
19	<	*         notice, this list of conditions and the following disclaimer.
20	<	*
21	<	* 2. Redistributions in binary form must reproduce the above copyright
22	<	*       notice, this list of conditions and the following disclaimer in
23	<	*       the documentation and/or other materials provided with the
24	<	*       distribution.
25	<	*
26	<	* 3. The end-user documentation included with the redistribution,
27	<	*           if any, must include the following acknowledgment:
28	<	*             "This product includes Radiance software
29	<	*                 (http://radsite.lbl.gov/)
30	<	*                 developed by the Lawrence Berkeley National Laboratory
31	<	*               (http://www.lbl.gov/)."
32	<	*       Alternately, this acknowledgment may appear in the software itself,
33	<	*       if and wherever such third-party acknowledgments normally appear.
34	<	*
35	<	* 4. The names "Radiance," "Lawrence Berkeley National Laboratory"
36	<	*       and "The Regents of the University of California" must
37	<	*       not be used to endorse or promote products derived from this
38	<	*       software without prior written permission. For written
39	<	*       permission, please contact [email protected].
40	<	*
41	<	* 5. Products derived from this software may not be called "Radiance",
42	<	*       nor may "Radiance" appear in their name, without prior written
43	<	*       permission of Lawrence Berkeley National Laboratory.
44	<	*
45	<	* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
46	<	* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
47	<	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
48	<	* DISCLAIMED.   IN NO EVENT SHALL Lawrence Berkeley National Laboratory OR
49	<	* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
50	<	* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
51	<	* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
52	<	* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
53	<	* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
54	<	* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
55	<	* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
56	<	* SUCH DAMAGE.
57	<	* ====================================================================
58	<	*
59	<	* This software consists of voluntary contributions made by many
60	<	* individuals on behalf of Lawrence Berkeley National Laboratory.   For more
61	<	* information on Lawrence Berkeley National Laboratory, please see
62	<	* <http://www.lbl.gov/>.
63	<	*/
8	>	#include "copyright.h"
9
10	<	#include  <stdlib.h>
10	>	#include  "rterror.h"
11		#include  "random.h"
12
13		#undef initurand
14
15		#define  MAXORDER       (8*sizeof(unsigned short))
16
17	<	unsigned short  *urperm = NULL; /* urand() permutation */
73	<	int  urmask;            /* bits used in permutation */
17	>	static unsigned short  empty_tab = 0;
18
19	+	unsigned short  *urperm = &empty_tab;   /* urand() permutation */
20	+	int  urmask = 0;                        /* bits used in permutation */
21	+
22	+
23	+	long
24	+	irandom(                        /* better than using random() % modulus */
25	+	long modulus
26	+	)
27	+	{
28	+	if ((sizeof(long) == 8) | (sizeof(int) == 8))
29	+	return((random()*modulus)>>31);
30	+
31	+	if (sizeof(long long) == 8)
32	+	return((random()*(long long)modulus)>>31);
33	+
34	+	return(random() % modulus);
35	+	}
36	+
37		int
38	<	initurand(size)         /* initialize urand() for size entries */
39	<	int  size;
38	>	initurand(                      /* initialize urand() for size entries */
39	>	int  size
40	>	)
41		{
42		int  order, n;
43	<	register int  i, offset;
43	>	int  i, offset;
44
45	<	if (urperm != NULL)
45	>	if ((urperm != NULL) & (urperm != &empty_tab))
46		free((void *)urperm);
47		if (--size <= 0) {
48	<	urperm = NULL;
48	>	empty_tab = 0;
49	>	urperm = &empty_tab;
50		urmask = 0;
51		return(0);
52		}
53	<	for (i = 1; size >>= 1; i++)
54	<	;
55	<	order = i>MAXORDER ? MAXORDER : i;
56	<	urmask = (1<<i) - 1;
53	>	for (i = 1; (size >>= 1); i++)
54	>	if (i == MAXORDER)
55	>	break;
56	>	order = i;
57	>	urmask = (1<<order) - 1;
58		urperm = (unsigned short *)malloc((urmask+1)*sizeof(unsigned short));
59		if (urperm == NULL) {
60		eputs("out of memory in initurand\n");
#	Line 98 | Line 63 | int  size;
63		urperm[0] = 0;
64		for (n = 1, offset = 1; n <= order; n++, offset <<= 1)
65		for (i = offset; i--; ) {
66	<	urperm[i] =
102	<	urperm[i+offset] = 2*urperm[i];
66	>	urperm[i+offset] = urperm[i] <<= 1;
67		if (random() & 0x4000)
68		urperm[i]++;
69		else
70		urperm[i+offset]++;
71		}
72	<	return(1<<order);
72	>	return(urmask+1);
73		}
74
75
76		int
77	<	ilhash(d, n)                    /* hash a set of integer values */
78	<	register int  *d;
79	<	register int  n;
77	>	ilhash(                         /* hash a set of integer values */
78	>	int  *d,
79	>	int  n
80	>	)
81		{
82	<	static int  tab[8] = {13623,353,1637,5831,2314,3887,5832,8737};
83	<	register int  hval;
82	>	static int  tab[8] = {103699,96289,73771,65203,81119,87037,92051,98899};
83	>	int  hval;
84
85		hval = 0;
86		while (n-- > 0)
87	<	hval += *d++ * tab[n&7];
88	<	return(hval);
87	>	hval ^= *d++ * tab[n&7];
88	>	return(hval & 0x7fffffff);
89		}

Diff Legend

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