Pascal's Triangle in Preparation - Completed: no need to view this thread

[Qwerkey]

I thought that I'd amuse myself by writing a graphics program representing the pinball demonstration of Pascal's Triangle.  A ball falls under gravity between a triangular array of pins on a board, at each pin the ball has an equal chance of falling to the right or left of the pin.  After a number of goes, the number of passes through each exit is given by the Pascal Triangle formula.

The final version will feature proper ball movement mechanics, acceleration under a constant force (gravity), friction and bouncing off the pins.  This preliminary demo just does the random left-right probabilities.  You will need to let the program run a number of goes to accumulate exit statistics.

Any suggestions for useful features?  Actual ball rolling (as opposed to sliding which will be my default) could be one.  I'll have a proper display for the exit counts (and compared to the Pascal Triangle figures), at least two balls - one travelling through the triangle and one returning from the bottom to Start.

You don't have to point out that this program will not do very much in the way of excitement!

Code: QB64: [Select]

1. CONST BallDiam%% = 60, PinRad%% = 7, Spacing%% = BallDiam%% + 2 * PinRad%% + 6, XScreen% = 900, YScreen% = 700
2. H! = Spacing%% * SQR(3 / 4)
3.  
4. DIM Pascal%(8)
5.  
6. RANDOMIZE (TIMER)
7.  
8. TempImg& = _NEWIMAGE(BallDiam%%, BallDiam%%, 32)
9. _DEST TempImg&
10. _PUTIMAGE (0, 0)-(BallDiam%% - 1, BallDiam%% - 1), _LOADIMAGE("whiteball.png", 32)
11. Ball& = MakeHardware&(TempImg&)
12.  
13. TempImg& = _NEWIMAGE(PinRad%% * 2 + 1, PinRad%% * 2 + 1, 32)
14. _DEST TempImg&
15. FOR N%% = PinRad%% TO 1 STEP -1 '!!! TBF
16.     CIRCLE (PinRad%%, PinRad%%), N%%, _RGB32(CINT(181 * (N%% + 5) / (PinRad%% + 5)), CINT(166 * (N%% + 5) / (PinRad%% + 5)), CINT(66 * (N%% + 5) / (PinRad%% + 5)))
17.     PAINT (PinRad%%, PinRad%%), _RGB32(CINT(181 * (N%% + 5) / (PinRad%% + 5)), CINT(166 * (N%% + 5) / (PinRad%% + 5)), CINT(66 * (N%% + 5) / (PinRad%% + 5)))
18. NEXT N%%
19. Pin& = MakeHardware&(TempImg&)
20.  
21. XPosn%% = 0: YPosn%% = 0
22.  
23. SCREEN _NEWIMAGE(XScreen%, YScreen%, 32)
24. _SCREENMOVE 50, 50
25. _DEST 0
26.  
27. WHILE INKEY$ = ""
28.     _LIMIT 1
29.     '_PUTIMAGE (287, 502), Ball&
30.     _PUTIMAGE (CINT((XScreen% - BallDiam%% + (XPosn%% * Spacing%%)) \ 2), 40 + CINT(H! * YPosn%%) - (BallDiam%% \ 2)), Ball&
31.     '_PUTIMAGE (350, 40), Pin&
32.     'FOR N%% = 0 TO 7 'no. of rows !!! TBF
33.     '    FOR M%% = -(N%% + 1) TO N%% + 1
34.     '        _PUTIMAGE ((XScreen% \ 2) - (Spacing%% * (N%% + 1) / 2) + Spacing%% / 2 + M%% * Spacing%% - PinRad%%, 40 + H! * N%%), Pin&
35.     '    NEXT M%%
36.     'NEXT N%%
37.  
38.     FOR N%% = 0 TO 8 'no. of rows !!! TBF
39.         FOR M%% = -(N%% + 1) TO (N%% + 1) STEP 2
40.             _PUTIMAGE ((XScreen% \ 2) + CINT(M%% * Spacing%% / 2) - PinRad%%, 40 - PinRad%% + CINT(H! * N%%)), Pin&
41.         NEXT M%%
42.     NEXT N%%
43.  
44.     LOCATE 1, 1
45.     FOR N%% = 0 TO 8
46.         PRINT Pascal%(N%%);
47.     NEXT N%%
48.     PRINT
49.  
50.     _DISPLAY
51.  
52.  
53.     YPosn%% = YPosn%% + 1
54.     IF RND < 0.5 THEN
55.         XPosn%% = XPosn%% - 1
56.     ELSE
57.         XPosn%% = XPosn%% + 1
58.     END IF
59.     IF YPosn%% = 8 THEN
60.         Pascal%(4 + XPosn%% / 2) = Pascal%(4 + XPosn%% / 2) + 1
61.     ELSEIF YPosn%% > 8 THEN
62.         XPosn%% = 0: YPosn%% = 0
63.         RANDOMIZE (TIMER)
64.     END IF
65.  
66. WEND
67.  
68. SYSTEM
69.  
70. FUNCTION MakeHardware& (Img&)
71.     MakeHardware& = _COPYIMAGE(Img&, 33)
72.     _FREEIMAGE Img&
73. END FUNCTION
74.  

