addrans man page on SunOS

Man page or keyword search:  
man Server   20652 pages
apropos Keyword Search (all sections)
Output format
SunOS logo
[printable version]

addrans(3M)							   addrans(3M)

NAME
       addrans - additive pseudo-random number generators

SYNOPSIS
       cc [ flag ... ] file ...	 -lsunmath -lm [ library ... ]

       #include <sunmath.h>

       int i_addran_(void);

       float r_addran_(void);

       double d_addran_(void);

       void i_addrans_(int *x, int *n, int *l, int *u);

       void u_addrans_(unsigned *x, int *n, unsigned *l, unsigned *u);

       void r_addrans_(float *x, int *n, float *l, float *u);

       void d_addrans_(double *x, int *n, double *l, double *u);

       void i_get_addrans_(int *x);

       void r_get_addrans_(float *x);

       void d_get_addrans_(double *x);

       void i_set_addrans_(int *x);

       void r_set_addrans_(float *x);

       void d_set_addrans_(double *x);

       void i_init_addrans_(void);

       void r_init_addrans_(void);

       void d_init_addrans_(void);

DESCRIPTION
       These  functions generate uniformly distributed random numbers of types
       int, unsigned int, float, or double.  Each function generates the  next
       random number in sequence using a recurrence of the form

	    next = table[i] - table[(i - 24) % ADDRAN_SIZE];
	    table[i] = next;
	    i = (i + 1) % ADDRAN_SIZE;

       Internally,   these   functions	 maintain  three  separate  tables  of
       ADDRAN_SIZE elements for each thread  in	 a  program.   ADDRAN_SIZE  is
       defined in <sunmath.h>.

       i_addran_()  returns  a	random 32-bit integer.	Successive numbers are
       computed in 32-bit integer arithmetic (i.e., modulo 2**32) and thus lie
       in the range -2147483648, ..., 2147483647.

       r_addran_()  returns  a	random	single precision floating point number
       between 0 and 1 - 2**-24.  Successive numbers are kept in this range by
       adding 1 when necessary.

       d_addran_()  returns  a	random	double precision floating point number
       between 0 and 1 - 2**-53.  Successive numbers are kept in this range by
       adding 1 when necessary.

       i_addrans_(n, x, l, u), u_addrans_(n, x, l, u), r_addrans_(n, x, l, u),
       and d_addrans_(n, x, l, u) each fill  the  array	 elements  x[0],  ...,
       x[*n-1]	with  random 32-bit signed integers, 32-bit unsigned integers,
       single precision floating point numbers and double  precision  floating
       point  numbers,	respectively.  The numbers are scaled and offset so as
       to be uniformly distributed over the interval [*l, *u].

       i_get_addrans_(x) fills x[0], ..., x[ADDRAN_SIZE-1]  with  the  current
       values  of  the	table used by i_addran_.  i_set_addrans_(x) fills this
       table with the values x[0], ...,	 x[ADDRAN_SIZE-1].   i_init_addrans_()
       resets this table to its initial state.

       r_get_addrans_(x)  fills	 x[0],	..., x[ADDRAN_SIZE-1] with the current
       values of the table used by r_addran_.	r_set_addrans_(x)  fills  this
       table  with  the values x[0], ..., x[ADDRAN_SIZE-1].  r_init_addrans_()
       resets this table to its initial state.

       d_get_addrans_(x) fills x[0], ..., x[ADDRAN_SIZE-1]  with  the  current
       values  of  the	table used by d_addran_.  d_set_addrans_(x) fills this
       table with the values x[0], ...,	 x[ADDRAN_SIZE-1].   d_init_addrans_()
       resets this table to its initial state.

       i_addrans_  and u_addrans_ use the same table as i_addran_.  r_addrans_
       uses the same table as r_addran_.  d_addrans_ uses the  same  table  as
       d_addran_.   So, for example, calling i_addran_ immediately after call‐
       ing  i_init_addrans_  will  give	 a  different  result	than   calling
       i_init_addrans_,	 then  u_addrans_,  then i_addran_.  Different threads
       within a program use different tables, however, so calling one of these
       functions  in  one thread will not affect the values delivered when the
       same function is called from another thread.

EXAMPLES
       To generate 1000 random double precision numbers in [0,1):

	      double x[1000];
	      int i;

	      for (i = 0; i < 1000; i++)
		  x[i] = d_addran_();

       The same numbers can be generated more efficiently using:

	      double x[1000], lb, ub;
	      int n = 1000;

	      lb = D_ADDRAN_LB; /* defined in <sunmath.h> */
	      ub = D_ADDRAN_UB; /* defined in <sunmath.h> */
	      d_addrans_(x, &n, &lb, &ub);

       To generate 1000 random integers between -10 and 10:

	      int x[1000], n = 1000, lb = -10, ub = 10;

	      i_addrans_(x, &n, &lb, &ub);

ATTRIBUTES
       See attributes(5) for descriptions of the following attributes:

       ┌────────────────────┬─────────────────┐
       │  ATTRIBUTE TYPE    │ ATTRIBUTE VALUE │
       ├────────────────────┼─────────────────┤
       │Interface Stability │ Committed	      │
       │MT-Level	    │ MT-Safe	      │
       └────────────────────┴─────────────────┘
SEE ALSO
       drand48(3C),    lcrans(3M),    mwcrans(3M),    rand(3C),	   random(3C),
       shufrans(3M), attributes(5)

       Knuth, Seminumerical Algorithms, 1981, Addison-Wesley.

       Park  and Miller, Random Number Generators: Good Ones are Hard to Find,
       Communications of the ACM, October 1988.

NOTES
       Typically, the  addrans(3M)  generators	are  faster  than  either  the
       lcrans(3M) or the mwcrans(3M) generators.

				  14 Mar 2009			   addrans(3M)
[top]

List of man pages available for SunOS

Copyright (c) for man pages and the logo by the respective OS vendor.

For those who want to learn more, the polarhome community provides shell access and support.

[legal] [privacy] [GNU] [policy] [cookies] [netiquette] [sponsors] [FAQ]
Tweet
Polarhome, production since 1999.
Member of Polarhome portal.
Based on Fawad Halim's script.
....................................................................
Vote for polarhome
Free Shell Accounts :: the biggest list on the net