Fun Math Graphics

[SierraKen]

Yeah, math is not fun, but last night I was tinkering with my analog clock equations and finished this today. It's 11 pictures using the same equations, just different numbers. The 12th (last) one uses different equations but similar. Thanks to the Internet for the original first and last equations, I don't know how they work but they do. :) Feel free to use any of these in your own programs.

Code: QB64: [Select]

1. 'There are 12 mathematically made pictures on this program.
2. 'The first 11 use the same equations, just different numbers.
3. 'The 12th is a little bit different.
4. 'Feel free to use any of these in your own programs.
5. 'Finished on July 22, 2019.
6.  
7. _TITLE "Fun Math Graphics"
8. SCREEN _NEWIMAGE(640, 480, 32)
9. CLS
10. PRINT "                             Fun Math Graphics"
11. PRINT: PRINT: PRINT
12. PRINT "                                 by Ken G."
13. PRINT: PRINT: PRINT
14. PRINT "         11 of these pictures are drawn using the same equations,"
15. PRINT "         just with different numbers. The 12th is similar but different."
16. PRINT: PRINT: PRINT
17. PRINT: PRINT: PRINT
18. INPUT "                           Press Enter to start.", a$
19. CLS
20. PRINT "1"
21. one:
22. seconds = seconds + .01
23. s = (60 - seconds) * 6 + 180
24. x = INT(SIN(s / 180 * 3.141592) * 180) + 325
25. y = INT(COS(s / 180 * 3.141592) * 180) + 225
26. CIRCLE (x, y), 2, _RGB32(127, 216, 127)
27. IF seconds > 60 THEN
28.     seconds = 0
29.     _DELAY 2
30.     CLS
31.     PRINT "2"
32.     GOTO two:
33. END IF
34. _DELAY .001
35. GOTO one:
36.  
37. two:
38. seconds = seconds + .01
39. s = (60 - seconds) * 6 + 180
40. x = INT(SIN(s / 90 * 3.141592) * 180) + 325
41. y = INT(COS(s / 180 * 3.141592) * 180) + 225
42. CIRCLE (x, y), 2, _RGB32(127, 216, 127)
43. IF seconds > 60 THEN
44.     seconds = 0
45.     _DELAY 2
46.     CLS
47.     PRINT "3"
48.     GOTO three:
49. END IF
50. _DELAY .001
51. GOTO two:
52.  
53. three:
54. seconds = seconds + .01
55. s = (60 - seconds) * 6 + 180
56. x = INT(SIN(s / 180 * 3.141592) * 180) + 325
57. y = INT(COS(s / 90 * 3.141592) * 180) + 225
58. CIRCLE (x, y), 2, _RGB32(127, 216, 127)
59. IF seconds > 60 THEN
60.     seconds = 0
61.     _DELAY 2
62.     CLS
63.     PRINT "4"
64.     GOTO four:
65. END IF
66. _DELAY .001
67. GOTO three:
68.  
69. four:
70. seconds = seconds + .01
71. s = (60 - seconds) * 6 + 180
72. x = INT(SIN(s / 135 * 3.141592) * 180) + 325
73. y = INT(COS(s / 33.75 * 3.141592) * 180) + 225
74. CIRCLE (x, y), 2, _RGB32(127, 216, 127)
75. IF seconds > 60 THEN
76.     seconds = 0
77.     _DELAY 2
78.     CLS
79.     PRINT "5"
80.     GOTO five:
81. END IF
82. _DELAY .001
83. GOTO four:
84.  
85. five:
86. seconds = seconds + .01
87. s = (60 - seconds) * 6 + 180
88. x = INT(SIN(s / 360 * 3.141592) * 180) + 325
89. y = INT(COS(s / 45 * 3.141592) * 180) + 225
90. CIRCLE (x, y), 2, _RGB32(127, 216, 127)
91. IF seconds > 60 THEN
92.     seconds = 0
93.     _DELAY 2
94.     CLS
95.     PRINT "6"
96.     GOTO six:
97. END IF
98. _DELAY .001
99. GOTO five
100.  
101. six:
102. seconds = seconds + .01
103. s = (60 - seconds) * 6 + 180
104. x = INT(SIN(s / 90 * 3.141592) * 180) + 325
105. y = INT(COS(s / 360 * 3.141592) * 180) + 225
106. CIRCLE (x, y), 2, _RGB32(127, 216, 127)
107. IF seconds > 60 THEN
108.     seconds = 0
109.     _DELAY 2
110.     CLS
111.     PRINT "7"
112.     GOTO seven:
113. END IF
114. _DELAY .001
115. GOTO six:
116.  
117. seven:
118. seconds = seconds + .01
119. s = (60 - seconds) * 6 + 180
120. x = INT(SIN(s / 45 * 3.141592) * 180) + 325
121. y = INT(COS(s / 360 * 3.141592) * 180) + 225
122. CIRCLE (x, y), 2, _RGB32(127, 216, 127)
123. IF seconds > 60 THEN
124.     seconds = 0
125.     _DELAY 2
126.     CLS
127.     PRINT "8"
128.     GOTO eight:
129. END IF
130. _DELAY .001
131. GOTO seven:
132.  
133. eight:
134. seconds = seconds + .01
135. s = (60 - seconds) * 6 + 180
136. x = INT(SIN(s / 120 * 3.141592) * 180) + 325
137. y = INT(COS(s / 5.1428 * 3.141592) * 180) + 225
138. CIRCLE (x, y), 2, _RGB32(127, 216, 127)
139. IF seconds > 60 THEN
140.     seconds = 0
141.     _DELAY 2
142.     CLS
143.     PRINT "9"
144.     GOTO nine:
145. END IF
146. _DELAY .001
147. GOTO eight:
148.  
149. nine:
150. seconds = seconds + .01
151. s = (60 - seconds) * 6 + 180
152. x = INT(SIN(s / 360 * 3.141592) * 180) + 325
153. y = INT(COS(s / 6 * 3.141592) * 180) + 225
154. CIRCLE (x, y), 2, _RGB32(127, 216, 127)
155. IF seconds > 60 THEN
156.     seconds = 0
157.     _DELAY 2
158.     CLS
159.     PRINT "10"
160.     GOTO ten
161. END IF
162. _DELAY .001
163. GOTO nine:
164.  
165. ten:
166. seconds = seconds + .01
167. s = (60 - seconds) * 6 + 180
168. x = INT(SIN(s / 360 * 3.141592) * 180) + 325
169. y = INT(COS(s / 11.25 * 3.141592) * 180) + 225
170. CIRCLE (x, y), 2, _RGB32(127, 216, 127)
171. IF seconds > 60 THEN
172.     seconds = 0
173.     _DELAY 2
174.     CLS
175.     PRINT "11"
176.     GOTO eleven:
177. END IF
178. _DELAY .001
179. GOTO ten:
180.  
181. eleven:
182. seconds = seconds + .01
183. s = (60 - seconds) * 6 + 180
184. x = INT(SIN(s / 360 * 3.141592) * 180) + 325
185. y = INT(COS(s / 1.57 * 3.141592) * 180) + 225
186. CIRCLE (x, y), 2, _RGB32(127, 216, 127)
187. IF seconds > 60 THEN
188.     seconds = 0
189.     _DELAY 2
190.     CLS
191.     PRINT "12"
192.     GOTO twelve:
193. END IF
194. _DELAY .001
195. GOTO eleven:
196.  
197. twelve:
198. s = 0
199. FOR d = 160 TO 0 STEP -.125
200.     s = s + 1
201.     x = COS(s * 3.141592 / 180) * d
202.     y = SIN(s * 3.151492 / 180) * d
203.     CIRCLE (x + 325, y + 225), 2, _RGB32(127, 216, 127)
204.     _DELAY .001
205. NEXT d
206.  

