Re: Finding PI using Collisions

[bplus]

I've not seen this before, interesting.

I have seen Pi calculations from throwing random line segment "toothpick" over a grid of equally spaced vertical or horizontal lines. Tons of tests for very slow climb to accuracy to a given limit.

[bplus]

It would be nice if someone could help repair this to get it working.  This would be a fun way to get different digits of _PI.  So far all my efforts has been useless.

By removing the animations, you probably could get the digits even faster.

I think there is a precision problem. You have to start the bounce at the precise moment of collision, not when one block is part way (no matter how little) into the other block or the wall.

You can't just say when blockSmall.x < wall.x or blockSmall.x + blockSmall.width > blockBig.x start the bounce.

Maybe if you back up the blockSmall.x when it has gone too far into wall or blockBig.x, you would also have to adjust the "bounce" of the blockBig.x from exact point in time of collision.

Append: But what if those two adjustments result in another bounce!

[_vince]

I've not seen this before, interesting.

I have seen Pi calculations from throwing random line segment "toothpick" over a grid of equally spaced vertical or horizontal lines. Tons of tests for very slow climb to accuracy to a given limit.

That would be a fun simulation to code, Buffon's needles it's called?  Someone has proposed that challenge on the n54 (not Steve's which happens to look like the JB forum) forum but after it was closed for unregistered users so no responses.

[bplus]

Could you post the link to Shiffman's lesson?

Wait, this!

[bplus]

OK got it working for up to 4 digits:

Code: QB64: [Select]

1. _TITLE "Block PI" ' B+ mod  [banned user] Post 2019-03-20
2.  
3. SCREEN _NEWIMAGE(1300, 200, 32)
4. _SCREENMOVE 80, 200
5. CONST true = -1
6. CONST false = NOT true
7.  
8. DIM SHARED count AS LONG
9. count = 0
10.  
11.  
12. DIM SHARED digits AS INTEGER
13. digits = 4 '<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< works up to 4  then 5 completely fails but if move farther away... almost!
14.  
15.  
16. DIM SHARED timeSteps AS _INTEGER64
17. timeSteps = 10 ^ (digits)
18.  
19. TYPE newBlock
20.     x AS DOUBLE
21.     y AS DOUBLE
22.     w AS INTEGER
23.     v AS DOUBLE
24.     m AS _INTEGER64
25.     xc AS INTEGER 'constraint block x can't go left of
26. END TYPE
27.  
28. DIM SHARED Block(2) AS newBlock
29. Block(1).x = 100 'for 5 digits try 1100
30. Block(1).w = 20
31. Block(1).m = 1
32. Block(1).v = 0
33. Block(1).xc = 0
34.  
35. Block(2).x = 200 'for 5 digits try 1200
36. Block(2).w = 100
37. Block(2).m = 100 ^ (digits - 1)
38. Block(2).v = -1 / (timeSteps + 1)
39. Block(2).xc = 20
40.  
41. WHILE NOT Done
42.     CLS
43.     FOR t = 1 TO timeSteps
44.         Block(1).x = Block(1).x + Block(1).v
45.         Block(2).x = Block(2).x + Block(2).v
46.         checkCollide
47.     NEXT
48.     DrawBlocks
49.     PRINT "Block 1 v ="; Block(1).v
50.     PRINT "Block 2 v ="; Block(2).v
51.     _PRINTSTRING (300, 8), "digits =" + STR$(digits)
52.     _PRINTSTRING (650, 8), "Count:" + STR$(count)
53.     _DISPLAY
54.     _LIMIT 60
55.  
56.     IF Block(2).x > _WIDTH THEN Done = true
57. WEND
58. SLEEP
59.  
60. SUB checkCollide
61.     DIM sm AS DOUBLE
62.     DIM v1 AS DOUBLE
63.     DIM v2 AS DOUBLE
64.  
65.     IF Block(2).x < Block(1).x + Block(1).w THEN 'collision
66.         sm = Block(1).m + Block(2).m
67.         v1 = Block(1).v: v2 = Block(2).v  '<<<<<<<<<<<<<<<<<<<<< make new values from the old ones!!!
68.         Block(1).v = v1 * (Block(1).m - Block(2).m) / sm + v2 * 2 * Block(2).m / sm
69.         Block(2).v = v2 * (Block(2).m - Block(1).m) / sm + v1 * 2 * Block(1).m / sm
70.         count = count + 1
71.     END IF
72.     IF Block(1).x < Block(1).xc THEN Block(1).x = Block(1).xc: count = count + 1: Block(1).v = -Block(1).v
73.     IF Block(2).x < Block(2).xc THEN Block(2).x = Block(2).xc: count = count + 1: Block(2).v = -Block(2).v
74. END FUNCTION
75.  
76. SUB DrawBlocks
77.     LINE (Block(1).x, 200 - Block(1).w)-STEP(Block(1).w, Block(1).w), _RGB32(127, 63, 63), BF
78.     LINE (Block(2).x, 200 - Block(2).w)-STEP(Block(2).w, Block(2).w), _RGB32(63, 63, 127), BF
79. END SUB
80.  
81.  

[bplus]

OK I got 7 digits. It took so long, I'm not interested in trying 8 unless I can make some serious cuts in time.

It only took about 3 main changes to get the code to run correctly (noted in code) compared to previous post.

Code: QB64: [Select]

1. _TITLE "PI Calc from Block Collision Counts" ' B+ mod  Post 2019-03-30
2.  
3. SCREEN _NEWIMAGE(1200, 200, 32)
4. _SCREENMOVE 80, 200
5. CONST true = -1
6. CONST false = NOT true
7.  
8. DIM SHARED count AS _FLOAT
9. count = 0
10.  
11.  
12. DIM SHARED digits AS _FLOAT
13. digits = 7 '<<< got 6 but took half hour, so I closed the gaps between wall, block1 and block2 now it takes 15.5 mins
14.  
15.  
16. DIM SHARED timeSteps AS _FLOAT
17. timeSteps = 10 ^ (digits + 1) 'fix #1, from (digits) to (digits + 1) got me to 5 digits easy!
18.  
19. TYPE newBlock 'all _floats to match [banned user]
20.     x AS _FLOAT
21.     y AS _FLOAT
22.     w AS _FLOAT
23.     v AS _FLOAT
24.     m AS _FLOAT
25.     xc AS _FLOAT 'constraint block x can't go left of
26. END TYPE
27.  
28. DIM SHARED Block1 AS newBlock, Block2 AS newBlock 'cut the array and use block1 and block2 to copy [banned user] approach
29. Block1.x = 1
30. Block1.w = 20
31. Block1.m = 1
32. Block1.v = 0
33. Block1.xc = 0
34.  
35. Block2.x = 22
36. Block2.w = 100
37. Block2.m = 100 ^ (digits - 1)
38. Block2.v = -1 / timeSteps
39. Block2.xc = Block1.w
40. DIM t AS _FLOAT
41. startT$ = TIME$
42. WHILE NOT Done
43.     CLS
44.     FOR t = 1 TO timeSteps
45.         Block1.x = Block1.x + Block1.v
46.         Block2.x = Block2.x + Block2.v
47.         checkCollide
48.     NEXT
49.  
50.     DrawBlocks
51.     PRINT "Block 1 v ="; Block1.v
52.     PRINT "Block 2 v ="; Block2.v
53.     _PRINTSTRING (300, 8), "Digits =" + STR$(digits)
54.     _PRINTSTRING (550, 8), "Count:" + STR$(count)
55.     _PRINTSTRING (750, 8), "Start: " + startT$
56.     _DISPLAY
57.     _LIMIT 60
58.  
59.     'the follwing is excellent stop condition because 6 finishes off screen!!!!!!
60.     'thanks [banned user]
61.     IF Block1.v > 0 AND Block2.v > Block1.v THEN Done = true
62. WEND
63. _PRINTSTRING (950, 8), "Done: " + TIME$
64. _DISPLAY
65. SLEEP
66.  
67. SUB checkCollide
68.     DIM sm AS _FLOAT
69.     DIM v1 AS _FLOAT
70.     DIM v2 AS _FLOAT
71.     IF Block2.x < Block1.x + Block1.w THEN 'collision
72.         sm = Block1.m + Block2.m
73.         v1 = Block1.v: v2 = Block2.v '<<<<<<<<<<<<<<<<<<<<< make new values from the old ones!!!
74.         Block1.v = v1 * (Block1.m - Block2.m) / sm + v2 * 2 * Block2.m / sm
75.         Block2.v = v2 * (Block2.m - Block1.m) / sm + v1 * 2 * Block1.m / sm
76.         count = count + 1
77.     END IF
78.  
79.     IF Block2.x < Block2.xc THEN Block2.x = Block2.xc 'Fix #2 comment out >> : count = count + 1 ': Block2.v = -Block2.v
80.     'this stopped the count inflation for digits = 6
81.  
82.     IF Block1.x < Block1.xc THEN Block1.x = Block1.xc: count = count + 1: Block1.v = -Block1.v
83.  
84. END FUNCTION
85.  
86. SUB DrawBlocks
87.     LINE (Block1.x, 200 - Block1.w)-STEP(Block1.w, Block1.w), _RGB32(127, 63, 63), BF
88.     LINE (Block2.x, 200 - Block2.w)-STEP(Block2.w, Block2.w), _RGB32(63, 63, 127), BF
89. END SUB
90.  
91.  

Here is a record of the last few clicks:

Started at 10:46 AM
By 12:04 PM it was 5 clicks away
BY 12:18 PM it was 4 clicks away
By 12:45 PM it was 3 clicks away
By 13:31 PM it was 2 clicks away
By 14:59 PM it was 1 click away
By 21:05 PM it finally finished

[bplus]

Got the time cut by less than half but still afraid to take a run on 8 digits, though I am curious if the code holds up for 8.

Code: QB64: [Select]

1. _TITLE "mod 2 PI Calc from Block Collision Counts" ' B+ mod  Post 2019-03-30
2. '2019-03-30 can I serious cut time for 6 digits from 15.5 mins? 4:34 now
3. '2019-03-31 7 digit run took 3 hrs 2 mins down from 10 hrs 50 mins (while using computer for other things at same time).
4.  
5. DIM digits AS INTEGER
6. digits = 7 '<<< got 6 but took half hour, so I closed the gaps between wall, block1 and block2 now it takes 15.5 mins
7.  
8. SCREEN _NEWIMAGE(1200, 200, 32)
9. _SCREENMOVE 80, 200
10. TYPE newBlock
11.     x AS _FLOAT
12.     w AS INTEGER
13.     v AS _FLOAT
14.     m AS _INTEGER64
15.     xc AS INTEGER 'constraint block x can't go left of
16. END TYPE
17. DIM timeSteps AS _INTEGER64
18. timeSteps = 10 ^ (digits + 1)
19. DIM Block1 AS newBlock, Block2 AS newBlock
20. Block1.x = 1
21. Block1.w = 20
22. Block1.m = 1
23. Block1.v = 0
24. Block1.xc = 0
25. Block2.x = Block1.x + Block1.w + 10
26. Block2.w = 100
27. Block2.m = 100 ^ (digits - 1)
28. Block2.v = -.5 / timeSteps
29. Block2.xc = Block1.w
30. DIM count AS _INTEGER64
31. DIM t AS _INTEGER64
32. DIM sm AS _FLOAT
33. DIM v1 AS _FLOAT
34. DIM v2 AS _FLOAT
35. startT$ = TIME$
36. DO
37.     t = 0
38.     WHILE t < timeSteps
39.         Block1.x = Block1.x + Block1.v
40.         Block2.x = Block2.x + Block2.v
41.         IF Block2.x < Block1.x + Block1.w THEN 'collision
42.             sm = Block1.m + Block2.m
43.             v1 = Block1.v: v2 = Block2.v
44.             Block1.v = v1 * (Block1.m - Block2.m) / sm + v2 * 2 * Block2.m / sm
45.             Block2.v = v2 * (Block2.m - Block1.m) / sm + v1 * 2 * Block1.m / sm
46.             count = count + 1
47.         END IF
48.         IF Block2.x < Block2.xc THEN Block2.x = Block2.xc
49.         IF Block1.x < Block1.xc THEN Block1.x = Block1.xc: count = count + 1: Block1.v = -Block1.v
50.         t = t + 1
51.     WEND
52.     CLS
53.     LINE (Block1.x, 200 - Block1.w)-STEP(Block1.w, Block1.w), _RGB32(127, 63, 63), BF
54.     LINE (Block2.x, 200 - Block2.w)-STEP(Block2.w, Block2.w), _RGB32(63, 63, 127), BF
55.     PRINT "Block 1 v ="; Block1.v
56.     PRINT "Block 2 v ="; Block2.v
57.     PRINT
58.     PRINT "Block 1 x ="; Block1.x + Block1.w
59.     PRINT "Block 2 x ="; Block2.x
60.     PRINT "X Difference ="; Block2.x - Block1.x - Block1.w
61.     _PRINTSTRING (300, 8), "Digits =" + STR$(digits)
62.     _PRINTSTRING (550, 8), "Count:" + STR$(count)
63.     _PRINTSTRING (750, 8), "Start: " + startT$
64.     _DISPLAY
65. LOOP UNTIL Block1.v > 0 AND Block2.v > Block1.v
66. _PRINTSTRING (950, 8), "Done: " + TIME$
67. _DISPLAY
68. SLEEP
69.  
70.  

Shiffman makes it look so easy with JS, he doesn't get bogged down until running 11 digits.

So I am really interested if anyone can cut the time in QB64 code for times comparable to JS.

[bplus]

Interesting code changes:

When there is a collision, the code backs up the x value to pre-collision spot, counts a bump and changes velocity.
Eliminated the bogging down by TimeSteps and the constraint checks on the blocks.
Does not bother with visual model but just counts bumps.

Sweet!!!  7 digit instantly! 8 in 1 sec, 9 in 10 secs, 10 in 1 min 38 secs!!!

Code: QB64: [Select]

1. _TITLE "mod 3 PI Calc from Block Collision Counts" ' B+ mod  Post 2019-04-02
2. '2019-03-30 can I serious cut time for 6 digits from 15.5 mins? 4:34 now
3. '2019-03-31 7 digit run took 3 hrs 2 mins down from 10 hrs 50 mins (while using computer for other things at same time).
4.  
5. '2019-04-02 [banned user]'s PI Pool changes code thus:
6. '  1. When there is a collision, the code backs up the x value to pre-collision spot, counts a bump and changes velocity.
7. '  2. Eliminated the bogging down by TimeSteps and the constraint checks on the blocks.
8. '  3. Does not bother with visual model but just counts bumps.
9.  
10. DIM digits AS INTEGER
11. digits = 10 ' 7 digit instantly! 8 in 1 sec, 9 in 10 secs, 10 in 1 min 38 secs!!!
12.  
13. SCREEN _NEWIMAGE(800, 200, 32)
14. _SCREENMOVE 300, 200
15. TYPE newBlock
16.     x AS _FLOAT
17.     w AS INTEGER
18.     v AS _FLOAT
19.     m AS _INTEGER64
20. END TYPE
21.  
22. DIM Block1 AS newBlock, Block2 AS newBlock
23. Block1.x = 100
24. Block1.w = 40
25. Block1.m = 1
26. Block1.v = 0
27.  
28. Block2.x = 300
29. Block2.w = 40
30. Block2.m = 100 ^ (digits - 1)
31. Block2.v = -5
32.  
33. DIM count AS _INTEGER64
34. DIM t AS _INTEGER64
35. DIM sm AS _FLOAT
36. DIM v1 AS _FLOAT
37. DIM v2 AS _FLOAT
38. startT$ = TIME$
39. DO
40.     Block1.x = Block1.x + Block1.v
41.     Block2.x = Block2.x + Block2.v
42.     IF Block2.x < Block1.x + Block1.w THEN 'collision backup and change velocities
43.         Block1.x = Block1.x - Block1.v
44.         Block2.x = Block2.x - Block2.v
45.         sm = Block1.m + Block2.m
46.         v1 = Block1.v: v2 = Block2.v '<<<<<<<<<<<<<<<<<<<<< make new values from the old ones!!!
47.         Block1.v = v1 * (Block1.m - Block2.m) / sm + v2 * 2 * Block2.m / sm
48.         Block2.v = v2 * (Block2.m - Block1.m) / sm + v1 * 2 * Block1.m / sm
49.         count = count + 1
50.     END IF
51.     IF Block1.x <= 0 THEN 'back up and change velocity
52.         Block1.x = Block1.x - Block1.v
53.         Block2.x = Block2.x - Block2.v
54.         count = count + 1: Block1.v = -Block1.v
55.     END IF
56. LOOP UNTIL Block1.v > 0 AND Block2.v > Block1.v
57. _PRINTSTRING (10, 8), "Digits =" + STR$(digits)
58. _PRINTSTRING (250, 8), "Start: " + startT$
59. _PRINTSTRING (450, 8), "Done: " + TIME$
60. _PRINTSTRING (10, 28), _TRIM$(STR$(count)) + " Collisions Counted"
61. _PRINTSTRING (10, 48), "314159265358979323846264338327950288419716939937510  [banned user]'s PI reference"
62. SLEEP
63.  
64.