Is this fast enough as general circle fill?

[SMcNeill]

Sometimes, computers do things that are completely counter-intuitive to us, and we find ourselves having to step back as programmers and simply say, "WOW!!"   Here's a perfect example of that:

Code: QB64: [Select]

1. DIM SHARED Radius AS INTEGER: Radius = 1000
2. DIM SHARED CP(Radius, Radius) AS INTEGER 'CirclePoints
3.  
4.  
5. SCREEN _NEWIMAGE(800, 600, 256)
6. COLOR 15
7.  
8.  
9. PreCalcCircles
10.  
11. x = _WIDTH / 2
12. y = _HEIGHT / 2
13. k = 15
14. TestLoopLimit = 10000
15.  
16. t1 = TIMER(0.001)
17. FOR i = 1 TO TestLoopLimit
18.     CircleFillFast x, y, 300, k
19. NEXT
20.  
21. t2 = TIMER(0.001)
22. FOR i = 1 TO TestLoopLimit
23.     CircleFill x, y, 300, k
24. NEXT
25. t3 = TIMER(0.001)
26.  
27. PRINT USING "##.#### seconds with CircleFillFast"; t2 - t1
28. PRINT USING "##.#### seconds with CircleFill"; t3 - t2
29.  
30.  
31. SUB PreCalcCircles
32.     FOR i = 0 TO Radius 'each circle, for all radius sizes from 1 to limit
33.         FOR j = 0 TO i 'get the points for each line of those circles
34.             CP(i, j) = SQR(i * i - j * j)
35.         NEXT
36.     NEXT
37. END SUB
38.  
39.  
40. SUB CircleFillFast (x, y, Radius, k)
41.     FOR j = 0 TO Radius 'get the points for each line of those circles
42.         LINE (x - CP(Radius, j), y + j)-(x + CP(Radius, j), y + j), k, BF
43.         LINE (x - CP(Radius, j), y - j)-(x + CP(Radius, j), y - j), k, BF
44.     NEXT
45. END SUB
46.  
47. SUB CircleFill (CX AS LONG, CY AS LONG, R AS LONG, C AS LONG)
48.     DIM Radius AS LONG, RadiusError AS LONG
49.     DIM X AS LONG, Y AS LONG
50.  
51.     Radius = ABS(R)
52.     RadiusError = -Radius
53.     X = Radius
54.     Y = 0
55.  
56.     IF Radius = 0 THEN PSET (CX, CY), C: EXIT SUB
57.  
58.     ' Draw the middle span here so we don't draw it twice in the main loop,
59.     ' which would be a problem with blending turned on.
60.     LINE (CX - X, CY)-(CX + X, CY), C, BF
61.  
62.     WHILE X > Y
63.         RadiusError = RadiusError + Y * 2 + 1
64.         IF RadiusError >= 0 THEN
65.             IF X <> Y + 1 THEN
66.                 LINE (CX - Y, CY - X)-(CX + Y, CY - X), C, BF
67.                 LINE (CX - Y, CY + X)-(CX + Y, CY + X), C, BF
68.             END IF
69.             X = X - 1
70.             RadiusError = RadiusError - X * 2
71.         END IF
72.         Y = Y + 1
73.         LINE (CX - X, CY - Y)-(CX + X, CY - Y), C, BF
74.         LINE (CX - X, CY + Y)-(CX + X, CY + Y), C, BF
75.     WEND
76. END SUB
77.  

Here we look at two different circle fill routines -- one, which I'd assume to be faster, which precalculates the offset needed to find the endpoints for each line which composes a circle, and another, which is the same old CircleFill program which I've shared countless times over the years with people on various QB64 forums.

When all is said and done though, CircleFill is STILL even faster than CircleFillFast, which pregenerates those end-points for us!

I've got to admit, I find these results rather shocking!  (Thus the name I chose when naming the CircleFill-NotSoFastAfterall routine.)  Apparently, in this case, the integer math used in CircleFill is faster than the time it takes for QB64 to look up those internal values from a preset array.

Who woulda thunk it?!!

