Output from tokenized file does not match the .bas output.

[JonD]

I have a created a program to generate random poker hands and display how likely it is to get each type of hand.

I was curious to know how much faster the tokenized (.tkn) file would run, so I added a timer and created the .tkn file.

But when I run the .tkn file, the output is different.  Things display in different places in the window than they should.

I tried to include screenshots of this, but I couldn't figure out how to insert the pictures into the post.  But here is the code:

'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''

'                                                           '

'   Program to show frequency of all ranks of poker hands   '

'                                                           '

'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''



'''''''''''''''''''''''''''''''''

'   Written by: Jon Drechsel    '

'   Latest Revision : 10/9/22   '

'''''''''''''''''''''''''''''''''



' initialize some variables

limit=1000  ' set this to the number of hands you would like to have generated, no more than 99,999,999

true=1 : false=0

showHands=true  ' set to true if you want the last hand of each rank displayed

lines=-1 ' set this to the number of empty lines between each rank's displayed 2 rows of data



totalHands=0  ' total number of poker hands that have been randomly generated

rankNameXpos=3  ' x position of upper left corner of area where rank names are listed

rankNameYpos=4  ' y position ... "                    "                     "

rankCountXpos=17+rankNameXpos  ' x position of upper left corner of area where rank counts are listed

percentXpos=9+rankCountXpos  ' x position of upper left corner of area where percentages are listed

oddsXpos=12+percentXpos  ' x position of left end of area where odds are displayed

handXpos=13+oddsXpos  ' x position of left end of area where hands are displayed



dim     rankCount(10)  ' the count of each type (rank) of poker hand

dim     kindCount(13)  ' the count of each card value, used for checking 2,3, or 4 of a kind, and full house

dim     card(5)  ' the cards in the randomly dealt hand (1-52, 1-13=spade, 14-26=heart, 27-39=diamond, 40-52=club)

dim     cardSuit(5)  ' the suit of each card in the hand (1=spade, 2=heart, 3=diamond, 4=club)

dim     cardValue(5)  ' the value of each card in the hand (1=Ace, 2=2,...., 11=J, 12=Q, 13=K)

dim     sorted(5) ' sorted(1) holds the number of the lowest value card in the hand (1-5)

                 ' sorted(2) holds the number of the next highest value, and so on.

                 ' this is used to determine if a hand is a straight or not

                 ' on 10/8/22 I changed "sort()" to "sorted()" because "sort" is now a command in Just Basic 2.0



' for displaying hands next to the count of each rank

dim     dispSuit$(4) : data "S", "H", "D", "C"

dim     dispValue$(13) : data " A", " 2", " 3", " 4", " 5", " 6", " 7", " 8", " 9", "10", " J", " Q", " K"

for i=1 to 4 : read a$ : dispSuit$(i)=a$ : next i

for i=1 to 13 : read a$ : dispValue$(i)=a$ : next i



' \\\\\\\\\\\\\\\ START OF MAIN PROGRAM ///////////////

' lay out the screen

mainwin 85 26  ' set the size of the main window

'            rank name     calc %     calc odds

data    "    Royal Flush",  0.000154, 649740

data    " Straight Flush",  0.00139 ,  72193.33

data    " Four of a Kind",  0.0240  ,   4165

data    "     Full House",  0.144   ,    694.17

data    "          Flush",  0.197   ,    508.8

data    "       Straight",  0.392   ,    254.8

data    "Three of a Kind",  2.11    ,     47.3

data    "       Two Pair",  4.75    ,     21.03

data    "           Pair", 42.3     ,      2.36

data    "      High Card", 50.1     ,      1.995

locate rankNameXpos, rankNameYpos-2 : print "       Target : "

locate rankCountXpos, rankNameYpos-2 : print using("########", limit)

locate rankNameXpos, rankNameYpos-1 : print "  Total Hands : "

locate oddsXpos, rankNameYpos-1 : print "Odds (1 in _)"

