Seeking best ellipse fill function. (For everyone's sake.)

[bplus]

Current fill routine for reference.

Code: QB64: [Select]

1. SUB FlatEllipseFill (ox AS INTEGER, oy AS INTEGER, a AS INTEGER, b AS INTEGER, col AS _UNSIGNED LONG)
2. DIM h2 AS DOUBLE
3. DIM w2 AS DOUBLE
4. DIM h2w2 AS DOUBLE
5. DIM xi AS DOUBLE
6. DIM dx AS DOUBLE
7. DIM x AS DOUBLE
8. DIM y AS DOUBLE
9. w2 = a * a
10. h2 = b * b
11. h2w2 = h2 * w2
12. xi = a
13. dx = 0
14. LINE (ox - a, oy)-(ox + a, oy), col, BF
15. FOR y = 1 TO b
16.     FOR x = xi - dx + 1 TO 0 STEP -1
17.         IF x * x * h2 + y * y * w2 <= h2w2 THEN EXIT FOR
18.     NEXT
19.     dx = xi - x
20.     xi = x
21.     LINE (ox - xi, oy + y)-(ox + xi, oy + y), col, BF
22.     LINE (ox - xi, oy - y)-(ox + xi, oy - y), col, BF
23. NEXT
24. END SUB

IMO this is optimized for clarity:

Code: QB64: [Select]

1. SUB fEllipse (CX AS LONG, CY AS LONG, xRadius AS LONG, yRadius AS LONG, c AS _UNSIGNED LONG)
2.     DIM scale AS SINGLE, x AS LONG, y AS LONG
3.     IF xRadius = 0 OR yRadius = 0 THEN EXIT SUB  '<<<<<<<<<<<<< really do need to skip out with 0
4.     scale = yRadius / xRadius
5.     LINE (CX, CY - yRadius)-(CX, CY + yRadius), c, BF
6.     FOR x = 1 TO xRadius
7.         y = scale * SQR(xRadius * xRadius - x * x)
8.         LINE (CX + x, CY - y)-(CX + x, CY + y), c, BF
9.         LINE (CX - x, CY - y)-(CX - x, CY + y), c, BF
10.     NEXT
11. END SUB

STxAxTIC begins to obscure but optimize for speed by going around using the sq root function with this substitution for SQR, reworking this line:

Code: QB64: [Select]

1. y = scale * SQR(xRadius * xRadius - x * x)
2.  

to this: (except he reworks for x not y)

Code: QB64: [Select]

1.    
2.     FOR x = xi - dx + 1 TO 0 STEP -1
3.         IF x * x * h2 + y * y * w2 <= h2w2 THEN EXIT FOR
4.     NEXT
5.     dx = xi - x
6.     xi = x
7.  

Sorry, this would be clearer if I stuck to same variable names and now I see he is changing X's not Y's when drawing 2 lines.
All that to avoid using SQR, wow! That actually clears up that part of Steve's version for me, thanks.

And now, if he did it for octant instead of just quadrant, we would have something that looks like Steves code, after we also replaced the For loops with While loops since For loops are known to be slowest Loop structure.

[Pete]

Other C programmershave posted this avoid using SQR method online so there is probably some reason for it. My question would be since this project is based on time.... What limits performance the most; using SQR or going from LONG to DOUBLE variables?  In other words, would SQR with LONG be faster or slower than avoiding SQR and using LONG?

Now the one Steve dug up is interesting in that it draws the ellipse in two stages. The only way that could possibly be faster is if part of an ellipse (certain axis) can use fewer calculations; so you use a quicker formula to draw that part and finish it off with the more complex computations in the other part. The problem with that method, as posted, is the boob effect, as Bill puts it. That's some yet unidentified math problem, but seriously, unless that two stage method is faster by design, it should be pitched, rather than corrected, in favor of a single drawing algorithm.

Pete

[bplus]

bplus:

And now, if he did it for octant instead of just quadrant, we would have something that looks like Steves code, after we also replaced the For loops with While loops since For loops are known to be slowest Loop structure.

I was expecting FlatEllipseFill to run twice as long as CircleFill. Wrong! It is already running neck and neck with the proven CircleFill Routine!!!


I added the exit sub if either radius = 0 and I changed all the variables to LONG and I substituted the For loop with a While loop:
I am getting very nearly the same times, sometimes CircleFill faster, sometimes FlatEllipseFill:

Code: QB64: [Select]

1. _TITLE "STATIC Ellipse Fill versus Steve Circle Fill"
2. DEFINT A-Z
3. SCREEN _NEWIMAGE(1220, 680, 32)
4. _SCREENMOVE 100, 20
5. _DELAY 1
6.  
7. FlatEllipseFill 915, 305, 300, 300, _RGBA32(0, 100, 0, 40)
8. FlatEllipseFill 915, 305, 300, 300, _RGBA32(0, 100, 0, 40)
9. INPUT "EllipseFill (fel) overlap test, press enter to continue "; wate$
10. LINE (0, 0)-(600, 20), _RGB32(0, 0, 0), BF
11. start## = TIMER
12. FOR i = 1 TO 10000
13.     FlatEllipseFill 915, 305, 300, 300, _RGBA32(0, 100, 0, 100)
14. NEXT
15. EllipseTime## = TIMER - start##
16. _PRINTSTRING (800, 615), "Time for 10000 EllipseFills:" + STR$(EllipseTime##)
17.  
18.  
19. ' ==================================================== compare to the old gold standard
20.  
21. CircleFill 305, 305, 300, _RGBA32(0, 100, 0, 40)
22. CircleFill 305, 305, 300, _RGBA32(0, 100, 0, 40)
23. LOCATE 1, 1: INPUT "CircleFill overlap test, press enter to continue "; wate$
24. LINE (0, 0)-(600, 20), _RGB32(0, 0, 0), BF
25.  
26. start## = TIMER
27. FOR i = 1 TO 10000
28.     CircleFill 305, 305, 300, _RGBA32(0, 100, 0, 100)
29. NEXT
30. OldCircleTime## = TIMER - start##
31. _PRINTSTRING (200, 615), "Time for 10000 Circle Fills:" + STR$(OldCircleTime##)
32.  
33. 'old circle fill
34. SUB CircleFill (CX AS INTEGER, CY AS INTEGER, R AS INTEGER, C AS _UNSIGNED LONG)
35.     DIM Radius AS INTEGER, RadiusError AS INTEGER
36.     DIM X AS INTEGER, Y AS INTEGER
37.  
38.     Radius = ABS(R)
39.     RadiusError = -Radius
40.     X = Radius
41.     Y = 0
42.  
43.     IF Radius = 0 THEN PSET (CX, CY), C: EXIT SUB
44.  
45.     ' Draw the middle span here so we don't draw it twice in the main loop,
46.     ' which would be a problem with blending turned on.
47.     LINE (CX - X, CY)-(CX + X, CY), C, BF
48.  
49.     WHILE X > Y
50.         RadiusError = RadiusError + Y * 2 + 1
51.         IF RadiusError >= 0 THEN
52.             IF X <> Y + 1 THEN
53.                 LINE (CX - Y, CY - X)-(CX + Y, CY - X), C, BF
54.                 LINE (CX - Y, CY + X)-(CX + Y, CY + X), C, BF
55.             END IF
56.             X = X - 1
57.             RadiusError = RadiusError - X * 2
58.         END IF
59.         Y = Y + 1
60.         LINE (CX - X, CY - Y)-(CX + X, CY - Y), C, BF
61.         LINE (CX - X, CY + Y)-(CX + X, CY + Y), C, BF
62.     WEND
63.  
64. END SUB
65.  
66. SUB FlatEllipseFill (ox AS LONG, oy AS LONG, a AS LONG, b AS LONG, col AS _UNSIGNED LONG)
67.     DIM h2 AS LONG
68.     DIM w2 AS LONG
69.     DIM h2w2 AS LONG
70.     DIM xi AS LONG
71.     DIM dx AS LONG
72.     DIM x AS LONG
73.     DIM y AS LONG
74.     IF a = 0 OR b = 0 THEN EXIT SUB ' B+ added this
75.     w2 = a * a
76.     h2 = b * b
77.     h2w2 = h2 * w2
78.     xi = a
79.     dx = 0
80.     LINE (ox - a, oy)-(ox + a, oy), col, BF
81.     y = 0 ' B+ added this to eliminate FOR loop
82.     WHILE y < b 'b+ no FOR loop
83.         y = y + 1
84.         FOR x = xi - dx + 1 TO 0 STEP -1
85.             IF x * x * h2 + y * y * w2 <= h2w2 THEN EXIT FOR
86.         NEXT
87.         dx = xi - x
88.         xi = x
89.         LINE (ox - xi, oy + y)-(ox + xi, oy + y), col, BF
90.         LINE (ox - xi, oy - y)-(ox + xi, oy - y), col, BF
91.     WEND
92. END SUB
93.  
94.  

So even CircleFill can be pitched as FlatEllipseFill could serve as both a Circle Fill and a Flat Ellipse Fill (as I was going to do with Steve's EllipseFill before the nipple problem was discovered).

Oh dang it, another For loop yet to go!

[Pete]

We already went over variable types that won't work. Just try this...

FlatEllipseFill 915, 305, 400, 200, _RGBA32(0, 100, 0, 40)

That's not an ellipse with variable types using LONG, but it becomes an ellipse if you use DOUBLE variable types. I haven't looked into the number results to see where the number results fail. I know Bill used LONG and INTEGER, which is too limited a type for this... but I just threw in DOUBLE everywhere, which is overkill. I decided to work on some of the numbers and post back...

Pete

[bplus]

We already went over LONG won't work. Just try this...

FlatEllipseFill 915, 305, 400, 200, _RGBA32(0, 100, 0, 40)

That's not an ellipse with LONG variable types, but it becomes an ellipse if you use DOUBLE variable types. I haven't looked into the number results to see where the number results fail. Hopefully, it's not some bug in QB64, but get this, 202, a larger number, works! I just don't have much patience when it comes to puzzles I guess, especially when I can skip right to a solution.

So if it is as fast using DOUBLE, great. If not, that's an issue. Maybe it can be fixed to use LONG by using SQR, or finding out what's wrong with LONG. I'll let you guys determine that, if you wish.

Pete

Sorry, missed that. It's probably the H2W2 number, squaring a square, say a = 400 b = 200 a^2 *b^2 = 6.4 x 10^9
but you say 202 works???

[Pete]

I just edited the post, because it was confusing.

I tried some work with the numbers and this seems to be working out so far...

DIM h2 AS DOUBLE
DIM w2 AS DOUBLE
DIM h2w2 AS DOUBLE
DIM xi AS INTEGER
DIM dx AS INTEGER
DIM x AS INTEGER
DIM y AS INTEGER

I don't need to use a variety of variable types in my work, so feel free to tear into this as needed. I may look into it a _bit more, too.

So far, so good. Running several simulations and it looks to be behaving. Apparently, only the right side of that equation needs to have DOUBLE as the variable type.

Pete

[bplus]

From experimenting with following, I think you have to type them all to cover the max value w2h2 can take:

Code: QB64: [Select]

1. _TITLE "long type test"
2. DIM test AS LONG, big AS _INTEGER64
3. test = 100 'test olny made it to 215 ^ 4 !!!
4. big = test * test * test * test
5. WHILE big > 0 AND test < 1500
6.     test = test + 1
7.     big = test * test * test * test
8. WEND
9. PRINT test, big, (test - 1) ^ 4
10.  
11.  

switch test from LONG type to _INTEGER64

[bplus]

As Pete warned this code did pick up errors at certain a, b with everything LONG, but runs fine with everything at _INTEGER64:

Code: QB64: [Select]

1. _TITLE "Flat Ellipse Fill (dimensions) test" 'edit: fix title
2.  
3. SCREEN _NEWIMAGE(1000, 700, 32)
4. _SCREENMOVE 180, 20
5. 'B+ 2019-02-10 resave this code to
6. 'just test this code for proper filling without overlap, timed tests are else where
7.  
8. FOR i = 0 TO 350 'draw ellipse at various heights
9.  
10.     CLS
11.     PRINT "b Radius"; i; "   press any to get to 400, <backspace> to go back one, <esc> for next test."
12.  
13.     FlatEllipseFill 500, 350, 400, i, _RGBA(255, 255, 255, 40)
14.     'k$ = ""
15.     'WHILE LEN(k$) = 0: k$ = INKEY$: WEND
16.     'IF k$ = CHR$(8) THEN i = i - 2
17.     'IF k$ = CHR$(27) THEN EXIT FOR
18.     _DISPLAY
19.     _LIMIT 5
20. NEXT
21.  
22. FOR i = 0 TO 350 'draw ellipse at various heights
23.  
24.     CLS
25.     PRINT "b Radius"; i; "   press any to get to 400, <backspace> to go back one, <esc> for next test."
26.  
27.     FlatEllipseFill 500, 350, i, 345, _RGBA(255, 255, 255, 40)
28.     'k$ = ""
29.     'WHILE LEN(k$) = 0: k$ = INKEY$: WEND
30.     'IF k$ = CHR$(8) THEN i = i - 2
31.     'IF k$ = CHR$(27) THEN EXIT FOR
32.     _DISPLAY
33.     _LIMIT 5
34.  
35. NEXT
36.  
37. CLS
38. WHILE _KEYDOWN(32) = 0 'check all sorts random stuff
39.     FlatEllipseFill RND * 1000, RND * 700, RND * 100, RND * 100, _RGBA32(255 * RND, 255 * RND, 255 * RND, 100 * RND)
40.     _DISPLAY
41.     _LIMIT 1
42. WEND
43.  
44.  
45. SUB FlatEllipseFill (ox AS _INTEGER64, oy AS _INTEGER64, a AS _INTEGER64, b AS _INTEGER64, col AS _UNSIGNED LONG)
46.     DIM h2 AS _INTEGER64
47.     DIM w2 AS _INTEGER64
48.     DIM h2w2 AS _INTEGER64
49.     DIM xi AS _INTEGER64
50.     DIM dx AS _INTEGER64
51.     DIM x AS _INTEGER64
52.     DIM y AS _INTEGER64
53.     IF a = 0 OR b = 0 THEN EXIT SUB ' B+ added this
54.     w2 = a * a
55.     h2 = b * b
56.     h2w2 = h2 * w2
57.     xi = a
58.     dx = 0
59.     LINE (ox - a, oy)-(ox + a, oy), col, BF
60.     y = 0 ' B+ added this to eliminate FOR loop
61.     WHILE y < b 'b+ no FOR loop
62.         y = y + 1
63.         x = xi - dx + 2
64.         WHILE x >= 1
65.             x = x - 1
66.             IF x * x * h2 + y * y * w2 <= h2w2 THEN EXIT WHILE
67.         WEND
68.         dx = xi - x
69.         xi = x
70.         LINE (ox - xi, oy + y)-(ox + xi, oy + y), col, BF
71.         LINE (ox - xi, oy - y)-(ox + xi, oy - y), col, BF
72.     WEND
73. END SUB
74.  
75.  

I confess a certain a bias to keeping everything out of float types.

[bplus]

Flat Ellipse Fill with all variables at _INTEGER64 is still running neck and neck with Circle Fill, sometimes one or the other has the better time but Circle Fill has the lowest time that I've seen over many tests.

Code: QB64: [Select]

1. _TITLE "STATIC Ellipse Fill versus Steve Circle Fill"
2. DEFINT A-Z
3. SCREEN _NEWIMAGE(1220, 680, 32)
4. _SCREENMOVE 100, 20
5. _DELAY 1
6.  
7. FlatEllipseFill 915, 305, 300, 300, _RGBA32(0, 100, 0, 40)
8. FlatEllipseFill 915, 305, 300, 300, _RGBA32(0, 100, 0, 40)
9. INPUT "Flat EllipseFill overlap test, press enter to continue "; wate$
10. LINE (0, 0)-(600, 20), _RGB32(0, 0, 0), BF
11. start## = TIMER
12. FOR i = 1 TO 10000
13.     FlatEllipseFill 915, 305, 300, 300, _RGBA32(0, 100, 0, 100)
14. NEXT
15. EllipseTime## = TIMER - start##
16. _PRINTSTRING (800, 615), "Time for 10000 Flat Ellipse Fills:" + STR$(EllipseTime##)
17.  
18.  
19. ' ==================================================== compare to the old gold standard
20.  
21. CircleFill 305, 305, 300, _RGBA32(0, 100, 0, 40)
22. CircleFill 305, 305, 300, _RGBA32(0, 100, 0, 40)
23. LOCATE 1, 1: INPUT "CircleFill overlap test, press enter to continue "; wate$
24. LINE (0, 0)-(600, 20), _RGB32(0, 0, 0), BF
25.  
26. start## = TIMER
27. FOR i = 1 TO 10000
28.     CircleFill 305, 305, 300, _RGBA32(0, 100, 0, 100)
29. NEXT
30. OldCircleTime## = TIMER - start##
31. _PRINTSTRING (200, 615), "Time for 10000 Circle Fills:" + STR$(OldCircleTime##)
32.  
33. 'old circle fill
34. SUB CircleFill (CX AS INTEGER, CY AS INTEGER, R AS INTEGER, C AS _UNSIGNED LONG)
35.     DIM Radius AS INTEGER, RadiusError AS INTEGER
36.     DIM X AS INTEGER, Y AS INTEGER
37.  
38.     Radius = ABS(R)
39.     RadiusError = -Radius
40.     X = Radius
41.     Y = 0
42.  
43.     IF Radius = 0 THEN PSET (CX, CY), C: EXIT SUB
44.  
45.     ' Draw the middle span here so we don't draw it twice in the main loop,
46.     ' which would be a problem with blending turned on.
47.     LINE (CX - X, CY)-(CX + X, CY), C, BF
48.  
49.     WHILE X > Y
50.         RadiusError = RadiusError + Y * 2 + 1
51.         IF RadiusError >= 0 THEN
52.             IF X <> Y + 1 THEN
53.                 LINE (CX - Y, CY - X)-(CX + Y, CY - X), C, BF
54.                 LINE (CX - Y, CY + X)-(CX + Y, CY + X), C, BF
55.             END IF
56.             X = X - 1
57.             RadiusError = RadiusError - X * 2
58.         END IF
59.         Y = Y + 1
60.         LINE (CX - X, CY - Y)-(CX + X, CY - Y), C, BF
61.         LINE (CX - X, CY + Y)-(CX + X, CY + Y), C, BF
62.     WEND
63.  
64. END SUB
65.  
66. SUB FlatEllipseFill (ox AS _INTEGER64, oy AS _INTEGER64, a AS _INTEGER64, b AS _INTEGER64, col AS _UNSIGNED LONG)
67.     DIM h2 AS _INTEGER64
68.     DIM w2 AS _INTEGER64
69.     DIM h2w2 AS _INTEGER64
70.     DIM xi AS _INTEGER64
71.     DIM dx AS _INTEGER64
72.     DIM x AS _INTEGER64
73.     DIM y AS _INTEGER64
74.     IF a = 0 OR b = 0 THEN EXIT SUB ' B+ added this
75.     w2 = a * a
76.     h2 = b * b
77.     h2w2 = h2 * w2
78.     xi = a
79.     dx = 0
80.     LINE (ox - a, oy)-(ox + a, oy), col, BF
81.     y = 0 ' B+ added this to eliminate FOR loop
82.     WHILE y < b 'b+ no FOR loop
83.         y = y + 1
84.         x = xi - dx + 2
85.         WHILE x >= 1
86.             x = x - 1
87.             IF x * x * h2 + y * y * w2 <= h2w2 THEN EXIT WHILE
88.         WEND
89.         dx = xi - x
90.         xi = x
91.         LINE (ox - xi, oy + y)-(ox + xi, oy + y), col, BF
92.         LINE (ox - xi, oy - y)-(ox + xi, oy - y), col, BF
93.     WEND
94. END SUB
95.  
96.  

[Pete]

Would using INTEGERS run any faster? My tests I've been running showed me that what I posted previously is true, that only the right side of that equation needed more range, so...

DIM xi AS _INTEGER64
DIM dx AS _INTEGER64
DIM x AS _INTEGER64
DIM y AS _INTEGER64

Could be changed to...

DIM xi AS INTEGER
DIM dx AS INTEGER
DIM x AS INTEGER
DIM y AS INTEGER

Yep, just tested some runs. So you could use...

DIM h2 AS _INTEGER64
DIM w2 AS _INTEGER64
DIM h2w2 AS _INTEGER64
DIM xi AS INTEGER
DIM dx AS INTEGER
DIM x AS INTEGER
DIM y AS INTEGER

In any event, it looks like we have something coming along that meets the requirements nicely. By we, I mean you guys. Sorry I can't be a bigger contributor here. This just isn't my area, but it's fun, and I managed to conjure up a couple of bug fixes.

Pete

[bplus]

Concerning optimizing Type Declarations, I think (or intuit) choosing the largest type needed to do and contain all calculations for all the variables involved and to specially avoid mixing float types with integer types.

[STxAxTIC]

Ooookay where were we? First thought: a speed comparison between a raw circle fill versus an ellipse fill is somewhat of a foregone conclusion. Circles are the simplest shape in the universe, so they had better fill in quickly. Is there room for both functions in the new up-and-coming Toolbox? Hell yes, for two reasons: (i) the forum is empty right now and real estate over there is cheap, and (ii) people who still call them "ovals" probably never heard of ellipses, so those folks may be left wondering how to fill in their circles despite having glazed over a solution.

As an aside, it's lovely that the ellipse and circle-filling functions run at comparable speeds, so minimalists can just download an ellipse-filling routine and be done with the question.

After 5 forum pages I think we may have a few products. You guys are incredibly resilient for sticking to this.

[Pete]

So here's what we have so far with two things I added/changed...

1) Added new variable to reduce equation steps: yyw2 = y * y * w2
2) Substituted DO/LOOP in place of FOR/LOOP for speed considerations.

Code: QB64: [Select]

1. SCREEN _NEWIMAGE(1000, 700, 32)
2. _SCREENMOVE 180, 0
3.  
4. FlatEllipseFill 500, 350, 350, 200, _RGBA(255, 255, 255, 40)
5.  
6. SUB FlatEllipseFill (ox AS INTEGER, oy AS INTEGER, a AS INTEGER, b AS INTEGER, col AS _UNSIGNED LONG)
7. IF a = 0 OR b = 0 THEN EXIT SUB
8. DIM h2 AS _INTEGER64
9. DIM w2 AS _INTEGER64
10. DIM h2w2 AS _INTEGER64
11. DIM yyw2 AS _INTEGER64
12. DIM xi AS INTEGER
13. DIM dx AS INTEGER
14. DIM x AS INTEGER
15. DIM y AS INTEGER
16. w2 = a * a
17. h2 = b * b
18. h2w2 = h2 * w2
19. xi = a
20. dx = 0
21. y = 0
22. LINE (ox - a, oy)-(ox + a, oy), col, BF
23. DO
24.     y = y + 1
25.     yyw2 = y * y * w2
26.     x = xi - dx + 1
27.     DO
28.         IF x * x * h2 + yyw2 <= h2w2 THEN EXIT DO
29.         x = x - 1
30.     LOOP
31.     dx = xi - x
32.     xi = x
33.     LINE (ox - xi, oy + y)-(ox + xi, oy + y), col, BF
34.     LINE (ox - xi, oy - y)-(ox + xi, oy - y), col, BF
35. LOOP UNTIL y = b
36. END SUB
37.  

I don't think it is as elegant with these changes, but since speed is the goal, so be it.

A DO/LOOP actually requires one additional statement than a FOR/NEXT, but if you guys are sure it's still faster, it's all good this way. 

There might be some more optimization possible in these equations and this geometric progression looping approach. Maybe Steve could use his index approach to cut down the number of loops needed, but my guess would be the added conditional statements might add too much time and make it a push at best.

I posted a quick demo using this method at: https://www.tapatalk.com/groups/qbasic/viewtopic.php?f=648955&t=39432

Pete

[SMcNeill]

DO...LOOP is faster than FOR...NEXT just from the way they’re translated into C.  I’ll post a few simple examples in a different topic later, so as to not clutter up this one, but DO will always outperform FOR, from my experience.  (Only by a little, but when speed is the goal, each microsecond adds up.)

[Pete]

The thing Fell likes best about this thread is the KTMB Principle. (Keep the monkeys busy!)

Well, in terms of speed, should we be careful what we wish for, because if DO/LOOP is faster than FOR/NEXT, that's isn't so bad, but do you think GOTO could be faster, still?

Code: QB64: [Select]

1. SCREEN _NEWIMAGE(1000, 700, 32)
2. _SCREENMOVE 180, 0
3.  
4. FlatEllipseFill 500, 350, 350, 200, _RGBA(255, 255, 255, 40)
5.  
6. SUB FlatEllipseFill (ox AS INTEGER, oy AS INTEGER, a AS INTEGER, b AS INTEGER, col AS _UNSIGNED LONG)
7. IF a = 0 OR b = 0 THEN EXIT SUB
8. DIM h2 AS _INTEGER64
9. DIM w2 AS _INTEGER64
10. DIM h2w2 AS _INTEGER64
11. DIM yyw2 AS _INTEGER64
12. DIM xi AS INTEGER
13. DIM dx AS INTEGER
14. DIM x AS INTEGER
15. DIM y AS INTEGER
16. w2 = a * a
17. h2 = b * b
18. h2w2 = h2 * w2
19. xi = a
20. dx = 0
21. y = 0
22. LINE (ox - a, oy)-(ox + a, oy), col, BF
23. 100
24. y = y + 1
25. yyw2 = y * y * w2
26. x = xi - dx + 1
27. 101
28. IF x * x * h2 + yyw2 <= h2w2 THEN 102
29. x = x - 1
30. GOTO 101
31. 102
32. dx = xi - x
33. xi = x
34. LINE (ox - xi, oy + y)-(ox + xi, oy + y), col, BF
35. LINE (ox - xi, oy - y)-(ox + xi, oy - y), col, BF
36. IF y < b THEN 100
37. END SUB
38.