Rand- 16 bits only????

I've started working on evolving constraints using verlet physics, and set up the seed configurations code. I'm using one bit per constraint, representing whether or not the constraint exists. I decided to be clever and fit it all into an int, but rand appears to only create 16 bits. sure, the bits cover a wide range, all the way to the max, but it only generates 16 bits. This is what I get in the debugger:
(displaying the bits)

0100010101001010100000000000000
0010001010111011100000000000000
0100010111101110100000000000000

and so on and so on.....

Any ideas/ fixes

This used to be true.

But with more recent versions of Blitz the values are 32-bit.

Edit: I've just tested this with Blitz3D 1.85 and it looks like random numbers have changed.

For k = 1 To 10
	n = Rand(-2100000000,2100000000)
	DebugLog Bin(n)
Next
Stop

This produces:

10000000110100010010100101101100
01111110100110001101000000101000
10000001000010010001101001111000
10000000100010100000000111111000
01111111100010111000110100000100
01111110110101100111101101000000
01111111100011111100011000101100
10000010001110011110001010110001
10000010110001101111101001001010
01111111010110011111101000110100

These are 32-bit values.

But those bits sure don't look sufficiently random.
I see far too many large blocks of 000000... and 111111...

And here's the output from BlitzPlus 1.37

11101011101110000011110100000000
10111000000010110000111010000000
00110000101000110001110000000000
10101000001110001011100100000000
00010001110000010100110100000000
10101101011111101010101010000000
01000001011101101010110000000000
11011110011111110010100000000000
11110100111101111110110110000000
00010101101101011011011100000000

What's with all those zeroes on the right?

If you run a 100 iterations in B+ you get the following spread of 1's amoung the bit range.
50 50 39 52 49 49 45 49 55 50 50 54 51 58 57 42 52 42 48 38 48 51 53 51 25 10 4 4 0 1 0 0

ie that is the amount of times 1 appeared in that bit after 100 random iterations. 50 would be average with values within 15 on either side to be expected but the last 8 bits do not show a random occurrence. Interesting. To solve it you could try just using four concecutive high bytes.

edit just used the proper max values (-2114125312,2114125312) and still pretty much the same thing.

Hmm. The random number generator isn't very good(sigh) I guess a user version might be good. I'll look up random number generators on the internet and look for algos.

is it as simple as doing:

random# = sin(millisecs()) * maxvalue#

or is there something i'm missing there? (besides needing to feed the number back in, so that you can use seeding to recreate a pattern of numbers

i'm just curious, cause i was pondering random number generation recently and that was my theory on how to do it

My post shows that the first 24 are quite random. You could solve the problem by using doing this
[/code]
n1=rand(-2114125312,2114125312)
n2=rand(-2114125312,2114125312)
n3= n1 shr 8
n4= n2 shr 24
n5=n4 shl24 + n1
[/code]
you could of course use less variables and do it all on one line but this makes it clearer.

that produces:

11111111100100101111000011100000
00000000101110100011110110111010
11111110101011100011000100011100
00000000101100010010100010101000
00000000111100110111101001011000
00000001011100101101101111100110
00000010001100001101111100110100
11111110011001001000000000000100
11111111111100111110100110110000
11111111010011100111011111101010

ugh. it's almost worse.

dan_upright:
The sin function may generate semingly random binarey values, but They would clearly be orderly, ie one number a little above the first, etc.

I forgot to look up generators, I'll check now.

From
http://www.agner.org/random/

Note: this is a typical pseudo-random number generator (note that most random number generators are pseudo; the only true random number generators rely on some allegedly truly random input, such as observations of quantum mechanical behavior).

Mother-of-All
pseudo random number generator

This is a so-called multiply-with-carry or recursion-with-carry generator, invented by George Marsaglia
Algorithm:

S = 2111111111 · Xn-4 + 1492 · Xn-3 + 1776 · Xn-2 + 5115 · Xn-1 + C

Xn = S modulo 232

C = floor(S / 232)

The last four X'es and C are stored in a buffer as 32-bit unsigned integers. The intermediate S is a 64-bit unsigned integer.

The X'es and C are initialized to random values based on a seed. They cannot all be zero.

This algorithm is most effectively implemented in assembly language where you have an instruction for multiplying two 32-bit integers and get a 64-bit product. In high level languages you do not have such an instruction, so you have to use floating point numbers with a mantissa of at least 63 bits. Not all compilers support this precision, for example Microsoft Visual C++ does not.
Specifications:

* 32-bit integer output
* cycle length is 3x10^47
* very good randomness

whoah. cool. It sounds nice. how would this look in blitz code?

somthing like

global x1,x2,x3,x4,C

function rand()
 S=2111111111*X1+1492*X2+1776*X3+5115*X4+C
 x1=x2
 x2=x3
 x3=x4
 x4=S Mod 232
 C=floor(S/232)
end function

Hmm. must have done somthing wrong it's always between -256 and 256.