for i=1 to 10

   read rankName$, rankCalculatedProbability, rankCalculatedOdds

   locate rankNameXpos, rankNameYpos+(i-1)*(2+lines) : print rankName$

   locate percentXpos-2, rankNameYpos+(i-1)*(2+lines) : print "0"

   locate oddsXpos-2, rankNameYpos+(i-1)*(2+lines) : print "%"

'    locate rankNameXpos, rankNameYpos+(i-1)*(2+lines)+1 : print "   (Calculated)"

   locate rankNameXpos, rankNameYpos+(i-1)+11 : print rankName$

   locate percentXpos, rankNameYpos+(i-1)+11 : print using("###.######", rankCalculatedProbability)

   locate oddsXpos-2, rankNameYpos+(i-1)+11 : print "%"

   locate oddsXpos, rankNameYpos+(i-1)+11 : print using("########.###", rankCalculatedOdds)

next i



call makeMoreRandom 100  ' pull out a "random" number (using time$("ms")) of rnd() so it's "more" random

   ' Before adding makeMoreRandom, I had trouble with this program giving the exact same "random" result

   ' each time I ran it immediately after opening Just BASIC.



startMS=time$("ms")  ' store current milliseconds since midnight to show elapsed time at the end



' start of loop

do

   call makeMoreRandom 10  ' makes random numbers "more" random by wasting some of them

   gosub [getRandomPokerHand]  ' generates a random 5 card poker hand, and sorts it based on card value

   totalHands=totalHands + 1

   gosub [initializeVariables]

   gosub [checkHandRank]  ' determines the type of poker hand

   rankCount(rank)=rankCount(rank) + 1

   gosub [displayResults]

loop until totalHands=limit



elapsedMS=time$("ms")-startMS  'calculates elapsed time in ms

locate rankNameXpos+2, rankNameYpos+10 : print elapsedMS; " ms elapsed"



end  ' /////////////// END OF MAIN PROGRAM \\\\\\\\\\\\\\\





function random(hi)  ' returns a random number between 1 and hi, inclusive

   random=int(rnd(1)*hi)+1

end function



sub makeMoreRandom n  ' makes random numbers "more" random by wasting some of them, based on milliseconds since midnight

   ti=time$("ms")  ' get current milliseconds since midnight

   randN=ti-n*int(ti/n)  ' set randN to the right most digits, essentially a random number

   for i=1 to randN : dummy=rnd(1) : next i  '  burn randN random numbers, hopefully making cards "more" random

end sub



[getRandomPokerHand]  ' generates a random 5 card poker hand, and sorts it based on card value

   card(1)=random(52) : sorted(1)=1 : call getSuitAndValueOfCard 1

   for i=2 to 5

       do  'until redo is false; i.e. until new card is not the same as another card in the hand

           card(i)=random(52) : redo=false

           ' now to make sure we haven't picked 2 of the exact same card from the deck

           for j=1 to i-1

               if card(j)=card(i) then redo=true : j=i-1  ' leave loop

           next j

       loop until redo=false

       sorted(i)=i

       call getSuitAndValueOfCard i

   next i

   ' now to sort the cards by cardValue and store a pointer to each card in sorted()

   for i=1 to 4

       for j=i+1 to 5

           if cardValue(sorted(i))>cardValue(sorted(j)) then temp=sorted(j) : sorted(j)=sorted(i) : sorted(i)=temp

       next j

   next i

return



sub getSuitAndValueOfCard i

   cardSuit(i)=int((card(i)+12)/13)

   cardValue(i)=card(i)-((cardSuit(i)-1)*13)

end sub



[initializeVariables]

   for i=1 to 4 : suitCount(i)=0 : next i  ' clear out suitCount from previous iteration

   flush=true : straight=true

   rank=10  ' assume rank is worst possible hand (High Card); this changes if the hand turns out to be a better hand

return