Anywho, I thought I'd share, just so others could look over the two routines and compare.  Maybe there's a way to improve the CircleFillFast so that it'd be faster than CircleFill, but if it is, I'm not seeing it at the moment.

It looks like CircleFill is still the fastest routine to use to rapidly fill a circle for us.  :D

[SMcNeill]

Code: QB64: [Select]

1. DIM SHARED Radius AS INTEGER: Radius = 1000
2. DIM SHARED CP(Radius, Radius) AS INTEGER 'CirclePoints
3.  
4.  
5. SCREEN _NEWIMAGE(800, 600, 256)
6. COLOR 15
7.  
8.  
9. PreCalcCircles
10.  
11. x = _WIDTH / 2
12. y = _HEIGHT / 2
13. k = 15
14. TestLoopLimit = 10000
15.  
16. t1 = TIMER(0.001)
17. FOR i = 1 TO TestLoopLimit
18.     CircleFillFast x, y, 300, k
19. NEXT
20. SLEEP
21.  
22. t2 = TIMER(0.001)
23. FOR i = 1 TO TestLoopLimit
24.     CircleFill x, y, 300, k
25. NEXT
26.  
27. t3 = TIMER(0.001)
28.  
29. PRINT USING "##.#### seconds with CircleFillFast"; t2 - t1
30. PRINT USING "##.#### seconds with CircleFill"; t3 - t2
31.  
32.  
33. SUB PreCalcCircles
34.     FOR i = 0 TO Radius 'each circle, for all radius sizes from 1 to limit
35.         FOR j = 0 TO i 'get the points for each line of those circles
36.             CP(i, j) = SQR(i * i - j * j)
37.         NEXT
38.     NEXT
39. END SUB
40.  
41.  
42. SUB CircleFillFast (x, y, r, k)
43.     DO UNTIL j > r
44.         t = CP(r, j)
45.         LINE (x - t, y + j)-(x + t, y + j), k, BF
46.         LINE (x - t, y - j)-(x + t, y - j), k, BF
47.         j = j + 1
48.     LOOP
49. END SUB
50.  
51. SUB CircleFill (CX AS LONG, CY AS LONG, R AS LONG, C AS LONG)
52.     DIM Radius AS LONG, RadiusError AS LONG
53.     DIM X AS LONG, Y AS LONG
54.  
55.     Radius = ABS(R)
56.     RadiusError = -Radius
57.     X = Radius
58.     Y = 0
59.  
60.     IF Radius = 0 THEN PSET (CX, CY), C: EXIT SUB
61.  
62.     ' Draw the middle span here so we don't draw it twice in the main loop,
63.     ' which would be a problem with blending turned on.
64.     LINE (CX - X, CY)-(CX + X, CY), C, BF
65.  
66.     WHILE X > Y
67.         RadiusError = RadiusError + Y * 2 + 1
68.         IF RadiusError >= 0 THEN
69.             IF X <> Y + 1 THEN
70.                 LINE (CX - Y, CY - X)-(CX + Y, CY - X), C, BF
71.                 LINE (CX - Y, CY + X)-(CX + Y, CY + X), C, BF
72.             END IF
73.             X = X - 1
74.             RadiusError = RadiusError - X * 2
75.         END IF
76.         Y = Y + 1
77.         LINE (CX - X, CY - Y)-(CX + X, CY - Y), C, BF
78.         LINE (CX - X, CY + Y)-(CX + X, CY + Y), C, BF
79.     WEND
80.  
81. END SUB
82.  

And this version is quite a bit faster than the previous one -- but still slower than the original CircleFill routine.  The only real change here for performance?  Using         t = CP(r, j)     and using t in our circle drawing routines instead of CP(r,j).  Referencing arrays are slower than referencing single variables, and we see the change in performance here, noticeably.

[SMcNeill]

*Remove the SLEEP statement in the above routine, which I was using to test things, or else you'll just sit there and not do much of anything while waiting for the program to complete.  I'd placed it there while testing changes and can't go back and edit the above post to remove it.  :P

[Petr]

Hi Steve. NUMERIC TYPES!

Try it now:

Code: QB64: [Select]