[SierraKen]

From my website:
Watch your computer draw a circle, elipses, curves, peaks, valleys, meshes of peaks, etc. all done with the same equation but just using different numbers. At the end I added different equations to make a spiral.

[SMcNeill]

Ken, you write some nice programs and examples, but you tend to work yourself to death doing so.

Your program comes in at 206 lines of code; here's the exact same thing, down to about 1/4th that size:

Code: QB64: [Select]

1. 'There are 12 mathematically made pictures on this program.
2. 'The first 11 use the same equations, just different numbers.
3. 'The 12th is a little bit different.
4. 'Feel free to use any of these in your own programs.
5. 'Finished on July 22, 2019.
6.  
7. _TITLE "Fun Math Graphics"
8. SCREEN _NEWIMAGE(640, 480, 32)
9. CLS
10. PRINT "                             Fun Math Graphics"
11. PRINT: PRINT: PRINT
12. PRINT "                                 by Ken G."
13. PRINT "                         Modified by Steve McNeill."
14. PRINT: PRINT: PRINT
15. PRINT "         11 of these pictures are drawn using the same equations,"
16. PRINT "         just with different numbers. The 12th is similar but different."
17. PRINT: PRINT: PRINT
18. PRINT: PRINT: PRINT
19. INPUT "                           Press Enter to start.", a$
20. DrawIt 180, 180 '1
21. DrawIt 90, 180 '2
22. DrawIt 180, 90 '3
23. DrawIt 135, 33.75 '4
24. DrawIt 360, 45 '5
25. DrawIt 90, 360 '6
26. DrawIt 45, 360 '7
27. DrawIt 120, 5.1428 '8
28. DrawIt 360, 6 '9
29. DrawIt 360, 11.25 '10
30. DrawIt 360, 1.52 '11
31.  
32. CLS: PRINT "12"
33. FOR d = 160 TO 0 STEP -.125
34.     s = s + 1
35.     x = COS(s * 3.141592 / 180) * d
36.     y = SIN(s * 3.151492 / 180) * d
37.     CIRCLE (x + 325, y + 225), 2, _RGB32(127, 216, 127)
38.     _DELAY .001
39. NEXT d
40.  
41. SUB DrawIt (xmod, ymod)
42.     STATIC N: N = N + 1
43.     CLS: PRINT N
44.     DO
45.         seconds = seconds + .01
46.         s = (60 - seconds) * 6 + 180
47.         x = INT(SIN(s / xmod * 3.141592) * 180) + 325
48.         y = INT(COS(s / ymod * 3.141592) * 180) + 225
49.         CIRCLE (x, y), 2, _RGB32(127, 216, 127)
50.         _DELAY .001
51.     LOOP UNTIL seconds > 60
52.     _DELAY 2
53. END SUB