[checkHandRank]  ' determines the type of poker hand

   ' now to check for a flush

   flushSuit=cardSuit(1)  ' remember the suit of the 1st card, then check cards 2-5 against it

   for i=2 to 5

       if cardSuit(i)<>flushSuit then flush=false : i=5  ' leave loop

   next i

   ' flush remained true if hand is truly a flush

   ' now to check for a straight, starting with special case ace-hi straight

   aceHiStraight=(cardValue(sorted(1))=1)  ' first sorted card must be and ace for an ace-hi straight to be possible

   for i=2 to 5 : aceHiStraight=aceHiStraight and (cardValue(sorted(i))=(i+8)) : next i  ' 10 thru King

   if flush and aceHiStraight then rank=1 : goto [endCheckHandRank]  ' royal flush

       ' I could have just put "return" instead of "goto [endCheckHandRank]" but it just feels wrong to me

   if aceHiStraight then rank=6 : goto [endCheckHandRank]  ' a non-flush ace-hi straight is still just a straight

   ' if we're here then the hand is neither a royal flush nor an ace-hi straight

   ' now to check for a regular (non ace-hi) straight

   ' since cardValue() is sorted, we can check this sequentially

   ' first we check the first card; if its 10 or higher, we cannot have a straight

   if cardValue(sorted(1))>9 then straight=false : goto [notAStraight]

   for i=2 to 5

       if cardValue(sorted(i))<>(cardValue(sorted(i-1))+1) then straight=false : i=5  ' exit loop

   next i

   ' straight remained true if hand is truly a straight

   if flush and straight then rank=2 : goto [endCheckHandRank]  ' straight flush

   if straight then rank=6 : goto [endCheckHandRank]  ' straight

   [notAStraight]

   if flush    then rank=5 : goto [endCheckHandRank]  ' flush

   ' if we're here then the hand is not a flush or a straight

   ' now to check for 4-of-a-kind, full-house, etc.

   for i=1 to 13 : kindCount(i)=0 : next i  ' clear out kindCount() from previous iteration

   for i=1 to 5  : kindCount(cardValue(i))=kindCount(cardValue(i)) + 1 : next i  ' count up # of each card value

   for i=1 to 13

       if (rank<>7) and (rank<>9) then if kindCount(i)=2 then rank=9 : pairCard=i  ' one pair at least

       if kindCount(i)=3 then rank=7  ' 3-of-a-kind at least, maybe full house too

       if kindCount(i)=4 then rank=3 : i=13  ' 4-of-a-kind; leave loop

   next i

   if rank=3  then [endCheckHandRank]  ' 4 of a kind

   if rank=10 then [endCheckHandRank]  ' High Card

   ' if we're here then hand is 1 pair, 2 pair, 3 of a kind, or full house

   if rank<>7 then [onePair]  ' send one pair down to check for possible 2 pair

   ' if we're here then hand is at least 3 of a kind, now to check for full house

   for i=1 to 13

       if kindCount(i)=2 then rank=4 : i=13  ' leave loop; full house

   next i

   goto [endCheckHandRank]

   [onePair]

   ' if we're here then hand is at least one pair, now to check for 2 pair

   if pairCard=13 then [endCheckHandRank]  ' pair of kings; no other pairs are possible

   for i=pairCard+1 to 13

       if kindCount(i)=2 then rank=8 : i=13  ' leave loop; 2 pair

   next i

   [endCheckHandRank]

return



[displayResults]

   locate rankCountXpos, rankNameYpos-1      : print using("########", totalHands)

   locate rankCountXpos, rankNameYpos+(rank-1)*(2+lines) : print using("########", rankCount(rank))

   for i=1 to 10

       locate percentXpos, rankNameYpos+(i-1)*(2+lines)  : print using("###.######", rankCount(i)/totalHands*100)

       if rankCount(i) then locate oddsXpos, rankNameYpos+(i-1)*(2+lines) : print using("########.###", totalHands/rankCount(i))

   next i

   if showHands then [showHand]

return



[showHand]  ' displays the last hand of each rank beside the count and percentage for each rank

   locate handXpos, rankNameYpos+(rank-1)*(2+lines)

   for i=1 to 5

       print dispValue$(cardValue(i));dispSuit$(cardSuit(i));" ";

   next i