1. DIM SHARED Radius AS INTEGER: Radius = 1000
2. DIM SHARED CP(Radius, Radius) AS INTEGER 'CirclePoints
3.  
4.  
5. SCREEN _NEWIMAGE(800, 600, 256)
6. COLOR 15
7.  
8.  
9. PreCalcCircles
10.  
11. x = _WIDTH / 2
12. y = _HEIGHT / 2
13. k = 15
14. TestLoopLimit = 10000
15.  
16. t1 = TIMER(0.001)
17. FOR i = 1 TO TestLoopLimit
18.     CircleFillFast x#, y#, 300, k#
19. NEXT
20.  
21.  
22. t2 = TIMER(0.001)
23. FOR i = 1 TO TestLoopLimit
24.     CircleFill x, y, 300, k
25. NEXT
26.  
27. t3 = TIMER(0.001)
28.  
29. PRINT USING "##.#### seconds with CircleFillFast"; t2 - t1
30. PRINT USING "##.#### seconds with CircleFill"; t3 - t2
31.  
32.  
33. SUB PreCalcCircles
34.     DIM i AS INTEGER, j AS INTEGER
35.     FOR i = 0 TO Radius 'each circle, for all radius sizes from 1 to limit
36.         FOR j = 0 TO i 'get the points for each line of those circles
37.             CP(i, j) = SQR(i * i - j * j)
38.         NEXT
39.     NEXT
40. END SUB
41.  
42.  
43. SUB CircleFillFast (x AS INTEGER, y AS INTEGER, r AS INTEGER, k AS INTEGER)
44.     REDIM t AS INTEGER, j AS INTEGER
45.     DO UNTIL j > r
46.         t = CP(r, j)
47.         LINE (x - t, y + j)-(x + t, y + j), k, BF
48.         LINE (x - t, y - j)-(x + t, y - j), k, BF
49.         j = j + 1
50.     LOOP
51. END SUB
52.  
53. SUB CircleFill (CX AS LONG, CY AS LONG, R AS LONG, C AS LONG)
54.     DIM Radius AS LONG, RadiusError AS LONG
55.     DIM X AS LONG, Y AS LONG
56.  
57.     Radius = ABS(R)
58.     RadiusError = -Radius
59.     X = Radius
60.     Y = 0
61.  
62.     IF Radius = 0 THEN PSET (CX, CY), C: EXIT SUB
63.  
64.     ' Draw the middle span here so we don't draw it twice in the main loop,
65.     ' which would be a problem with blending turned on.
66.     LINE (CX - X, CY)-(CX + X, CY), C, BF
67.  
68.     WHILE X > Y
69.         RadiusError = RadiusError + Y * 2 + 1
70.         IF RadiusError >= 0 THEN
71.             IF X <> Y + 1 THEN
72.                 LINE (CX - Y, CY - X)-(CX + Y, CY - X), C, BF
73.                 LINE (CX - Y, CY + X)-(CX + Y, CY + X), C, BF
74.             END IF
75.             X = X - 1
76.             RadiusError = RadiusError - X * 2
77.         END IF
78.         Y = Y + 1
79.         LINE (CX - X, CY - Y)-(CX + X, CY - Y), C, BF
80.         LINE (CX - X, CY + Y)-(CX + X, CY + Y), C, BF
81.     WEND
82.  
83. END SUB
84.  
85.  

[SMcNeill]

Just changing the types for     CircleFillFast x#, y#, 300, k# , breaks the program.  There is no x# or y# in use anywhere, so you're placing the circle at 0,0 with color 0....  75% of it is drawn off the screen, and that's going to make it appear to run faster than it actually is.

You can't compare speeds of drawing 1/4 of a circle, against speeds of drawing a whole circle.  ;)

You'd need to change all instances of X/Y to become single precision values, and then you end up with similar speed results as before.

Code: QB64: [Select]

