Return to random.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / quagga / isisd / topology

Annotation of embedaddon/quagga/isisd/topology/random.c, revision 1.1

1.1     ! misho       1: /*********************************************************************/
        !             2: /*                                                                   */
        !             3: /* current processor time in seconds                                 */
        !             4: /* difference between two calls is processor time spent by your code */
        !             5: /* needs: <sys/types.h>, <sys/times.h>                               */
        !             6: /* depends on compiler and OS                                        */
        !             7: /*                                                                   */
        !             8: /*********************************************************************/
        !             9: 
        !            10: #include <sys/types.h>
        !            11: #include <sys/times.h>
        !            12: 
        !            13: /*
        !            14:  * Prototypes.
        !            15:  */
        !            16: unsigned long timer(void);
        !            17: void init_rand(long);
        !            18: double rand01(void);
        !            19: double randg01(void);
        !            20: long nrand(long);
        !            21: void free_arc(void *);
        !            22: 
        !            23: unsigned long timer ()
        !            24:    { struct tms hold;
        !            25: 
        !            26:         times(&hold);
        !            27:         return (unsigned long) ((float) (hold.tms_utime) / 60.0);
        !            28:    }
        !            29: 
        !            30: 
        !            31: /*********************************************************************/
        !            32: /*                                                                   */
        !            33: /*            Family of random number generators                     */
        !            34: /*                                                                   */
        !            35: /*  Initialisation:                                                  */
        !            36: /*            void init_rand ( seed );                               */
        !            37: /*                 long seed     - any positive number               */
        !            38: /*                                 if seed<=0 init_rand takes time   */
        !            39: /*                                 from timer instead of seed        */
        !            40: /*                                                                   */
        !            41: /*  Whole number uniformly distributed on [0,n):                     */
        !            42: /*            long nrand (n);                                        */
        !            43: /*                 long n                                            */
        !            44: /*                                                                   */
        !            45: /*  Real number uniformly distributed on [0,1]                       */
        !            46: /*            double rand01();                                       */
        !            47: /*                                                                   */
        !            48: /*  Real number with Gauss(0,1) disitribution:                       */
        !            49: /*            double randg01();                                      */
        !            50: /*                                                                   */
        !            51: /*  Algorithm:                                                       */
        !            52: /*            x(n+1) = (x(n) * 5^13) mod 2^31                        */
        !            53: /*                                                                   */
        !            54: /*********************************************************************/
        !            55: 
        !            56: unsigned long internal_seed;
        !            57: 
        !            58: void init_rand ( init_seed )
        !            59: 
        !            60: long init_seed;
        !            61: 
        !            62: { internal_seed = ( init_seed > 0 )
        !            63:                  ? (unsigned long) init_seed
        !            64:                  : (unsigned long) timer(); 
        !            65:                 
        !            66: 
        !            67:   /* only odd numbers are acceptable */
        !            68:   if ( internal_seed % 2 == 0 ) internal_seed --;
        !            69: }
        !            70: 
        !            71: /*********************************************************************/
        !            72: /*                                                                   */
        !            73: /* Internal function  irand  may depend on OS and compiler           */
        !            74: /*                                                                   */
        !            75: /* irand assumption:                                                 */
        !            76: /* unsigned long i,j;                                                */
        !            77: /*   if i*j > max(unsigned long)                                     */
        !            78: /*           1. No overflow interruption                             */
        !            79: /*           2. i*j = i*j mod max(unsigned long)                     */
        !            80: /*                                                                   */
        !            81: /* This assumption is true for a lot of computers.                   */
        !            82: /* If your computer fails:                                           */
        !            83: /*   rename: irand <---> xrand                                       */
        !            84: /*                                                                   */
        !            85: /*********************************************************************/
        !            86:  
        !            87: #define  A   1220703125
        !            88: #define  B   2147483647
        !            89: #define  BF  2147483647.
        !            90: 
        !            91: static long irand ()
        !            92: 
        !            93: { internal_seed = ( internal_seed * A ) & B;
        !            94:   return (long) internal_seed ;
        !            95: }
        !            96: 
        !            97: #if 0 /* Not used. */
        !            98: /*********************************************************************/
        !            99: /*                                                                   */
        !           100: /*              computer independent variant of  irand               */
        !           101: /*                                                                   */
        !           102: /*********************************************************************/
        !           103: 
        !           104: 
        !           105: #define T15  32768 
        !           106: #define T16  65536
        !           107: #define A1   37252
        !           108: #define A2   29589
        !           109: 
        !           110: static long xrand()
        !           111: 
        !           112: { unsigned long is1, is2;
        !           113: 
        !           114:   is1 = internal_seed / T15;
        !           115:   is2 = internal_seed % T15;
        !           116: 
        !           117:   internal_seed = ( (((is2 * A1) + (is1 * A2))% T16 )* T15 + (is2 * A2) ) & B;
        !           118:   return (long) ( internal_seed ) ;
        !           119: }
        !           120: #endif
        !           121: 
        !           122: /*********************************************************************/
        !           123: 
        !           124: 
        !           125: double rand01()
        !           126: 
        !           127: { return  (double) (irand() / BF) ;
        !           128: }
        !           129:   
        !           130: /*********************************************************************/
        !           131: 
        !           132: #define NK  12
        !           133: 
        !           134: double randg01()
        !           135: 
        !           136: { int i;
        !           137:   double sum = 0;
        !           138: 
        !           139:   for ( i = 0; i < NK; i++ ) sum += rand01();
        !           140:   return sum - 6.;
        !           141: 
        !           142:   /* if   NK != 12  then you must return (12/NK)*sum - (NK/2) */
        !           143: }
        !           144: 
        !           145: #undef NK
        !           146:      
        !           147:   
        !           148: /*********************************************************************/
        !           149: 
        !           150: long nrand ( n )
        !           151: 
        !           152: long n;
        !           153: 
        !           154: { return (long) ( rand01() * (double) n );
        !           155: }
        !           156: 
        !           157: /*********************************************************************/
        !           158: 
        !           159: #undef A
        !           160: #undef A1
        !           161: #undef A2
        !           162: #undef B
        !           163: #undef BF
        !           164: #undef T15
        !           165: #undef T16