return




I am running on Windows 10 if that matters.

Thanks for any help.

[tsh73]

Hello JonD

Really interesting error
It happends that in compiled version, DATA is not read back correctly
Putting DATA on separate lines
dim     dispSuit$(4)
data "S", "H", "D", "C"
dim     dispValue$(13)
data " A", " 2", " 3", " 4", " 5", " 6", " 7", " 8", " 9", "10", " J", " Q", " K"

saves the day.

[Rod]

Tsh73 has your answer. However creating a .tkn file will not make the code run faster. It will make the code start a little faster. Your .bas file is always compiled to a .tkn file before it is run. You don’t see this using the ide but it happens. Then the interpreter takes over and uses the .tkn to run the compiled basic.

Creating a .tkn file simply saves this compile time which in a large program can be a few seconds or so before the .tkn is ready to run. So startup is faster but the running speed will be exactly the same as running a .bas file.

One way to speed up your program is to show the accumulated results less often, say every 100 or 1000 hands. Updating the display takes time, Windows makes it a chore. So the less you update the screen the faster the program will run.

[plus]

I have a statistical technique question. Are you drawing and replacing to the deck for each card or hand? Because that will change ranking odds compared to say dealing out 5 hands using 25 cards from deck and then reshuffling deck and dealing.

[getRandomPokerHand]  ' generates a random 5 card poker hand, and sorts it based on card value
   card(1)=random(52) : sorted(1)=1 : call getSuitAndValueOfCard 1
   for i=2 to 5
       do  'until redo is false; i.e. until new card is not the same as another card in the hand
           card(i)=random(52) : redo=false
           ' now to make sure we haven't picked 2 of the exact same card from the deck
           for j=1 to i-1
               if card(j)=card(i) then redo=true : j=i-1  ' leave loop
           next j
       loop until redo=false
       sorted(i)=i
       call getSuitAndValueOfCard i
   next i


This looks to me like you are drawing at random of 52 for each card and only if card is already in hand do you redraw.

I recommend starting a deck of 52 and use Fisher Yates or Knuth shuffle and draw cards without replacement.[/code]

[JonD]

tsh73,
Thanks for the solution.  I'm happy it was such any easy fix.

Rod,
Thanks for explaining that about the .tkn file.
I have considered updating the screen less often.  I might do that.

plus,
You raise an interesting question.
Perhaps someone who is an expert in the area of statistics can chime in.
But for this exercise, I believe that my method is sufficient.
When drawing from an actual deck, the chance of any particular card being drawn is 1 in 52 on the first draw.
Then 1 in 51 on the second, 1 in 50 on third, and so on.
In my method, the chances are 1 in 52 for each card I draw, then as you mentioned, I check to see if it has already been drawn, and if so, I draw again.
I think that, as long as the chances for drawing the next card are identical (1 in 52 in this case), there is no advantage given to any single card in the deck to be drawn over any other.
So I think that it doesn't matter, statistically.  It is 1 in 52 vs. 1 in 51 (or 50 and so on).  The chances of any single card being drawn still remain equal to all the other remaining cards.
So while it doesn't exactly match what happens in real life, I believe this model is statistically identical.
You can actually try it yourself if you like.  You can let my program run to a high number and see how closely the random hands it picks match actual real world calculated odds for the hands.
If you do that though, keep in mind that there is currently no way to stop the program before it finishes.  So I would experiment with some lower "limit" numbers (first line of the program) to see how long you want it to run.
Also you can set showHands to false on the 3rd line, which does make it run faster.
Please reply back.  I'm curious to know if I convinced you with my explanation or not.
Thanks.

[plus]

Yes, Rod did good explaining Tkn advantage, thanks Rod .

JonD thank you for your intelligent reply. I am sort of between projects and very tempted to try a ranking run myself with the shuffle and deal method then compare numbers. Someone at another forum made a slot machine with Poker Hands, might be interesting application. Guess I'll get started. I am pretty sure there is not going to be a huge difference if any; if there is difference in numbers it could be just variance between random runs. I also found interesting your "more" random generator, have you seen the complaints we've had in past with JB's Rnd()? Have you run any code experiments testing your Function?