1. DIM SHARED Radius AS INTEGER: Radius = 1000
2. DIM SHARED CP(Radius, Radius) AS INTEGER 'CirclePoints
3.  
4.  
5. SCREEN _NEWIMAGE(800, 600, 256)
6. COLOR 15
7.  
8.  
9. PreCalcCircles
10.  
11. x# = _WIDTH / 2
12. y# = _HEIGHT / 2
13. k# = 15
14. TestLoopLimit = 10000
15.  
16. t1 = TIMER(0.001)
17. FOR i = 1 TO TestLoopLimit
18.     CircleFillFast x#, y#, 300, k#
19. NEXT
20.  
21.  
22. t2 = TIMER(0.001)
23. FOR i = 1 TO TestLoopLimit
24.     CircleFill x#, y#, 300, k#
25. NEXT
26.  
27. t3 = TIMER(0.001)
28.  
29. PRINT USING "##.#### seconds with CircleFillFast"; t2 - t1
30. PRINT USING "##.#### seconds with CircleFill"; t3 - t2
31.  
32.  
33. SUB PreCalcCircles
34.     DIM i AS INTEGER, j AS INTEGER
35.     FOR i = 0 TO Radius 'each circle, for all radius sizes from 1 to limit
36.         FOR j = 0 TO i 'get the points for each line of those circles
37.             CP(i, j) = SQR(i * i - j * j)
38.         NEXT
39.     NEXT
40. END SUB
41.  
42.  
43. SUB CircleFillFast (x AS INTEGER, y AS INTEGER, r AS INTEGER, k AS INTEGER)
44.     REDIM t AS INTEGER, j AS INTEGER
45.     DO UNTIL j > r
46.         t = CP(r, j)
47.         LINE (x - t, y + j)-(x + t, y + j), k, BF
48.         LINE (x - t, y - j)-(x + t, y - j), k, BF
49.         j = j + 1
50.     LOOP
51. END SUB
52.  
53. SUB CircleFill (CX AS LONG, CY AS LONG, R AS LONG, C AS LONG)
54.     DIM Radius AS LONG, RadiusError AS LONG
55.     DIM X AS LONG, Y AS LONG
56.  
57.     Radius = ABS(R)
58.     RadiusError = -Radius
59.     X = Radius
60.     Y = 0
61.  
62.     IF Radius = 0 THEN PSET (CX, CY), C: EXIT SUB
63.  
64.     ' Draw the middle span here so we don't draw it twice in the main loop,
65.     ' which would be a problem with blending turned on.
66.     LINE (CX - X, CY)-(CX + X, CY), C, BF
67.  
68.     WHILE X > Y
69.         RadiusError = RadiusError + Y * 2 + 1
70.         IF RadiusError >= 0 THEN
71.             IF X <> Y + 1 THEN
72.                 LINE (CX - Y, CY - X)-(CX + Y, CY - X), C, BF
73.                 LINE (CX - Y, CY + X)-(CX + Y, CY + X), C, BF
74.             END IF
75.             X = X - 1
76.             RadiusError = RadiusError - X * 2
77.         END IF
78.         Y = Y + 1
79.         LINE (CX - X, CY - Y)-(CX + X, CY - Y), C, BF
80.         LINE (CX - X, CY + Y)-(CX + X, CY + Y), C, BF
81.     WEND
82.  
83. END SUB

[SMcNeill]

The best speed I can tend to generate with tweaking things is this (so far): 

Code: QB64: [Select]

