addons/Random/source/IoRandom.c

   1 //metadoc Random copyright Steve Dekorte 2002
   2 //metadoc Random license BSD revised
   3 /*metadoc Random description
   4 A high quality and reasonably fast random number generator based on
   5 Makoto Matsumoto, Takuji Nishimura, and Eric Landry's implementation
   6 of the Mersenne Twister algorithm. The default seed is and xor of
   7 the ANSI C time() and clock() return values.
   8 <p>
   9 Reference:
  10 <p>
  11 <i>
  12 M. Matsumoto and T. Nishimura, <br>
  13 "Mersenne Twister: A 623-Dimensionally Equidistributed Uniform Pseudo-RandomGen Number
  14                                                         Generator", <br>
  15 ACM Transactions on Modeling and Computer Simulation, Vol. 8, No. 1, January 1998, pp 3--30.
  16 </i>
  17 */
  18 //metadoc Random category Math")
  19
  20 #include "IoRandom.h"
  21 #include "IoNumber.h"
  22 #include "RandomGen.h"
  23 #include "BStream.h"
  24
  25 #define DATA(self) ((RandomGen *)(IoObject_dataPointer(self)))
  26
  27 void IoRandom_writeToStream_(IoRandom *self, BStream *stream)
  28 {
  29         RandomGen *r = DATA(self);
  30         int i;
  31
  32         for (i = 0; i < RANDOMGEN_N; i ++)
  33         {
  34                 BStream_writeTaggedUint32_(stream, r->mt[i]);
  35         }
  36
  37         BStream_writeTaggedUint32_(stream, r->mti);
  38 }
  39
  40 void *IoRandom_readFromStream(IoRandom *self, BStream *stream)
  41 {
  42         RandomGen *r = DATA(self);
  43         int i;
  44
  45         for (i = 0; i < RANDOMGEN_N; i ++)
  46         {
  47                 r->mt[i] = BStream_readTaggedUint32(stream);
  48         }
  49
  50         r->mti = BStream_readTaggedUint32(stream);
  51         return self;
  52 }
  53
  54 IoTag *IoRandom_newTag(void *state)
  55 {
  56         IoTag *tag = IoTag_newWithName_("Random");
  57         IoTag_state_(tag, state);
  58         IoTag_cloneFunc_(tag, (IoTagCloneFunc *)IoRandom_rawClone);
  59         IoTag_freeFunc_(tag, (IoTagFreeFunc *)IoRandom_free);
  60         //IoTag_writeToStreamFunc_(tag, (IoTagWriteToStreamFunc *)IoRandom_writeToStream);
  61         //IoTag_readFromStreamFunc_(tag, (IoTagReadFromStreamFunc *)IoRandom_readFromStream);
  62         return tag;
  63 }
  64
  65 IoRandom *IoRandom_proto(void *state)
  66 {
  67         IoMethodTable methodTable[] = {
  68         {"value", IoRandom_value},
  69         {"setSeed", IoRandom_setSeed},
  70         {"flip", IoRandom_flip},
  71         {"gaussian", IoRandom_gaussian},
  72         {"bytes", IoRandom_bytes},
  73         {NULL, NULL},
  74         };
  75
  76         IoObject *self = IoObject_new(state);
  77
  78         IoObject_tag_(self, IoRandom_newTag(state));
  79         IoObject_setDataPointer_(self, RandomGen_new());
  80
  81         RandomGen_chooseRandomSeed(DATA(self));
  82
  83         IoState_registerProtoWithFunc_((IoState *)state, self, IoRandom_proto);
  84
  85         IoObject_addMethodTable_(self, methodTable);
  86         return self;
  87 }
  88
  89 IoNumber *IoRandom_rawClone(IoRandom *proto)
  90 {
  91         IoObject *self = IoObject_rawClonePrimitive(proto);
  92         IoObject_setDataPointer_(self, RandomGen_new());
  93         //RandomGen_chooseRandomSeed(DATA(self));
  94         return self;
  95 }
  96
  97 void IoRandom_free(IoMessage *self)
  98 {
  99         RandomGen_free(DATA(self));
 100 }
 101
 102 IoObject *IoRandom_flip(IoObject *self, IoObject *locals, IoMessage *m)
 103 {
 104         int r = RandomGen_randomInt(DATA(self));
 105         return IOBOOL(self, r & 0x1);
 106 }
 107
 108 IoObject *IoRandom_value(IoObject *self, IoObject *locals, IoMessage *m)
 109 {
 110         /*doc Random value(optionalArg1, optionalArg2)
 111         If called with:
 112         <ul>
 113         <li> no arguments, it returns a floating point
 114         random Number between 0 and 1.
 115         <li> one argument, it returns a floating point random
 116         Number between 0 and optionalArg1.
 117         <li> two arguments, it returns a floating point random
 118         Number between optionalArg1 and optionalArg2.
 119         </ul>
 120         */
 121
 122         double f = RandomGen_randomDouble(DATA(self));
 123         double result = 0;
 124
 125         if (IoMessage_argCount(m) > 0)
 126         {
 127                 double a = IoMessage_locals_doubleArgAt_(m, locals, 0);
 128
 129                 if (IoMessage_argCount(m) > 1)
 130                 {
 131                         double b = IoMessage_locals_doubleArgAt_(m, locals, 1);
 132
 133                         if (a == b )
 134                         {
 135                                 result = a;
 136                         }
 137                         else
 138                         {
 139                                 result = a + (b - a) * f;
 140                         }
 141                 }
 142                 else
 143                 {
 144                         if (a == 0)
 145                         {
 146                                 result = 0;
 147                         }
 148                         else
 149                         {
 150                                 result = a * f;
 151                         }
 152                 }
 153         }
 154         else
 155         {
 156                 result = f;
 157         }
 158
 159         return IONUMBER(result);
 160 }
 161
 162 IoObject *IoRandom_setSeed(IoObject *self, IoObject *locals, IoMessage *m)
 163 {
 164         /*doc Random setSeed(aNumber)
 165         Sets the random number generator seed to the unsign int version of aNumber.
 166         */
 167
 168         unsigned long v = IoMessage_locals_longArgAt_(m, locals, 0);
 169         RandomGen_setSeed(DATA(self), v);
 170         return self;
 171 }
 172
 173 IoObject *IoRandom_gaussian(IoObject *self, IoObject *locals, IoMessage *m)
 174 {
 175         /*doc Random gaussian(optionalMean, optionalStandardDeviation)
 176         Returns a pseudo random number between 0 and 1 with a gaussian distribution.
 177         */
 178
 179         double mean = 0;
 180         double standardDeviation = 1;
 181
 182         if (IoMessage_argCount(m) > 0)
 183         {
 184                 mean = IoMessage_locals_doubleArgAt_(m, locals, 0);
 185         }
 186
 187         if (IoMessage_argCount(m) > 1)
 188         {
 189                 standardDeviation = IoMessage_locals_doubleArgAt_(m, locals, 1);
 190         }
 191
 192         return IONUMBER(RandomGen_gaussian(DATA(self), mean, standardDeviation));
 193 }
 194
 195 IoObject *IoRandom_bytes(IoObject *self, IoObject *locals, IoMessage *m)
 196 {
 197         /*doc Random bytes(count)
 198         Returns a Sequence of size count containing random bytes.
 199         */
 200
 201         size_t i, count = IoMessage_locals_sizetArgAt_(m, locals, 0);
 202         UArray *a;
 203         uint8_t *d = malloc(count);
 204
 205         for(i = 0; i < count; i ++)
 206         {
 207                 d[i] = (uint8_t)(RandomGen_randomInt(DATA(self)) & 255);
 208         }
 209
 210         a = UArray_newWithData_type_size_copy_(d, CTYPE_uint8_t, count, 0);
 211         UArray_setEncoding_(a, CENCODING_NUMBER);
 212
 213         return IoSeq_newWithUArray_copy_(IOSTATE, a, 0);
 214 }