Oh one more question, those odds you have, are they from a source or calculated on your own?

[JonD]

plus,

Actually I just joined this forum 2 days ago to submit this tokenized file issue, so no I haven't seen previous posts about the rnd() function.
And no I haven't run any code experiments testing my makeMoreRandom function.
I was having trouble with rnd() giving me the exact same "random" number sequence each time I ran my program after opening JB, so this is what I came up with to fix that.

As far as the calculated poker hand odds, I did not calculate them myself.
I actually wrote this program about 10 years ago (using JB version 1.01), so I don't actually remember for sure where I got them.
But I believe I may have gotten them from Wikipedia.

[plus]

Still a WIP but starting to get results:

' Poker.bas 2022-10-10 b+ try ranking hands
global Order$
Order$ = " A 2 3 4 5 6 7 8 910 J Q K"
Dim Deck$(52), rankCounts(10)
Call makeDeck
'For i = 1 To 52
'    Print i, Deck$(i)
'Next
'end

Call shuffle
'For i = 1 To 52
'    Print i, Deck$(i)
'Next
'end

'make sure we detect rare occurances
h$ = " AC10C JC QC KC"
Print h$;" = ";RankName$(Rank(h$))
h$ = " KS10S JS QS AS"
Print h$;" = ";RankName$(Rank(h$))
h$ = " AC 3C JC QC KC"
Print h$;" = ";RankName$(Rank(h$))
h$ = " AC 2C 3C 4C 5C"
Print h$;" = ";RankName$(Rank(h$))
h$ = " AS 2C 3C 4C 5C"
Print h$;" = ";RankName$(Rank(h$))
cls
tests = 1000000
while fini = 0
   for k = 0 to 9
       h$ = ""
       For i = 1 To 5
           h$ = h$ + Deck$(k * 5 + i)
       Next
       r = Rank(h$)
       rankCount(r) = rankCount(r) + 1
   next
   hands = hands + 10
   if hands >= tests then fini = 1 else call shuffle
'input "Quit? ";a$
'if a$ = "y" then fini = 1 else call shuffle
wend
for i = 1 to 10
   print rankCount(i);", ";int(rankCount(i)/tests*100);"%, ";RankName$(i)
next

Function RankName$ (RNumber)
   Select Case RNumber
       Case 1: RankName$ = "Royal Flush"
       Case 2: RankName$ = "Straight Flush"
       Case 3: RankName$ = "Four of a Kind"
       Case 4: RankName$ = "Full House"
       Case 5: RankName$ = "Flush"
       Case 6: RankName$ = "Straight"
       Case 7: RankName$ = "Three of a Kind"
       Case 8: RankName$ = "Two Pair"
       Case 9: RankName$ = "Pair"
       Case 10: RankName$ = "High Card"
   End Select
End Function

Function Rank (hand$)
   Dim arrange(13)
   For i = 1 To 5
       v$ = Mid$(hand$, i * 3 - 2, 2)
       f = (InStr(Order$, v$) + 1) / 2
       arrange(f) = arrange(f) + 1
   Next
   For i = 1 To 13
       Select Case arrange(i)
           Case 2: pair = pair + 1
           Case 3: three = 1
           Case 4: four = 1
       End Select
   Next
   If four = 1 Then Rank = 3: Exit Function
   If three = 1 And pair = 1 Then Rank = 4: Exit Function
   If three = 1 Then Rank = 7: Exit Function
   If pair = 2 Then Rank = 8: Exit Function
   If pair = 1 Then
       Rank = 9: Exit Function
   Else ' check flush and straight
       suit$ = Mid$(hand$, 3, 1): flush = 1
       For i = 2 To 5
           If Mid$(hand$, i * 3, 1) <> suit$ Then flush = 0: Exit For
       Next
       i = 1: straight = 1 ' find lowest card i
       While arrange(i) = 0
           i = i + 1
       Wend
       if i = 1 then
           If arrange(10) = 1 And arrange(11) = 1 And arrange(12) = 1 And arrange(13) = 1 Then
               straight = 1 : royal = 1 : goto [FinishRank]
           end if
       end if
       If i >= 10 Then
           straight = 0
       Else
           straight = 1
           For j = i + 1 To i + 4 ' check next 4 cards in sequence
               If arrange(j) <> 1 Then straight = 0: Exit For
           Next
       End If
       [FinishRank]
       If (straight = 1) And (flush = 1) And (royal = 1) Then Rank = 1: Exit Function
       If (straight = 1) And (flush = 1) Then Rank = 2: Exit Function
       If (flush = 1) Then Rank = 5: Exit Function
       If (straight = 1) Then
           Rank = 6
       Else
           Rank = 10
       End If
   End If