1. _DEFINE A-Z AS LONG
2. DIM SHARED Radius AS INTEGER: Radius = 1000
3. DIM SHARED CP(Radius, Radius) AS INTEGER 'CirclePoints
4.  
5.  
6. SCREEN _NEWIMAGE(800, 600, 256)
7. COLOR 15
8.  
9.  
10. PreCalcCircles
11.  
12. x = _WIDTH / 2
13. y = _HEIGHT / 2
14. k = 15
15. TestLoopLimit = 10000
16.  
17. t1# = TIMER(0.001)
18. FOR i = 1 TO TestLoopLimit
19.     CircleFillFast x, y, 300, k
20. NEXT
21.  
22.  
23. t2# = TIMER(0.001)
24. FOR i = 1 TO TestLoopLimit
25.     CircleFill x, y, 300, k
26. NEXT
27.  
28. t3# = TIMER(0.001)
29.  
30. PRINT USING "##.#### seconds with CircleFillFast"; t2# - t1#
31. PRINT USING "##.#### seconds with CircleFill"; t3# - t2#
32.  
33.  
34. SUB PreCalcCircles
35.     FOR i = 0 TO Radius 'each circle, for all radius sizes from 1 to limit
36.         FOR j = 0 TO i 'get the points for each line of those circles
37.             CP(i, j) = SQR(i * i - j * j)
38.         NEXT
39.     NEXT
40. END SUB
41.  
42.  
43. SUB CircleFillFast (x, y, r, k)
44.     dc = _DEFAULTCOLOR
45.     COLOR k
46.     DO UNTIL j > r
47.         t = CP(r, j)
48.         LINE (x - t, y + j)-STEP(t + t, 0), , BF
49.         LINE (x - t, y - j)-STEP(t + t, 0), , BF
50.         j = j + 1
51.     LOOP
52.     COLOR dc
53. END SUB
54.  
55. SUB CircleFill (CX AS LONG, CY AS LONG, R AS LONG, C AS LONG)
56.     DIM Radius AS LONG, RadiusError AS LONG
57.     DIM X AS LONG, Y AS LONG
58.  
59.     Radius = ABS(R)
60.     RadiusError = -Radius
61.     X = Radius
62.     Y = 0
63.  
64.     IF Radius = 0 THEN PSET (CX, CY), C: EXIT SUB
65.     ' Draw the middle span here so we don't draw it twice in the main loop,
66.     ' which would be a problem with blending turned on.
67.     LINE (CX - X, CY)-(CX + X, CY), C, BF
68.  
69.     WHILE X > Y
70.         RadiusError = RadiusError + Y * 2 + 1
71.         IF RadiusError >= 0 THEN
72.             IF X <> Y + 1 THEN
73.                 LINE (CX - Y, CY - X)-(CX + Y, CY - X), C, BF
74.                 LINE (CX - Y, CY + X)-(CX + Y, CY + X), C, BF
75.             END IF
76.             X = X - 1
77.             RadiusError = RadiusError - X * 2
78.         END IF
79.         Y = Y + 1
80.         LINE (CX - X, CY - Y)-(CX + X, CY - Y), C, BF
81.         LINE (CX - X, CY + Y)-(CX + X, CY + Y), C, BF
82.     WEND
83.  
84. END SUB

Speeds on my machine are 0.55 seconds versus 0.50 seconds, so both of them are plenty fast for most instances.  (After all, this is drawing a filled circle the whole size of my screen 10,000 times.)

Maybe if someone wanted/needed the endpoints for collision detection or some other use, then the precalculated values in CircleFillFast would be useful.  As it is though, I suppose I'm still going to have to call CircleFill the quickest routine I've personally seen so far. 

[Petr]

You're right. I did not realize that. Whatever I'm trying to do, it's not better.

[Petr]

Steve, can you please look to this source, why it is so slow? https://www.qb64.org/forum/index.php?topic=287.msg1756#msg1756

[SMcNeill]

Steve, can you please look to this source, why it is so slow? https://www.qb64.org/forum/index.php?topic=287.msg1756#msg1756

Try it with $CHECKING:OFF.

I'll give it a better looking over later tonight, but the wife has me heading out for supper here in a few moments.  $CHECKING might make a noticeable boost in performance for you though. 

[Petr]

I'll try it. Thank you. I'm going to sleep, it's almost midnight here. I'll see it tomorrow.

[SMcNeill]

Advice 2:

Remove:

FUNCTION IN& (x AS INTEGER, y AS INTEGER)
    IN& = (_WIDTH * y + x) * 4
END FUNCTION


Function calls are slow.  Do the math directly, and don't call on _WIDTH.

Early in the routine, use w = _WIDTH, then:

  _MEMPUT m, m.OFFSET + (w * y1 + x) * 4, clr&

[SMcNeill]

Fellippe, when you started with comparing time, which is very beneficial to all, I give this code here. I made the analogy of the LINE command via MEMPUT. Even though I expected great speed, but  the result is to cry. It's a terrible lemur lazy. Could you tell me what I was doing here bad again? Thank you.

Code: QB64: [Select]

