Archimedean spiral: Difference between revisions
m
Replace deprecated functions
(add gwbasic) |
m (Replace deprecated functions) |
||
| (49 intermediate revisions by 20 users not shown) | |||
Line 15:
Draw an Archimedean spiral.
<br><br>
=={{header|Action!}}==
Action! does not provide trigonometric functions. Therefore a simple implementation for Sin and Cos function has been provided.
<syntaxhighlight lang="action!">INT ARRAY SinTab=[
0 4 9 13 18 22 27 31 36 40 44 49 53 58 62 66 71 75 79 83
88 92 96 100 104 108 112 116 120 124 128 132 136 139 143
147 150 154 158 161 165 168 171 175 178 181 184 187 190
193 196 199 202 204 207 210 212 215 217 219 222 224 226
228 230 232 234 236 237 239 241 242 243 245 246 247 248
249 250 251 252 253 254 254 255 255 255 256 256 256 256]
INT FUNC Sin(INT a)
WHILE a<0 DO a==+360 OD
WHILE a>360 DO a==-360 OD
IF a<=90 THEN
RETURN (SinTab(a))
ELSEIF a<=180 THEN
RETURN (SinTab(180-a))
ELSEIF a<=270 THEN
RETURN (-SinTab(a-180))
ELSE
RETURN (-SinTab(360-a))
FI
RETURN (0)
INT FUNC Cos(INT a)
RETURN (Sin(a-90))
PROC DrawSpiral(INT x0,y0)
INT angle,radius,x,y
Plot(x0,y0)
FOR angle=0 TO 1800 STEP 5
DO
radius=angle/20
x=radius*Cos(angle)/256+x0
y=radius*Sin(angle)/256+y0
DrawTo(x,y)
OD
RETURN
PROC Main()
BYTE CH=$02FC,COLOR1=$02C5,COLOR2=$02C6
Graphics(8+16)
Color=1
COLOR1=$0C
COLOR2=$02
DrawSpiral(160,96)
DO UNTIL CH#$FF OD
CH=$FF
RETURN</syntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Archimedean_spiral.png Screenshot from Atari 8-bit computer]
=={{header|Ada}}==
{{libheader|SDLAda}}
<
with SDL.Video.Windows.Makers;
Line 89 ⟶ 145:
Window.Finalize;
SDL.Finalise;
end Archimedean_Spiral;</
=={{header|ALGOL W}}==
{{Trans|AWK}}
This version doubles the characters horiontally to give a slightly more rounded shape.
<syntaxhighlight lang="algolw">begin % draw an Archimedian spiral %
% Translation of AWK which was a trnslation of Applesoft Basic program %
integer procedure max ( integer x, y ) ; begin if x > y then x else y end;
integer procedure min ( integer x, y ) ; begin if x < y then x else y end;
integer x_min, y_min, x_max, y_max, a, b, x, y;
string(255) array arr ( 1 :: 255 );
real h, w, m, s, t;
x_min := y_min := 9999;
x_max := y_max := 0;
h := 96;
w := h + h / 2;
a := 1;
b := 1;
m := 6 * PI;
s := .02;
t := s;
while t <= m do begin % build spiral %
real r;
r := a + b * t;
x := round(r * cos(t) + w);
y := round(r * sin(t) + h);
if x <= 0 or y <= 0 then begin end
else if x >= 280 then begin end
else if y >= 192 then begin end
else begin
arr( x )( y // 1 ) := "*";
x_min := min(x_min,x);
x_max := max(x_max,x);
y_min := min(y_min,y);
y_max := max(y_max,y);
t := t + s
end if__various_x_and_y_values__
end while__t_le_m ;
for i := x_min until x_max do begin
for j := y_min until y_max do begin
string(1) c;
c := arr( i )( j // 1 );
writeon( c, c )
end for_j ;
write()
end for_i
end.</syntaxhighlight>
{{out}}
<pre>
**************
******** ********
****** ****
**** ******
**** ****
**** ****
**** ****
**** ****************** **
**** **** ****** **
** **** **** ****
**** ** **** **
** **** **** **
** **** ** **
** ** ********** **** **
** **** **** **** ** **
** ** ** **** ** **
** ** **** ** ** **
** ** ** **** ** **
** ** ** ****** ** **
** ** ** **** **
** ** **** ** **
** ** ** **** **
** ** **** **** **
** ** ****** **** ****
** **** ************** **
** ** **
**** ** ****
** **** ****
**** **** ******
** ****** ******
** ******** ********
** **********
**
****
******
******
********
********
</pre>
=={{header|Amazing Hopper}}==
{{Trans|AmigaBASIC}}
[[File:Captura_de_pantalla_de_2022-10-07_22-57-32.png|200px|thumb|right]]
<syntaxhighlight lang="c">
#include <jambo.h>
Main
Set break
a=1.5, b=1.5, r=0, origen x=200, origen y=105
total = 0, Let ( total := Mul(20, M_PI) )
Cls
Loop for ( t=0, var 't' Is less equal to 'total', Let (t := Add (t, 0.005)) )
#( r = a + b * t )
Set 'origen x, origen y', # ( 200 + (2*r*sin(t)) ) » 'origen x', #( 105 + (r*cos(t)) ) » 'origen y',
Gosub 'Dibuja un segmento'
Next
Pause
End
Subrutines
Define (Dibuja un segmento, x1, y1, x2, y2)
dx=0, dy=0, paso=0, i=0, DX=0, DY=0
Sub(x2, x1), Sub (y2, y1), Move to ' dx, dy '
Let( paso := Get if( Greater equal ( Abs(dx) » (DX), Abs(dy)»(DY) ), DX, DY ) )
// incremento:
Div(dx, paso), Div(dy, paso), Move to ( dx, dy )
Color back (13)
// dibuja línea:
i = 0
Loop if ( Less equal (i, paso) )
Locate( y1, x1 ), Printnl( " " )
Add ( x1, dx), Add( y1, dy ), Move to ( x1, y1 )
++i
Back
Printnl("\OFF")
Return
</syntaxhighlight>
{{out}}
<pre>
Invocar como:
rxvt -g 500x250 -fn "xft:FantasqueSansMono-Regular:pixelsize=1" -e hopper jm/archi.jambo
</pre>
=={{header|APL}}==
Line 97 ⟶ 290:
Uses Dyalog's [https://sharpplot.com/ SharpPlot] integration, which works on all supported platforms.
<
InitCauseway ⍬ ⍝ initialise current namespace
sp←⎕NEW Causeway.SharpPlot
sp.DrawPolarChart {⍵(360|⍵)}⌽⍳720
View sp</
[https://i.imgur.com/hZDqjjM.png See the plot on imgur.]
Line 107 ⟶ 300:
=={{header|AutoHotkey}}==
Requires [https://github.com/tariqporter/Gdip GDIP]
<
{
MsgBox, 48, gdiplus error!, Gdiplus failed to start. Please ensure you have gdiplus on your system
Line 157 ⟶ 350:
Gdip_Shutdown(pToken)
ExitApp
Return</
=={{header|AWK}}==
<syntaxhighlight lang="awk">
# syntax: GAWK -f ARCHIMEDEAN_SPIRAL.AWK
# converted from Applesoft BASIC
Line 196 ⟶ 389:
function max(x,y) { return((x > y) ? x : y) }
function min(x,y) { return((x < y) ? x : y) }
</syntaxhighlight>
{{out}}
<pre>
Line 239 ⟶ 432:
=={{header|BASIC}}==
==={{header|AmigaBASIC}}===
{{trans|Locomotive Basic}}
<
b=1.5
pi=3.141592
Line 251 ⟶ 442:
r=a+b*t
LINE -(320+2*r*SIN(t),100+r*COS(t))
NEXT</
==={{header|Applesoft BASIC}}===
<
120 LET W = H + H / 2
130 HGR2
Line 273 ⟶ 464:
280 HPLOT X,Y
290 NEXT
</syntaxhighlight>
==={{header|BASIC256}}===
<syntaxhighlight lang="basic256">
# Basic-256 ver 1.1.4
# Archimedean Spiral
Line 289 ⟶ 480:
i = 1 : t = 0 : xn = 0 : yn = 0 # Initial values
iter = 150 : q = 30
line x,0,x,height
Line 305 ⟶ 495:
print i + chr(9) + int(x) + chr(9) + int(y) + chr(9) + int(t) # chr(9) = TAB
i += 1
end while
imgsave "spiral-Basic-256.png", "PNG"
</syntaxhighlight>
==={{header|BBC BASIC}}===
{{works with|BBC BASIC for Windows}}
[[File:Archimedean_spiral_bbc_basic.jpeg|300px|right]]
<syntaxhighlight lang="bbcbasic"> A=320
VDU 23, 22, A+10; A+10; 8, 16, 16, 128
ORIGIN @size.x%, @size.y%
GCOL 7
FOR I=-(A - A MOD 100) TO A - A MOD 100 STEP 100
LINE I, -A, I, A : LINE -A, I, A, I
NEXT
MOVE 0, 0
GCOL 1
VDU 23, 23, 3|
FOR I=0 TO 5 * PI STEP .05
R=A / 16 * I
DRAW R * COS(I), R * SIN(I)
NEXT
</syntaxhighlight>
==={{header|Chipmunk Basic}}===
{{works with|Chipmunk Basic|3.6.4}}
<syntaxhighlight lang="basic">
10 rem Archimedean spiral
20 graphics 0
30 graphics cls
40 a = 3 : b = 1.4
50 x0 = 320 : y0 = 200
60 graphics moveto x0,y0
70 for t = 0 to 40*pi step 0.2
80 r = a+b*t
90 x = r*cos(t)+320 : y = r*sin(t)+200
100 graphics lineto x,y
110 next t
120 end
</syntaxhighlight>
==={{header|Commodore BASIC}}===
Commodore BASIC 2.0 lacks in-built graphics capability. This implementation is written for Commodore BASIC 7.0 that was built into the Commodore 128 computer. Should also work for Commodore BASIC 3.5.
<
2 REM USING COMMODORE BASIC 7.0
3 REM OF THE COMMODORE 128
Line 330 ⟶ 553:
90 X0 = X : Y0 = Y
100 NEXT T
110 GOTO 110</
==={{header|FreeBASIC}}===
<
' compile with: fbc -s gui
Line 352 ⟶ 575:
PSet(halfscrn + x, halfscrn - y), RGB(255, 255, 255)
Next
' empty keyboard buffer
Line 358 ⟶ 580:
Print : Print "hit any key to end program"
Sleep
End</
==={{header|GW-BASIC}}===
<
20 B = 1
30 SCREEN 1
Line 372 ⟶ 594:
100 IF INKEY$="" THEN GOTO 100
110 SCREEN 2:SCREEN 0
120 END</
==={{header|IS-BASIC}}===
<
110 OPTION ANGLE DEGREES
120 PLOT 640,360,ANGLE 90;
130 FOR I=2 TO 33.2 STEP .05
140 PLOT FORWARD I,LEFT 5;
150 NEXT</
==={{header|Locomotive Basic}}===
{{trans|Commodore BASIC}}
<
20 mode 2:rad:move 320,200
30 for t=0 to 40*pi step 0.2
Line 390 ⟶ 612:
50 draw r*sin(t)+320,r*cos(t)+200
60 next
70 while inkey$="":wend</
==={{header|PureBasic}}===
<syntaxhighlight lang="purebasic">#MAXLOOP = 7*360
#XCENTER = 640/2
#YCENTER = 480/2
#SCALAR = 200
If OpenWindow(0, 100, 200, 640, 480, "Archimedean spiral")
If CreateImage(0, 640, 480,24,RGB(255,255,255))
If StartDrawing(ImageOutput(0))
i.f=0.0
While i<=#MAXLOOP
x.f=#XCENTER+Cos(Radian(i))*#SCALAR*i/#MAXLOOP
y.f=#YCENTER+Sin(Radian(i))*#SCALAR*i/#MAXLOOP
Plot(x,y,RGB(50,50,50))
i+0.05
Wend
StopDrawing()
EndIf
EndIf
ImageGadget(0, 0, 0, 0, 0, ImageID(0))
Repeat : Event = WaitWindowEvent() : Until Event = #PB_Event_CloseWindow
EndIf
End</syntaxhighlight>
==={{header|Run BASIC}}===
<
'runs in Run Basic
'Run Basic website http://www.runbasic.com
Line 419 ⟶ 665:
print "Thank you and Goodbye"
end
End</
==={{header|QBasic}}===
<
WINDOW (-2.67, -2!)-(2.67, 2!)
PI = 4 * ATN(1)
Line 433 ⟶ 679:
Y = (A + B * T) * SIN(T)
LINE -(X, Y)
NEXT</
==={{header|Sinclair ZX81 BASIC}}===
{{trans|Applesoft BASIC}}
Works with the unexpanded (1k RAM) ZX81. The output is quite blocky, but identifiably a spiral.
<
20 LET B=0.7
30 FOR T=0 TO 7*PI STEP 0.05
40 LET R=A+B*T
50 PLOT R*COS T+32,R*SIN T+22
60 NEXT T</
{{out}}
Screenshot [http://edmundgriffiths.com/zx81archspiral.jpg here].
==={{header|VBA}}===
<syntaxhighlight lang="vb">Private Sub plot_coordinate_pairs(x As Variant, y As Variant)
Dim chrt As Chart
Set chrt = ActiveSheet.Shapes.AddChart.Chart
With chrt
.ChartType = xlXYScatter
.HasLegend = False
.SeriesCollection.NewSeries
.SeriesCollection.Item(1).XValues = x
.SeriesCollection.Item(1).Values = y
End With
End Sub
Public Sub main()
Dim x(1000) As Single, y(1000) As Single
a = 1
b = 9
For i = 0 To 1000
theta = i * WorksheetFunction.Pi() / 60
r = a + b * theta
x(i) = r * Cos(theta)
y(i) = r * Sin(theta)
Next i
plot_coordinate_pairs x, y
End Sub</syntaxhighlight>
==={{header|Yabasic}}===
{{trans|Sinclair_ZX81_BASIC}}
<syntaxhighlight lang="yabasic">5 OPEN WINDOW 320, 200 : WINDOW ORIGIN "CC"
10 LET A=1.5
20 LET B=0.7
30 FOR T=0 TO 30*PI STEP 0.05
40 LET R=A+B*T
50 LINE TO R*COS(T),R*SIN(T)
60 NEXT T</syntaxhighlight>
=={{header|BQN}}==
The BQN online REPL supports some basic plotting functionality through <code>•Plot</code>. This is used to create a spiral plotting function:
<syntaxhighlight lang="bqn">{(•math.Sin •Plot○(⊢×↕∘≠) •math.Cos) -(2×π) × 𝕩⥊(↕÷-⟜1)100}</syntaxhighlight>
When called with argument 200, it is similar to the given example diagram.
[https://mlochbaum.github.io/BQN/try.html#code=eyjigKJtYXRoLlNpbiDigKJQbG904peLKOKKosOX4oaV4oiY4omgKSDigKJtYXRoLkNvcykgLSgyw5fPgCkgw5cg8J2VqeKliijihpXDty3in5wxKTEwMH0yMDA= Try it out!]
=={{header|C}}==
Interactive code which asks the parameters a and b as inputs, the number of cycles and the division steps. Requires the [http://www.cs.colorado.edu/~main/bgi/cs1300/ WinBGIm] library.
<syntaxhighlight lang="c">
#include<graphics.h>
#include<stdio.h>
Line 482 ⟶ 772:
closegraph();
}
</syntaxhighlight>
=={{header|C sharp|C#}}==
<
using System.Linq;
using System.Drawing;
Line 525 ⟶ 815:
}
}
</syntaxhighlight>
=={{header|C++}}==
[[File:SpiralCpp.png|200px|thumb|right]]
<
#include <windows.h>
#include <string>
Line 640 ⟶ 930:
spiral s; s.draw( 16, 8 ); return 0;
}
</syntaxhighlight>
=={{header|Clojure}}==
{{Works with| Incanter}}
<
(use '(incanter core stats charts io))
Line 659 ⟶ 949:
(view (parametric-plot arq-spiral 0 (* 10 Math/PI)))
</syntaxhighlight>
Another version inspired by the Java below, showing how to interop with awt/swing to do simple graphics:
<syntaxhighlight lang="clojure">
(let [panel (proxy [javax.swing.JPanel] []
(paintComponent [g]
(proxy-super paintComponent g)
(.setStroke g (java.awt.BasicStroke. 2))
(.setRenderingHint g java.awt.RenderingHints/KEY_ANTIALIASING
java.awt.RenderingHints/VALUE_ANTIALIAS_ON)
(let [[a b] [0 (/ 1 Math/PI)]
[w h] [(.getWidth this) (.getHeight this)]
[cx cy] [(/ w 2.0) (/ h 2.0)]
margin 16
[rotations point-n] [3 (quot (min w h) 2)]
[ring-n line-n] [6 12]
scale (/ (- (min w h) (* 2 margin)) (* 2.0 ring-n))]
;; Grid
(.setColor g (java.awt.Color. 0xEEEEEE))
(doseq [i (range 1 (inc ring-n))]
(let [[posx posy] [(- cx (* i scale)) (- cy (* i scale))]]
(.drawOval g posx posy (* 2 i scale) (* 2 i scale))))
(dotimes [i line-n]
(let [theta (* 2 Math/PI (/ i (double line-n)))
[x y] [(+ cx (* scale ring-n (Math/cos theta)))
(+ cy (* scale ring-n (Math/sin theta)))]]
(.drawLine g cx cy x y)))
;; Spiral
(.setColor g (java.awt.Color. 0x202020))
(loop [i 0 [x y] [(+ cx (* a scale)) cy]]
(let [p (/ (inc i) (double point-n))
theta (* rotations 2 Math/PI p)
r (* scale (+ a (* b theta)))
[x1 y1] [(+ cx (* r (Math/cos theta)))
(- cy (* r (Math/sin theta)))]]
(.drawLine g x y x1 y1)
(when (< i (dec point-n)) (recur (inc i) [x1 y1])))))))]
(doto (javax.swing.JFrame.)
(.add (doto panel
(.setPreferredSize (java.awt.Dimension. 640 640))
(.setBackground java.awt.Color/white))
java.awt.BorderLayout/CENTER)
(.pack)
(.setVisible true)))
</syntaxhighlight>
=={{header|Common Lisp}}==
Line 667 ⟶ 1,000:
Common Lisp doesn't provide native graphical output. Libraries or bitmapped output could be used instead, but for this solution, the output is accomplished with character printing.
<
(let* ((min-x (apply #'min (mapcar #'car coords)))
(min-y (apply #'min (mapcar #'cdr coords)))
Line 737 ⟶ 1,070:
</syntaxhighlight>
=={{header|Craft Basic}}==
<syntaxhighlight lang="basic">bgcolor 0, 0, 0
cls graphics
fgcolor 255, 255, 0
define pi = 3.14, size = 80
define x = 250, y = 200
define a = 1.5, b = .7
for t = 0 to size * pi step .1
let r = a + b * t
dot r * cos(t) + x, r * sin(t) + y
wait
next t</syntaxhighlight>
=={{header|Delphi}}==
{{works with|Delphi|6.0}}
{{libheader|Types,ExtCtrls,Graphics}}
<syntaxhighlight lang="Delphi">
procedure ArcSpiral(Image: TImage);
var Radius,Theta: double;
var X,Y: integer;
var Center: TPoint;
const Step = 0.2;
const Offset = 3; Spacing = 1.4;
begin
Image.Canvas.Brush.Color:=clWhite;
Image.Canvas.Rectangle(0,0,Image.Width,Image.Height);
Center:=Point(Image.Width div 2, Image.Height div 2);
Image.Canvas.MoveTo(Center.X,Center.Y);
Theta:=0;
while Theta<(40*Pi) do
begin
{Radius increases as theta increases}
Radius:=Offset+Spacing*Theta;
{Calculate position on circle}
X:=Trunc(Radius*Cos(Theta)+Center.X);
Y:=Trunc(Radius*sin(Theta)+Center.Y);
Image.Canvas.LineTo(X,Y);
Theta:=Theta+Step;
end;
end;
</syntaxhighlight>
{{out}}
[[File:DelphiASpiral.png|frame|none]]
<pre>
</pre>
=={{header|EasyLang}}==
[https://easylang.dev/show/#cod=JcwxCsAgEETRfk8xdQQRol08TSK4IAZUUG8f11TDg88kzqHz0yKMtjTg4QzNf3rkFFBwCQCk1S4euN+KBoWxVTlvTWkKlF9Xxgma4CRNHw== Run it]
<syntaxhighlight lang="easylang">
linewidth 0.4
x = 50
y = 50
while r < 50
line r * cos t + x r * sin t + y
r += 0.05
t += 3
.
</syntaxhighlight>
=={{header|FOCAL}}==
<
1.2 S B=2
1.3 S N=250
Line 756 ⟶ 1,159:
4.1 S X2=R*FSIN(.2*(T+1))
4.2 S Y2=R*FCOS(.2*(T+1))</
This program uses FOCAL-11 on a DEC GT40 vector graphics terminal.
Line 764 ⟶ 1,167:
{{Works with|Frege|3.23.888}}
<
import Java.IO
Line 852 ⟶ 1,255:
drawSpiral g
f <- File.new "SpiralFrege.png"
void $ ImageIO.write buffy "png" f</
Output is [http://funwithsoftware.org/images/2016-SpiralFrege.png here] due to [[User talk:Short Circuit#Is file uploading blocked forever?|Is file uploading blocked forever?]]
=={{header|Frink}}==
<syntaxhighlight lang="frink">p = new polyline
g = new graphics
a = 1
b = 1
for theta = 0 to 10 circle step 1 degree
{
r = a + b theta
x = r cos[theta]
y = r sin[theta]
p.addPoint[x,-y]
}
g.add[p]
g.show[]
g.write["ArchimedeanSpiralFrink.svg",800,800]</syntaxhighlight>
[[File:ArchimedeanSpiralFrink.svg|400 px]]
=={{header|FutureBasic}}==
<syntaxhighlight lang="futurebasic">
_maxPoints = 190
void local fn DoIt
window 1, @"Archimedean Spiral", (0,0,500,500)
WindowSetBackgroundColor( 1, fn ColorBlack )
pen 3, fn ColorRed
float x, y, angle
long i, a = 10, b = 10, x1 = 250, y1 = 250
for i = 0 to _maxPoints - 1
angle = 0.1 * i
x = (a + b * angle) * cos(angle) + 250
y = (a + b * angle) * sin(angle) + 250
line x1,y1 to x,y
x1 = x : y1 = y
next
end fn
fn DoIt
HandleEvents
</syntaxhighlight>
{{output}}
[[File:ArchimedeanSpiralFB.png]]
=={{header|Go}}==
{{works with|go|1.9}}
Creates a PNG file using only built-in packages.
<
import (
Line 906 ⟶ 1,355:
log.Fatal(err)
}
}</
=={{header|Haskell}}==
Line 913 ⟶ 1,362:
{{libheader|Juicy.Pixels}}
{{libheader|Rasterific}}
<
-- stack --resolver lts-7.0 --install-ghc runghc --package Rasterific --package JuicyPixels
Line 939 ⟶ 1,388:
polyline points
writePng "SpiralHaskell.png" img</
Output is [http://funwithsoftware.org/images/2016-SpiralHaskell.png here] due to [[User talk:Short Circuit#Is file uploading blocked forever?|Is file uploading blocked forever?]]
Line 945 ⟶ 1,394:
=={{header|J}}==
[[File:Archimedian spiral j.png|200px|thumb|right]]
<
'aspect 1' plot (*^)j.0.01*i.1400</
<div style="clear:both"></div>
Line 953 ⟶ 1,402:
[[File:archimedian_spiral.png|300px|thumb|right]]
{{works with|Java|8}}
<
import static java.lang.Math.*;
import javax.swing.*;
Line 1,036 ⟶ 1,485:
});
}
}</
=={{header|JavaScript}}==
Line 1,042 ⟶ 1,491:
{{Works with|Chrome}}
[[File:ASjs.png|200px|right|thumb|Output ASjs.png]]
<
<!-- ArchiSpiral.html -->
<html>
Line 1,067 ⟶ 1,516:
}
</script></body></html>
</syntaxhighlight>
{{Output}}
<pre>
Line 1,077 ⟶ 1,526:
Assumes the same HTML canvas embedding as above, but is functionally composed.
Defines and logs a set of points, before rendering them to canvas.
<
<head>
<title>Archimedean spiral</title>
Line 1,085 ⟶ 1,534:
<h3>Archimedean spiral</h3></p>
<canvas id="spiral" width="640" height="640" style="border: 2px outset;"></canvas>
<script></
<
const
ai = 0.05,
Line 1,118 ⟶ 1,567:
Array.from({
length: 1 + n - m
}, (_, i) => m + i);</
<
=={{header|jq}}==
Line 1,125 ⟶ 1,574:
'''Works with gojq, the Go implementation of jq'''
====SVG version====
<
def pi: 1 | atan * 4;
Line 1,150 ⟶ 1,599:
spiral(0; 10; 0.025)
</syntaxhighlight>
{{out}}
Line 1,158 ⟶ 1,607:
====ASCII Art Version====
{{trans|awk}}
<
def min($x;$y): if $x <= $y then $x else $y end;
def max($x;$y): if $x <= $y then $y else $x end;
Line 1,188 ⟶ 1,637:
| "\(.)\n" ;
spiral(1; 1; 0.02; 96)</
{{out}}
As for [[#awk|awk]].
Line 1,195 ⟶ 1,644:
{{works with|Julia|0.6}}
<
spiral(θ, a=0, b=1) = @. b * θ * cos(θ + a), b * θ * sin(θ + a)
x, y = spiral(1:0.1:10)
println(lineplot(x, y))</
{{out}}
Line 1,225 ⟶ 1,674:
=={{header|Kotlin}}==
{{trans|Java}}
<
import java.awt.*
Line 1,300 ⟶ 1,749:
f.isVisible = true
}
}</
=={{header|Lambdatalk}}==
<syntaxhighlight lang="Scheme">
1) from polar to cartesian coordinates
x = r*cos(t) = (a+b*t)*cos(t)
y = r*sin(t) = (a+b*t)*sin(t)
2) define the curve
{def CURVE
{lambda {:a :b :t}
{* {+ :a {* :b :t}} {cos :t}}
{* {+ :a {* :b :t}} {sin :t}}
}}
-> CURVE
3) and draw it using SVG
{{SVG 580}
{g {AXES 580 580}
{polyline {@ points="{S.map {CURVE 5 4}
{S.serie 0 {* 10 {PI}} 0.1}}"
{stroke red 3}}
}}}
</syntaxhighlight>
The ouput can be seen in http://lambdaway.free.fr/lambdawalks/?view=archimedian_spiral
=={{header|Lua}}==
{{libheader|LÖVE}}
{{works with|LÖVE|11.3}}
<syntaxhighlight lang="lua">
a=1
b=2
Line 1,326 ⟶ 1,803:
end
end
</syntaxhighlight>
=={{header|M2000 Interpreter}}==
<syntaxhighlight lang="m2000 interpreter">
module Archimedean_spiral {
smooth on ' enable GDI+
Line 1,356 ⟶ 1,833:
}
Archimedean_spiral
</syntaxhighlight>
=={{header|Maple}}==
<syntaxhighlight lang="maple">
plots[polarplot](1+2*theta, theta = 0 .. 6*Pi)
</syntaxhighlight>
=={{header|Mathematica}}/{{header|Wolfram Language}}==
The built-in function PolarPlot easily creates the desired plot
<
=={{header|MATLAB}}==
<
b = 1;
turns = 2;
theta = 0:0.1:2*turns*pi;
polarplot(theta, a + b*theta);</
=={{header|Maxima}}==
Using draw package
<syntaxhighlight lang="maxima">
archi_spi(a,b):=wxdraw2d(nticks=200,polar(a+b*theta,theta,1,10*%pi))$
archi_spi(1,1);
</syntaxhighlight>
[[File:Archi spi.png|thumb|center]]
=={{header|MiniScript}}==
For use with the [http://miniscript.org/MiniMicro Mini Micro].
<syntaxhighlight lang="miniscript">
clear
x0 = gfx.width / 2
y0 = gfx.height / 2
gfx.clear color.white
for t in range(0, 70 * pi, 0.1)
r = 3.2+ 1.5 * t
x = r * cos(t) + gfx.width / 2
y = r * sin(t) + gfx.height / 2
gfx.line x0, y0, x, y, color.black,2
x0 = x; y0 = y
end for
</syntaxhighlight>
Alternative version using a Turtle library included with the [http://miniscript.org/MiniMicro Mini Micro].
<syntaxhighlight lang="miniscript">
import "turtle"
radToDegrees = function(rad)
return 180 * rad / pi
end function
clear
print Turtle.displayNum
display(Turtle.displayNum).clear
t = new Turtle
for i in range(0, 50, 0.04)
t.forward i
t.left radToDegrees(pi/20)
end for
</syntaxhighlight>
=={{header|Nim}}==
{{libheader|gintro}}
<
import gintro/[glib, gobject, gtk, gio, cairo]
Line 1,449 ⟶ 1,968:
let app = newApplication(Application, "Rosetta.spiral")
discard app.connect("activate", activate)
discard app.run()</
=={{header|PARI/GP}}==
Line 1,457 ⟶ 1,976:
[[File:ArchiSpiral2.png|right|thumb|Output ArchiSpiral2.png]]
<
\\ The Archimedean spiral
\\ ArchiSpiral() - Where: lps is a number of loops, c is a direction 0/1
Line 1,477 ⟶ 1,996:
ArchiSpiral(640,5,1); \\ArchiSpiral2.png
}
</
{{Output}}
Line 1,490 ⟶ 2,009:
=={{header|Perl}}==
{{trans|Raku}}
<
use constant PI => 3.14159265;
Line 1,503 ⟶ 2,022:
$img->write(file => 'Archimedean-spiral.png');
</syntaxhighlight>
=={{header|Phix}}==
Line 1,510 ⟶ 2,029:
{{libheader|Phix/online}}
You can run this online [http://phix.x10.mx/p2js/Archimedean_spiral.htm here].
<!--<
<span style="color: #000080;font-style:italic;">--
-- demo\rosetta\Archimedean_spiral.exw
-- ===================================
--</span>
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #008080;">include</span> <span style="color: #000000;">pGUI</span><span style="color: #0000FF;">.</span><span style="color: #000000;">e</span>
Line 1,520 ⟶ 2,040:
<span style="color: #004080;">cdCanvas</span> <span style="color: #000000;">cddbuffer</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">cdcanvas</span>
<span style="color: #008080;">function</span> <span style="color: #000000;">redraw_cb</span><span style="color: #0000FF;">(</span><span style="color: #004080;">Ihandle</span> <span style="color: #000080;font-style:italic;">/*ih
<span style="color: #7060A8;">cdCanvasActivate</span><span style="color: #0000FF;">(</span><span style="color: #000000;">cddbuffer</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">deg</span><span style="color: #0000FF;">=</span><span style="color: #000000;">0</span> <span style="color: #008080;">to</span> <span style="color: #000000;">360</span><span style="color: #0000FF;">*</span><span style="color: #000000;">7</span> <span style="color: #008080;">do</span>
<span style="color: #004080;">atom</span> <span style="color: #000000;">rad</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">deg</span><span style="color: #0000FF;">*</span><span style="color: #004600;">PI</span><span style="color: #0000FF;">/</span><span style="color: #000000;">180</span><span style="color: #0000FF;">,</span>
<span style="color: #004080;">integer</span> <span style="color: #000000;">x</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">
<span style="color: #7060A8;">cdCanvasPixel</span><span style="color: #0000FF;">(</span><span style="color: #000000;">cddbuffer</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">x</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">y</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">#00FF00</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
Line 1,548 ⟶ 2,065:
<span style="color: #008080;">procedure</span> <span style="color: #000000;">main</span><span style="color: #0000FF;">()</span>
<span style="color: #7060A8;">IupOpen</span><span style="color: #0000FF;">()</span>
<span style="color: #000000;">canvas</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">IupCanvas</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"RASTERSIZE=500x500"</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- initial size</span>
<span style="color: #7060A8;">IupSetCallbacks</span><span style="color: #0000FF;">(</span><span style="color: #000000;">canvas</span><span style="color: #0000FF;">,</span> <span style="color: #0000FF;">{</span><span style="color: #008000;">"MAP_CB"</span><span style="color: #0000FF;">,</span> <span style="color: #7060A8;">
<span style="color: #
<span style="color: #7060A8;">IupShow</span><span style="color: #0000FF;">(</span><span style="color: #000000;">dlg</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">IupSetAttribute</span><span style="color: #0000FF;">(</span><span style="color: #000000;">canvas</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"RASTERSIZE"</span><span style="color: #0000FF;">,</span> <span style="color: #004600;">NULL</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- release the minimum limitation</span>
Line 1,565 ⟶ 2,078:
<span style="color: #000000;">main</span><span style="color: #0000FF;">()</span>
<!--</
=={{header|Processing}}==
Line 1,572 ⟶ 2,085:
====with points====
When drawn with points the rotation must be very small, and initially the animation is very slow. This is because the points will move further and further apart as the radius increases.
<
float theta;
float rotation;
Line 1,591 ⟶ 2,104:
// check restart
if (x>width/2.0) frameCount=-1;
}</
====with points, rotated====
Rotates the canvas matrix using the built-in rotate() and draws a simple point, rather than computing rotated coordinates with sin()/cos().
<
float rotation;
Line 1,612 ⟶ 2,125:
// check restart
if (theta>width/2.0) frameCount=-1;
}</
====with points, vector====
Rotates a vector object of increasing magnitude using the built-in PVector and draws its point, rather than computing rotated coordinates with sin()/cos().
<
float rotation;
Line 1,634 ⟶ 2,147:
// check restart
if (pv.mag()>width/2.0) frameCount=-1;
}</
====with line segments====
Draw each new line segments anchored to the previous point in order to keep the spiral visually connected no matter how much the radius expands.
<
float theta;
float rotation;
Line 1,659 ⟶ 2,172:
// check restart
if (px>width/2.0) frameCount=-1;
}</
====with line segments, rotated====
Uses the built-in rotate() and screenX() to rotate the frame of reference and then recover the rotated screen position of each next point. Draw each new line segments anchored to the previous point in order to keep the spiral visually connected no matter how much the radius expands.
<
float theta;
float rotation;
Line 1,688 ⟶ 2,201:
py = y;
if (theta>width/2.0) frameCount=-1; // start over
}</
==={{header|Processing Python mode}}===
====with points====
When drawn with points the rotation must be very small, and initially the animation is very slow. This is because the points will move further and further apart as the radius increases.
<
rotation = 0.1
Line 1,710 ⟶ 2,223:
if x > width / 2.0:
background(255)
theta = 0</
=={{header|Python}}==
Using the '''turtle''' module.
<
from math import *
color("blue")
Line 1,749 ⟶ 2,238:
goto(x, y)
up()
done()</
=={{header|Quackery}}==
<syntaxhighlight lang="quackery"> [ $ "turtleduck.qky" loadfile ] now!
turtle
20 frames
0 n->v
900 times
[ 2dup walk
1 20 v+
1 36 turn ]
2drop
1 frames</syntaxhighlight>
{{out}}
[[File:Quackery Archimedean spiral.png]]
=={{header|R}}==
<
plot((1 + s) * exp(1i * s), type="l"))</
=={{header|Racket}}==
[[File:archemedian-spiral-racket.png]]
<
(require plot
racket/math)
Line 1,779 ⟶ 2,284:
;; writes to a file so hopefully, I can post it to RC...
(plot-file (list (archemedian-spiral-renderer2d 0.0 24 4))
"images/archemidian-spiral-racket.png")</
=={{header|Raku}}==
Line 1,785 ⟶ 2,290:
{{works with|Rakudo|2018.10}}
<syntaxhighlight lang="raku"
my ($w, $h) = (400, 400);
Line 1,795 ⟶ 2,300:
}
$png.write: 'Archimedean-spiral-perl6.png';</
=={{header|REXX}}==
Line 1,801 ⟶ 2,306:
Note: the value of <big><big> ''a'' </big></big> doesn't mean that much as the plot is automatically centered.
<
parse arg cy a b inc chr . /*obtain optional arguments from the CL*/
if cy=='' | cy=="," then cy= 3 /*Not specified? Then use the default.*/
Line 1,842 ⟶ 2,347:
if x=pi * .5 then return 1; if x==pi*1.5 then return -1
if abs(x)=pi | x=0 then return 0; q= x*x; z= x
do k=2 by 2 until p=z; p= z; _= -_ *q/(k*k+k); z= z+_; end; return z</
{{out|output|text= when using the following inputs: <tt> 13 , 5 , db </tt>}}
Line 2,042 ⟶ 2,547:
=={{header|Ring}}==
<
/*
+---------------------------------------------------------------------------------------------------------
Line 2,147 ⟶ 2,652:
return
</syntaxhighlight>
=={{header|RPL}}==
[[File:Archimedean.png|thumb|right|HP-48G emulator screenshot]]
{{works with|HP|48G}}
« → a b
« -20 20 DUP2 XRNG YRNG
POLAR RAD 'a+b*t' STEQ { t 0 18.9 } INDEP
ERASE DRAW { } PVIEW
{ EQ PPAR } PURGE
» » '<span style="color:blue">ARCHI</span>' STO
1 1 <span style="color:blue">ARCHI</span>
=={{header|Ruby}}==
Line 2,153 ⟶ 2,670:
{{libheader|JRubyArt}}
JRubyArt is an implementation of Processing in ruby, that uses JRuby to provide the interoperability with the java libraries.
<
INCR = 0.1
attr_reader :x, :theta
Line 2,174 ⟶ 2,691:
size(300, 300)
end
</syntaxhighlight>
=={{header|Rust}}==
<
extern crate bmp;
Line 2,208 ⟶ 2,725:
// Save the image
let _ = img.save("archimedean_spiral.bmp").unwrap_or_else(|e| panic!("Failed to save: {}", e));
}</
=={{header|SAS}}==
<
h=constant('pi')/40;
do i=0 to 400;
Line 2,224 ⟶ 2,741:
proc sgplot;
series x=x y=y;
run;</
=={{header|Scala}}==
===Java Swing Interoperability===
<syntaxhighlight lang="scala">
object ArchimedeanSpiral extends App {
Line 2,295 ⟶ 2,812:
)
}</
=={{header|Scheme}}==
{{libheader|Scheme/PsTk}}
<
(import (scheme base)
(scheme complex)
Line 2,335 ⟶ 2,852:
(draw-spiral canvas))
(tk-event-loop tk))
</syntaxhighlight>
=={{header|Scilab}}==
<syntaxhighlight lang="text">a = 3;
b = 2;
Line 2,355 ⟶ 2,872:
scf(2);
plot2d(x,y);</
=={{header|Seed7}}==
<
include "draw.s7i";
include "keybd.s7i";
Line 2,383 ⟶ 2,900:
theta +:= delta;
end while;
ignore(getc(KEYBOARD));
end func;</
=={{header|Sidef}}==
{{trans|Raku}}
<
define π = Num.pi
Line 2,403 ⟶ 2,920:
}
img.write(file => 'Archimedean_spiral.png')</
Output image: [https://github.com/trizen/rc/blob/master/img/archimedean-spiral-sidef.png Archimedean spiral]
=={{header|Stata}}==
<
scalar h=_pi/40
set obs 400
Line 2,413 ⟶ 2,930:
gen x=(1+t)*cos(t)
gen y=(1+t)*sin(t)
line y x</
=={{header|Tcl}}==
This creates a little Tk GUI where you can interactively enter values for `a` and `b`. The spiral will be re-drawn automatically thanks to `trace`:
<
# create widgets
Line 2,482 ⟶ 2,999:
update ;# lay out widgets before trying to draw
draw
vwait forever ;# go into event loop until window is closed</
=={{header|Wren}}==
{{trans|Sidef}}
{{libheader|DOME}}
<
import "dome" for Window
Line 2,539 ⟶ 3,031:
static draw(dt) {}
}</
{{out}}
[[File:Wren-Archimedean_spiral.png]]
=={{header|XPL0}}==
Looks a lot like the C++ image.
<
[SetVid($12); \set 640x480 graphics
A:= 0.0; B:= 3.0; T:= 0.0;
Line 2,552 ⟶ 3,047:
T:= T + 0.03; \increase angle (Theta)
until T >= 314.159; \50 revs
]</
=={{header|zkl}}==
[[File:ArchimedeanSpiral.zk.jpg|250px|thumb|right]]
Uses the PPM class from http://rosettacode.org/wiki/Bitmap/Bresenham%27s_line_algorithm#zkl
<
w,h:=640,640; centerX,centerY:=w/2,h/2;
bitmap:=PPM(w+1,h+1,0xFF|FF|FF); // White background
Line 2,578 ⟶ 3,063:
}
bitmap.writeJPGFile("archimedeanSpiral.jpg");
}(0,5,7);</
| |||