End Function

Sub shuffle
   For i = 52 To 2 Step -1
       r = Int(Rnd(1) * i) + 1
       t$ = Deck$(i)
       Deck$(i) = Deck$(r)
       Deck$(r) = t$
   Next
End Sub

Sub makeDeck
   suit$ = "CDHS"
   For s = 1 To 4
       For i = 1 To 13
           Deck$((s - 1) * 13 + i) = Mid$(Order$, (i - 1) * 2 + 1, 2) + Mid$(suit$, s, 1)
       Next
   Next
End Sub

'            rank name     calc %     calc odds
'1data    "    Royal Flush",  0.000154, 649740
'2data    " Straight Flush",  0.00139 ,  72193.33
'3data    " Four of a Kind",  0.0240  ,   4165
'4data    "     Full House",  0.144   ,    694.17
'5data    "          Flush",  0.197   ,    508.8
'6data    "       Straight",  0.392   ,    254.8
'7data    "Three of a Kind",  2.11    ,     47.3
'8data    "       Two Pair",  4.75    ,     21.03
'9data    "           Pair", 42.3     ,      2.36
'10 data    "      High Card", 50.1     ,      1.995



It's getting late but did get one test run of 1 Million:

3, 0%, Royal Flush
14, 0%, Straight Flush
270, 0%, Four of a Kind
1459, 0%, Full House
1842, 0%, Flush
3938, 0%, Straight
20920, 2%, Three of a Kind
48072, 4%, Two Pair
422522, 42%, Pair
500960, 50%, High Card

They seem to be line with the stats JonD brought in his code. Only took 1 Million tries to get 3 Royal Flushes.

So, Straights are really much more frequent than Flushes.

[Rod]

Randomise works a little differently in Just BASIC. Essentially you don’t need it. The prng will always start with a new random number set. If you use the randomise command you are actually forcing the prng to issue a series of repeatable random numbers.

Also if you deal from a shuffled pack you use just one deal. If you deal and test for previous you can loop hundreds of times per deal thus slowing it all down.

[plus]

You know this ranking system is good start but with Pairs being 42% of all hands, we need to declare winner if say 2 players have 2 Fives and both have Ace high card, or say both players have Ace high and King for 2nd high. Then what, go by suits? Has to be to decide between 2 Royal Flushes or Straight Flushes with same high card. High cards and Suits need to add to rank naming system.

[plus]

I would like to continue on with some kind of Poker app where players join in with their AI's so issue of settling ties is huge obstacle until settled.

According to this article:
automaticpoker.com/poker-basics/...-in-poker/

Suits don't matter in tie breakers (of same rank), it's simply Card rank versus card rank from highest to lowest eg A Royal Flush ties another.
Still I think if rank doesn't settle then Suits would but then what's the order alphabetical puts Spades highest Clubs lowest and Diamonds then Hearts next.

And to avoid ties, Poker games should avoid common cards available to all players.

Also there is simple solution to 2 digit Tens, just use T like we do for Ace, Jack, Queen, King... I like! (Royal Flushes are all letters.)

Now for tie breaker function now that we have the tie and suit issue cleared up.