When you have "11 pictures using the same equations, just different numbers", you don't need to write 11 different code segments for those equations.  You only need to write one SUB, and call it with the variables which change.

IF you wanted to change your program so that it would run with 100 different examples, instead of 11, you'd have to go in and copy/paste your work 100 different times and then modify the goto labels and amounts.  IF I wanted to change my alteration of your work to run 100, different examples, all I'd have to do is just go in and call DrawIt with an additional 89 xmod/ymod values...

Use of SUB/FUNCTION reduces the burden on both the programmer and the program significantly.  You definitely should look into incorporating their usage into your programs ASAP, and you'll see that your productivity will increase by leaps and bounds, and your programs size/efficiency will also improve by notable effects.

And, one last caveat:  Since you're writing code to teach others, try to reduce the usage of GOTO so much in your code.  It makes the readabily and understanding of the code much more difficult to follow (and heavy usage is one reason why some programmers call BASIC a language which makes programmers stupid), and often its not needed at all.  Let's take a moment to compare two code structures:

Code: QB64: [Select]

1. CLS
2. PRINT "1"
3. one:
4. seconds = seconds + .01
5. s = (60 - seconds) * 6 + 180
6. x = INT(SIN(s / 180 * 3.141592) * 180) + 325
7. y = INT(COS(s / 180 * 3.141592) * 180) + 225
8. CIRCLE (x, y), 2, _RGB32(127, 216, 127)
9. IF seconds > 60 THEN
10.     seconds = 0
11.     _DELAY 2
12.     CLS
13.     PRINT "2"
14.     GOTO two:
15. END IF
16. _DELAY .001
17. GOTO one:
18.  
19. two:

