hello, anyone know what the max size integer that can be calculated with rnd statment.
to elaborate:
pseudo random integer = Int((High - Low + 1) * Rnd + Low)
however i want to know that the max allowable number for High in the equation?
Printable View
hello, anyone know what the max size integer that can be calculated with rnd statment.
to elaborate:
pseudo random integer = Int((High - Low + 1) * Rnd + Low)
however i want to know that the max allowable number for High in the equation?
The rnd returns a Single data type. But you're wrapping the code within the int() function so it would be an integer that has a max value of: 32767Quote:
Originally Posted by learning c
:thanks:
ok what about just the rnd statment? it returns a single, however, it isn't a regular single is it as it returns numbers less than 1 and greater than 0.
so what is the number of different unique permutations from rnd statment as well as max and min values?
ok so i tried it out in practice:
sometimes i get:Code:Private Sub Command1_Click()
Dim i&, min, max, rand
min = 1
max = 0
For i = 0 To 10000000
rand = Rnd
If rand > max Then max = rand
If rand < min Then min = rand
Next i
Debug.Print min, max
End Sub
0 0.9999997
sometimes:
3.576279E-07 0.9999999
now that's an odd value for the min value as 3.576279E-07 = 0.0000003576279
so now i am puzzled as to how to find out how many different unique numbers rnd creates :confused:
It returns a single data type. The function itself just happens to not return negative values.
I would assume the Min and max values are min and max of the single data type (–3.402823E+38 to 3.402823E+38).
Maybe someone knows more about the rnd function than I do but I'm pretty sure that's right.
ok here are some more results never below E-07:confused:
0 0.9999997
3.576279E-07 0.9999999
0 0.9999999
1.788139E-07 0.9999999
0 0.9999999
0 0.9999997
2.980232E-07 0.9999999
0 0.9999999
1.788139E-07 0.9999999
0 0.9999999
0 0.9999997
2.980232E-07 0.9999999
0 0.9999999
1.788139E-07 0.9999999
0 0.9999999
0 0.9999997
3.576279E-07 0.9999999
I guess the rnd function returns numbers within that range. Also, try putting "Randomize" in the Form_Load() event and see if that changes anything.
good point, no difference :(Quote:
Originally Posted by DigiRev
You're confusing Int() with CInt(). Int() simply lops off the decimal value, while CInt() does a type conversion to integer.Quote:
Originally Posted by DigiRev
As far as I am aware, there is no upper bound for Int(). Try this in the immediate window:
?int(9999999999999999999)
1E+19
?cint(9999999999999999999)
[Run-time error '6': Overflow]
Int() can handle double values, but you can only assign up to 32767 to integer variable on left side of equation... so for equation above your max is 32767.Quote:
Originally Posted by learning c
As to the OP, I believe Milk when he said in this post:That whole thread is a decent read, and links to this thread which has more discussion, which in turn links to the tutorial on using randomize.Quote:
Originally Posted by Milk
Hopefully something in one of those links will prove helpful.
hey Ellis Dee
i need a pseudo random number at this stage, however i am trying to max the size of the pseudo number i get from rnd.
pseudo random integer = Int((High - Low + 1) * Rnd + Low)
as discussed only gets 16 bit pseudo random numbers, however, isn't a single 32bits? so rnd should be able to create 32bit numbers, i.e support a much higher max value :hmmm:
What's limiting you is the use of an integer data type at the left side of the equation, this pseudo random integer.
you're right :wanders off feeling stupid:Quote:
Originally Posted by leinad31
ok back to this again...
so theorectically rnd is a single and should therefore be able to generate 2^32-1 different numbers...
however when i try and extract them:
Code:
Private Sub Command1_Click()
Dim rand, i&, max, min, maxval
rand = CDec(0): maxval = CDec(4294967295#)
max = CDec(0): min = CDec(0)
For i = 0 To 1000000
rand = Fix((maxval + 1) * Rnd)
'Debug.Print rand
If rand > max Then max = rand
If rand < min Then min = rand
Next i
Debug.Print max, min
End Sub
Private Sub Form_Load()
Randomize Timer
End Sub
i never get all 4294967295 integers :hmmmm:
i think it has something to do with how many bytes are used for the floating point part of the number....
1) There is a fixed sequence of random numbers (16,777,216 of them).
2) The user enters RND(-x) and x is used to determine a start point for this fixed sequence
3) Thereafter, RND returns numbers from this sequence, looping to the beginning as required.
DIM Y as LONG (or DOUBLE) will yield those numbers
Instead of RND(-x) which is useful for restoring saved games to allow playback, simple cryptography, etc., you usually see RANDOMIZE TIMER which is the equivalent of RND(-x) where x=some function of the timer.
That sets essentially a random place for the fixed sequence to return values.
Mac
P.S. Here is a demonstration of the fixed sequence. The function MyRnd shows how random numbers are generated.
True, RND does not return 0-16777215, but returns those numbers divided by 16777216. RND will return this to DOUBLE accuracy if you ask for it.
Code:Option Explicit
Dim Seed As Double
Dim Temp As Double
Private Sub Form_Load()
Randomize Timer
Seed = Rnd * 16777216
Temp = MyRnd
End Sub
Private Function MyRnd() As Double
MyRnd = Seed
Temp = (16598013# * Seed + 12820163)
Seed = Temp - Fix(Temp / 16777216) * 16777216
End Function
Private Sub Command1_Click()
Text1.Text = Str$(Rnd * 16777216) + Space$(10) + Str$(MyRnd)
End Sub
Int can handle even the maximum "integer" number possible in VB6.
Increment that by one and you get an error: and the error is raised by CDec function, because it goes off the range of the Decimal datatype. That is the maximum accuracy you can get for a number. Double lets you have bigger numbers than that, but it loses accuracy from the end (ie. you see zero instead of the correct numbers).Code:MsgBox Int(CDec("79228162514264337593543950335"))
You can run Rnd against that:And what about the datatype?Code:Randomize
MsgBox Rnd * CDec("79228162514264337593543950335")
Should return True: Rnd's result is coerced into Decimal.Code:MsgBox VarType(Rnd * CDec("79228162514264337593543950335")) = vbDecimal
However, Decimal isn't an integer datatype really; I'm not fully sure what it is, because it doesn't behave fully like floating datatypes should behave. I guess it is a form of a hacked integer like Currency, but can have the decimal point set more freely.
I also tested the result of running Rnd against Decimal datatype: the results held a lot of digits, which confirms Rnd's result was coerced into Decimal:
Warning! This runs for a long time, Variant is a slow datatype, not to forget math is far slower under IDE than compiled. As you can also see, it is very unlikely to hit the maximum number in a loop that loops far less than the amount of maximum number.Code:Dim decTest As Variant, decResult As Variant, lngA As Long, decMax As Variant
Randomize
decTest = CDec("79228162514264337593543950335")
For lngA = 0 To 100000000
decResult = Rnd * decTest
If decResult > decMax Then decMax = decResult
Next lngA
MsgBox decTest & vbNewLine & decMax
One thing that comes with Rnd being coerced into Decimal is that the results don't often held any digits below the decimal point: and if they do, it is unlikely there is many of them:I get only about a 1/10 ratio. Of course, this is due to the nature of Decimal in the maximum range of digits it can hold. Going for smaller numbers should give more numbers with digits under the decimal point, up to the point you get them almost every time.Code:Dim decTest As Variant, decResult As Variant, lngA As Long, lngCount As Long
Randomize
decTest = CDec("79228162514264337593543950335")
For lngA = 0 To 10000
decResult = Rnd * decTest
If decResult <> Int(decResult) Then lngCount = lngCount + 1
Next lngA
MsgBox decTest & vbNewLine & lngCount & " of 10000 with digits below decimal point"
Great post, Merri.
I would just like to ensure that nobody thinks that it is possible to generate 79228162514264337593543950335 random numbers.Quote:
Originally Posted by Merri
There is a fixed set of 16777216 "random numbers" that is always produced. The list contains 0/16777216 thru 16777215/16777216 in a certain fixed sequence per formula I suppied earlier here.
RANDOMIZE determines where, in that fixed set, you will start getting numbers.
This will generate all possible results of using the big number
The following will run foreverCode:dim zlist(0 to 16777215) as magic place to hold giant numbers
dim i as long
for i=0 to 16777215
zlist(i)=(i*79228162514264337593543950335)/16777216
next i
Put another way: If all RND ever returned was 0,.25,.50,.75 thenCode:dim r as magic place to hold giant numbers
do
r=RND*79228162514264337593543950335
for i=0 to 16777215
if r= zlist(i) then exit for
next i
loop while i<16777215 'i.e. we found a match
RND*1000 would only return 0, 250, 500, and 750. It would never return any other number such as 435.
Sorry to bore you. Probably you all knew that anyway, but it looked like someone could think there can be a huge collection of random numbers. There is exactly 16777216 in BASICA, QBasic, VB, etc. No more, no less.
Mac
Mr. Mac: my point was mostly to answer the thread's first question, the maximum number you can use with it; not to see what are the limitations of Rnd function. Your sample code has a few errors, but that's not very important as you were merely stating the same you already said in your earlier post.
However, to not let too many people down, it is possible get more randomness with custom randomizing function. I bothered to code something, not something that is very great but it should be good enough for far bigger accuracy than what you can get with only Rnd.
I didn't bother to count the biggest number this gives out or how random it really is in the long run. It should make most people happy enough. I don't know in what kind of situatation someone would need so big random numbers (when coding with VB): but if someone had a real need for really random numbers big numbers, he'd have to look for more information on the subject.Code:Public Function DecRnd() As Variant
Dim dblResult As Double
dblResult = CDbl(Rnd) + CDbl(Time) + (CDbl(Timer) - CDbl(Int(Timer)))
DecRnd = (CDec(Rnd * 16777216) * CDec(GetTickCount And &H7FFFFF) * CDec(dblResult - Int(dblResult)) * CDec("1449551462400"))
End Function
The concept we are dealing with is the count of possible random numbers, not accuracy. RND is perfectly "accurate". It just doesn't have a huge number of possible outcomes.Quote:
Originally Posted by Merri
I couldn't analyze your algorithm to figure out the possibilities. I'm sure many.
To answer your question about situation: If one is encrypting a message using RND, one needs more possible random numbers. I could supply a good algorithm, but I doubt anyone on this forum is interested.
Mac
I'm starting to believe there is some kind of difference between the Finnish and English word for accurate as this is what, fifth time somebody gets on that word once I've used it :D
thanks for your posts guys :D i think i was on the wrong path, i was trying to calculate one large 32bit+ pseudo random number and extract 3 or 4 btyes from it as an optimisation, however, i think that extracting the bytes from the 32bit number may take longer than getting 4 separate single bytes.
but for interest's sake in case anyone else has to deal with it i found that you cannot reproduce the rnd sequence with vb6 code (from ms's website), so it is best to create your own algorithm based on sources in books or elsewhere on the net.
i may come back to this if my app needs more optimising.
What you say confuses me as the algorithm I showed exactly and perfectly reproduces the RND sequence (with VB5 code that I presume works in VB6).Quote:
Originally Posted by learning c
So you must be talking about something else.
Mac
Despite this being a rhetorical statement, I'll toss in my two cents:Quote:
Originally Posted by Merri
Accuracy is often mistakenly used when the concept being conveyed is precision. Accuracy is synonymous with correctness, while precision is synonymous with scale. "Accurate to 1 millimeter" tells us that a measurement is correct, and the precision of that measurement is 1 millimeter. Another way of looking at it would be those "margin of error: +/- 5%" qualifiers, which quantify accuracy but say nothing about precision.
But in the specific example in this thread, the concept you were trying to convery was neither accuracy nor precision, but rather spread. As in, how many elements in the set of possible results.