1.  
2. DIM SHARED m AS _MEM
3. J& = _NEWIMAGE(800, 600, 32)
4. m = _MEMIMAGE(J&)
5. SCREEN J&
6.  
7. T = TIMER
8.  
9. FOR test = 1 TO 1000
10.     vinceCircleFill 400, 300, 200, _RGB32(0, 255, 0)
11. NEXT test
12.  
13. PRINT TIMER - T
14.  
15. SUB vinceCircleFill (x AS LONG, y AS LONG, R AS LONG, C AS _UNSIGNED LONG)
16.     x0 = R
17.     y0 = 0
18.     e = 0
19.     DO WHILE y0 < x0
20.         IF e <= 0 THEN
21.             y0 = y0 + 1
22.             MEM_LINE x - x0, y + y0, x + x0, y + y0, C
23.             MEM_LINE x - x0, y - y0, x + x0, y - y0, C
24.             e = e + 2 * y0
25.         ELSE
26.             MEM_LINE x - y0, y - x0, x + y0, y - x0, C
27.             MEM_LINE x - y0, y + x0, x + y0, y + x0, C
28.             x0 = x0 - 1
29.             e = e - 2 * x0
30.         END IF
31.     LOOP
32.     MEM_LINE x - R, y, x + R, y, C
33. END SUB
34.  
35. SUB MEM_LINE (x1 AS INTEGER, y1 AS INTEGER, x2 AS INTEGER, y2 AS INTEGER, clr AS LONG)
36.     DEFLNG A-Z
37.     dX = x2 - x1
38.     dY = y2 - y1
39.     IF dX > dY OR dX = dY THEN
40.         x = x1: y = y1
41.         DO WHILE x <> x2
42.             x = x + 1
43.             y = y + (dY / dX)
44.             _MEMPUT m, m.OFFSET + IN&(x, y), clr&
45.         LOOP
46.     END IF
47.     IF dY > dX THEN
48.         x = x1: y = y1
49.         DO WHILE y <> y2
50.             x = x + (dX / dY)
51.             y = y + 1
52.             _MEMPUT m, m.OFFSET + IN&(x, y), clr&
53.         LOOP
54.     END IF
55.     IF x1 = x2 THEN
56.         FOR d = y1 TO y2
57.             _MEMPUT m, m.OFFSET + IN&(x1, d), clr&
58.         NEXT d
59.     END IF
60.     IF y1 = y2 THEN
61.         FOR d = x1 TO x2
62.             _MEMPUT m, m.OFFSET + IN&(d, y1), clr&
63.         NEXT d
64.     END IF
65. END SUB
66.  
67. FUNCTION IN& (x AS INTEGER, y AS INTEGER)
68.     IN& = (_WIDTH * y + x) * 4
69. END FUNCTION
70.  
71.  

A few tweaks to the above code, and you'll see a slight improvement on run time:

Code: QB64: [Select]