Compared to:

Code: QB64: [Select]

1.     CLS
2.     PRINT "1"
3.     DO
4.         seconds = seconds + .01
5.         s = (60 - seconds) * 6 + 180
6.         x = INT(SIN(s / 180 * 3.141592) * 180) + 325
7.         y = INT(COS(s / 180 * 3.141592) * 180) + 225
8.         CIRCLE (x, y), 2, _RGB32(127, 216, 127)
9.         _DELAY .001
10.     LOOP UNTIL seconds > 60
11.     _DELAY 2

I don't know about you, but I can assure you which one I find easier to follow and understand, and I believe most people (and bosses) would agree that the second is "much cleaner code" than the first appears to be.

[Ashish]

...
I don't know about you, but I can assure you which one I find easier to follow and understand, and I believe most people (and bosses) would agree that the second is "much cleaner code" than the first appears to be.

I agree. But when I was new to QB64, just like SierraKen, I used to do same thing. This is because I didn't knew about SUBs, FUNCTIONs (and many other things.)
Then slowly, slowly I learned by many example codes done by Bosses.

[Petr]

I totally agree with Ashish. Steve, when I started, the DIM command, DIM SHARED, was completely unknown to me. Same SUB and FUNCTIONS. Even though I have been using it for a long time, I am watched to your SUB as the calf at the new door, because it was you, and I thank you very much for showing it, who show me the two-way SUB. This means that you can return results using parameters. And there is still much new.
I remember - your _DEST,  _SOURCE examples thread. This was something great for me!
SierraKen, we all learning us still.

[SierraKen]

Thank you SMcNeill. Yes I knew I could shorten it down to something like that, but it doesn't work me to death because all I do is copy/paste segments of code. Plus I wanted to make it easy for programmers to copy any segment they wanted to use in their own programs. Of course they could have done it your way as well but would have to know what they are looking for.  But I agree, I do need to learn SUBs more. I guess right now I'm at the point where I don't understand the difference between SUBs and just using a GOSUB / RETURN routine, which I'm starting to use more and more now and that also reduces the code. But I appreciate the comments and examples. I might look more into this later on. And yeah, I do need to learn more about what QB64 has to offer if I want to keep putting examples to learn by on my website and this forum. My mind is a slow learner. :) I've been doing BASIC in different kinds since the 80's, way back when you needed line numbers. LOL This was before SUBs or they would have taught us them in the college course I took and the High School class. But when QBasic came out, everything changed. :)

[SMcNeill]

There’s not a lot of differences in SUB and GOSUB routines, but I find them significant.  Biggest things to remember:

* SUB/FUNCTION are self-contained; GOSUB aren’t.

GOSUB Example:

Code: [Select]

x = 3
PRINT x

GOSUB AddOne
PRINT x

END

AddOne:
x = x + 1
PRINT x
RETURN
The above will print 3, 4, 4 as the three lines of results.

SUB example:

Code: [Select]

x = 3
PRINT x

AddOne
PRINT x

END

SUB AddOne
    x = x + 1
    PRINT x
END SUB
Now here, we’ll see 3, 1, 3 as the result.  AddOne is self-contained as a SUB, and x inside it has no relation to the value of x outside it.  When we call AddOne, SUB_x has a default value of 0, adds 1 to that, and SUB_x becomes 1.  The Main_x we set at a value of 3, and it never changes. 

