Text Only | Text with Attachments

QB64.org Forum

Active Forums => Programs => Topic started by: SierraKen on July 22, 2019, 01:42:16 pm

Title: Fun Math Graphics
Post by: SierraKen on July 22, 2019, 01:42:16 pm
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)
  10. PRINT "                             Fun Math Graphics"
  12. PRINT "                                 by Ken G."
  14. PRINT "         11 of these pictures are drawn using the same equations,"
  15. PRINT "         just with different numbers. The 12th is similar but different."
  18. INPUT "                           Press Enter to start.", a$
  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:
  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:
  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:
  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:
  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:
  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:
  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:
  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:
  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
  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:
  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:
  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
  206.  
Title: Re: Fun Math Graphics
Post by: SierraKen on July 22, 2019, 05:47:51 pm
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.
Title: Re: Fun Math Graphics
Post by: SMcNeill on July 23, 2019, 06:48:55 am
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)
  10. PRINT "                             Fun Math Graphics"
  12. PRINT "                                 by Ken G."
  13. PRINT "                         Modified by Steve McNeill."
  15. PRINT "         11 of these pictures are drawn using the same equations,"
  16. PRINT "         just with different numbers. The 12th is similar but different."
  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
  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

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]
  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:
  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.
Title: Re: Fun Math Graphics
Post by: Ashish on July 23, 2019, 08:49:07 am
Quote from: SMcNeill on July 23, 2019, 06:48:55 am
...
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.
Title: Re: Fun Math Graphics
Post by: Petr on July 23, 2019, 11:52:08 am
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.
Title: Re: Fun Math Graphics
Post by: SierraKen on July 23, 2019, 12:08:47 pm
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. :)
Title: Re: Fun Math Graphics
Post by: SMcNeill on July 23, 2019, 12:47:22 pm
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
Title: Re: Fun Math Graphics
Post by: SierraKen on July 24, 2019, 01:28:30 pm
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
Title: Re: Fun Math Graphics
Post by: bplus on July 24, 2019, 02:45:48 pm
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

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.
Title: Re: Fun Math Graphics
Post by: SMcNeill on July 24, 2019, 03:30:20 pm
Quote from: SierraKen on July 24, 2019, 01:28:30 pm
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.
Title: Re: Fun Math Graphics
Post by: SierraKen on July 24, 2019, 06:42:56 pm
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.
Title: Re: Fun Math Graphics
Post by: Jack002 on July 25, 2019, 11:28:58 am
Love the math graphics program. Its almost a graphing calculator. Just needs some axis and tick marks and axis values.
Title: Re: Fun Math Graphics
Post by: SierraKen on July 25, 2019, 12:04:50 pm
LOL yep, thanks Jack.
Title: Re: Fun Math Graphics
Post by: OldMoses on July 25, 2019, 07:10:09 pm
I learned something new, and possibly quite timely. I was unaware of STATIC as a way to retain variable values in a SUB.
Title: Re: Fun Math Graphics
Post by: SierraKen on July 25, 2019, 11:22:15 pm
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.
Text Only | Text with Attachments