1. DIM SHARED m AS _MEM
2. J& = _NEWIMAGE(800, 600, 32)
3. m = _MEMIMAGE(J&)
4. SCREEN J&
5.  
6. T = TIMER
7.  
8. FOR test = 1 TO 1000
9.     vinceCircleFill 400, 300, 200, _RGB32(0, 255, 0)
10. NEXT test
11.  
12. PRINT TIMER - T
13.  
14. SUB vinceCircleFill (x AS LONG, y AS LONG, R AS LONG, C AS _UNSIGNED LONG)
15.     x0 = R
16.     y0 = 0
17.     e = 0
18.     DO WHILE y0 < x0
19.         IF e <= 0 THEN
20.             y0 = y0 + 1
21.             MEM_LINE x - x0, y + y0, x + x0, y + y0, C
22.             MEM_LINE x - x0, y - y0, x + x0, y - y0, C
23.             e = e + 2 * y0
24.         ELSE
25.             MEM_LINE x - y0, y - x0, x + y0, y - x0, C
26.             MEM_LINE x - y0, y + x0, x + y0, y + x0, C
27.             x0 = x0 - 1
28.             e = e - 2 * x0
29.         END IF
30.     LOOP
31.     MEM_LINE x - R, y, x + R, y, C
32. END SUB
33.  
34. SUB MEM_LINE (x1 AS INTEGER, y1 AS INTEGER, x2 AS INTEGER, y2 AS INTEGER, clr AS LONG)
35.     DEFLNG A-Z
36.     $CHECKING:OFF
37.     dX = x2 - x1
38.     dY = y2 - y1
39.     w = _WIDTH
40.     x = x1: y = y1
41.     IF dX >= dY THEN
42.         DO WHILE x <> x2
43.             x = x + 1
44.             y = y + (dY / dX)
45.             _MEMPUT m, m.OFFSET + (w * y + x) * 4, clr
46.         LOOP
47.     ELSE
48.         DO WHILE y <> y2
49.             x = x + (dX / dY)
50.             y = y + 1
51.             _MEMPUT m, m.OFFSET + (w * y + x) * 4, clr
52.         LOOP
53.     END IF
54.     IF x1 = x2 THEN
55.         d = y1
56.         DO UNTIL d > y2
57.             _MEMPUT m, m.OFFSET + (w * d + x1) * 4, clr
58.             d = d + 1
59.         LOOP
60.     END IF
61.     IF y1 = y2 THEN
62.         d = x1
63.         DO UNTIL d > x2
64.             _MEMPUT m, m.OFFSET + (w * y1 + d) * 4, clr
65.             d = d + 1
66.         LOOP
67.     END IF
68.     $CHECKING:ON
69. END SUB

As it was, it took 10.3 seconds to draw 1000 times on my machine.  (I changed the limit from 10,000 to 1,000 so I wouldn't have to wait all night for results.)  The modified version does the same thing in 3.4 seconds.

$CHECKING makes a small change, with 4.3 seconds vs 3.4 seconds for run time, but the greatest change comes from dropping the multiple FUNCTION calls.  They're SLOOOOOOW in relation to other things in QB64 and should generally be avoided as much as possible in situations where speed might be a critical consideration for your program.  Changing the FOR-NEXT loops to DO-LOOP saves a little time as well, though it's mainly one of those things where you'd worry about altering and using AFTER you're certain the code runs right the first time around for you. 

Still, I don't think it'll compare to the times of LINE (x1,y1)-(x2,y2), kolor, BF, since LINE BF has been extensively optimized at the C-level by Galleon, but it's still a nice improvement overall for us.  :)

[Petr]

Steve, thank you for your pretty detailed analysis of the problem. Never thought me to try the reaction time of the functions. It's a shame that such a useful thing as the functions have such a reaction time.

[SMcNeill]

Looking at it fresh this morning, I see another way you could speed it up even more, with the use of some creative math.

        DO WHILE y <> y2
            x = x + (dX / dY)
            y = y + 1
            _MEMPUT m, m.OFFSET + (w * y + x) * 4, clr
        LOOP

If you make y1 and y2 in relation to w to begin with, you could reduce a few math operations in the DO LOOPS...

Y1 = Y1 * w: Y2 = Y2 * w     <---- first line at the start of the SUB

Y = Y + w   <----  in the DO LOOP
_MEMPUT m, m.offset + (y + x) *4, clr    <----  internally in the routine now, Y increments by _WIDTH amount naturally, and we remove a multiplication step of operations.


*************

Since X and Y are interger values, you can probably change the math to be a little more efficient elsewhere as well:

Instead of X = X + (DX / DY), make it X = X + (DX \ DY)

Integer division (\) is considerably faster than real division (/), so if you can use it and need a program to optimize speed, do so. 

****************

Lots of little tricks and tweaks which can be used to optimize speed.  The main thing you have to be *really* careful of is not to obfuscate the code beyond the point of being able to understand it in the future.  Just because you *can* make it faster, it doesn't mean you always *should* -- especially if you alter it so much you can't figure it out and debug it or alter it, at a later date.

Fast is good, but understanding is better.  ;D

[SMcNeill]

In fact, you may be able to remove that * 4 operation completely, if you multiple the X/Y/W values by 4 at the beginning of the program as well.

Then it'd just be a case of _MEMPUT m, m.offset + y + x, clr, which would save several math operations for each DO..LOOP.