[FellippeHeitor]

I was hoping to see the balls pile up.

[bplus]

Qwerky, thanks I had not seen this interpretation of Pascal's triangle before, interesting.

The ball movement is OK just increase _LIMIT.

You could maybe get an image of the whole pin triangle to _PUTIMAGE instead of redrawing the pins in loops.

[bplus]

I started checking out this method of moving the ball for bunching up random numbers about a center point and ran into something I did not expect.

If you make an even amount of +1/-1 moves from 0, you will always be an even distance away from 0.
Likewise for odd amounts, you will always be an odd distance away from 0 (and never be back on 0).

Code: QB64: [Select]

1. _TITLE "RND walk + or - 1" 'B+ 2019-04-26
2. RANDOMIZE TIMER
3.  
4. steps = 5 'try odd and even numbers
5.  
6. 'if steps are even all distances from 0 are even
7. 'if steps are odd then all distances from 0 are odd
8. ' This had me scratching my head for a minute until I did it by hand on paper.
9.  
10. DIM results(-steps TO steps) AS INTEGER
11. FOR j = 1 TO 1000
12.     x = 0
13.     FOR i = 1 TO steps
14.         r = RND
15.         IF r < .5 THEN x = x - 1 ELSE x = x + 1
16.         'PRINT r, x
17.     NEXT
18.     'PRINT x,
19.     results(x) = results(x) + 1
20. NEXT
21. 'SLEEP
22. CLS
23. FOR i = -steps TO steps
24.     PRINT i, results(i)
25.     t = t + results(i)
26.     IF i < 0 THEN lt = lt + results(i)
27.     IF i > 0 THEN rt = rt + results(i)
28. NEXT
29. PRINT
30. PRINT "  Total tested amt"; t
31. PRINT "==============================="
32. PRINT "Less than zero amt"; lt
33. PRINT "       Equal 0 amt"; t - rt - lt
34. PRINT "Greater than 0 amt"; rt
35.  
36.  

[Qwerkey]

Fellippe, naturally when I first thought to do this I'd thought of making the balls pile up in columns - the good visual demonstration of Pascal's triangle.  However, the thing that interests me is simulating the mechanics of the balls rolling and bouncing off the pins and whether I could get the simulation to properly do the 50% left-right selection correctly.  That's the engineer talking cf. a mathematician!

For a 9-row triangle, the centre Pascal's triangle number in the ninth row is 70.  The vertical size of the simultaion would be very large and what I want to do is show the ball motions in detail.  So I believe that I'll have to sacrifice the column piling-up (but that would be more entertaining than displaying the numbers).  I might try allowing the piled-up balls to overlap - that might be a (rather silly) compromise.

[Qwerkey]

My memory of the machines which demonstrate this was a little hazy: in the actual machines, the balls do not fall uniquely onto the first row position but are spread out by extra pins (see attached image and check the Wiki page for a video en.wikipedia.org/wiki/Bean_machine).

I am assuming that my method will give the correct result. See image of this preliminary program after 30,000 ball runs, where that ratios relative to the expected Pascal Triangle numbers are given (normalised to the central column).  I was surprised at how large a number of runs was required to get all the column figures near to expected values, but that's randomness for you.