This “self-contained” feature of SUB/FUNCTION makes them very suitable for creating libraries which we can then $INCLUDE into other programs.  GOSUB tends to be very Program specific, as its variables can affect the rest of your code, whereas SUB/FUNCTION doesn’t.


*SUB/FUNCTION have passable parameters; GOSUB doesn’t.

Since a SUB is self-contained, we need some way to pass values back and forth to it — the most basic way is via parameters.

Code: [Select]

x = 3
PRINT x

AddOne x
PRINT x

AddOne x
PRINT x

END

SUB AddOne (x)
    x = x + 1
END SUB
And here, we print 3, 4, 5.  We pass the value of x back and forth in the parenthesis when we declare our SUB.  (The (x) in this case.)


And that’s the very basics, to highlight the differences and help get you started on learning how to use them.  Just post when interested in learning more, and ask any questions you might have, and I — and the rest of the forum members, I’m certain — will be happy to help any way we can with your concerns.  ;D

[SierraKen]

Thank you SMcNeill. So it's like a program within a program, very cool! I can almost visualize it, but I will need practice with it for awhile first. Not sure if I will use it yet or not though, my mind is so wrapped with GOTOs and GOSUBs and one even flow that adding more is REALLY different. lol

[bplus]

One of the first subs I ever created and used over and over was LP(row, col, string$)

LP here stands for Locate and Print:, the sub's code is simply:

Code: QB64: [Select]

1. SUB LP(row, col, string$)
2.    LOCATE row, col: PRINT string$; '< probably want ; at end if printing near bottom of screen
3. END SUB

It's handy because it saves typing out LOCATE and PRINT and combines two lines of code into one meaty one.
Screen design starts with deciding where to place and print everything.

[SMcNeill]

Thank you SMcNeill. So it's like a program within a program, very cool! I can almost visualize it, but I will need practice with it for awhile first. Not sure if I will use it yet or not though, my mind is so wrapped with GOTOs and GOSUBs and one even flow that adding more is REALLY different. lol

Once you get used to SUB/FUNCTION, you’ll slowly start to forget that GOSUB even exists.  There’s often very few advantages to using GOSUB, and a lot for using SUB.  Consider this code:

FOR I = 1 TO 10
     GOSUB AddOne
NEXT

END

AddOne:
FOR I = 1 TO 10
    x = x + 1
NEXT
PRINT x
RETURN

With the above, you’re just going to print 10 to the screen and end.  Your GOSUB changed the value of I and immediately jumped out of the previous loop when RETURN was called.

Now, what do we get with a SUB?

FOR I = 1 TO 10
    AddOne
NEXT

SUB AddOne
    STATIC x
    FOR I = 1 TO 10
        x = x + 1
    NEXT
    PRINT x
END SUB

And with the above, we print 10, 20, 30, ..., 100.  The I inside the loop has no effect on the I in the main module, meaning we’re not going to corrupt any values in our main program.


And your observation of, “its like a program within a program”, is spot on.  From the way I was taught waaay back in the early 90’s, GOSUB meant to GO to a SUB-routine.  SUB, however, was used to call a SUB-module — and that’s a huge difference all by itself.

[SierraKen]

That's pretty neat SMcNeill, thanks. Will look into it sometime soon I think. I know the more I use new programming methods, the more I get used to it.

[Jack002]

Love the math graphics program. Its almost a graphing calculator. Just needs some axis and tick marks and axis values.

[SierraKen]

LOL yep, thanks Jack.

[OldMoses]

I learned something new, and possibly quite timely. I was unaware of STATIC as a way to retain variable values in a SUB.

[SierraKen]

I just used 2 SUBs in the newly updated Tech Invaders game. Thank you for pushing me to use them! I had no idea how good they could be. But I'm still learning :). Read the last post or so on the Tech Invaders thread.