Archimedean spiral: Difference between revisions
Content deleted Content added
Ada version |
|||
(106 intermediate revisions by 39 users not shown) | |||
Line 1:
{{task}}
[[File:Archimedian spiral j.png|300px|right]]
The [[wp:Archimedean_spiral|Archimedean spiral]] is a spiral named after the Greek mathematician Archimedes.
Line 13 ⟶ 14:
;Task
Draw an Archimedean spiral.
<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;
with SDL.Video.
with SDL.Events.Events;
Line 35 ⟶ 89:
T_Last : constant := 100.0;
Event : SDL.Events.Events.Events;
procedure Draw_Archimedean_Spiral is
use type SDL.C.int;
use Ada.Numerics.Elementary_Functions;
Pi : constant := Ada.Numerics.Pi;
Step : constant := 0.
T : Float;
R : Float;
Line 61 ⟶ 104:
loop
R := A + B * T;
Renderer.Draw
(Point =>
Y => Height / 2 - SDL.C.int (R * Sin (T, 2.0 * Pi))));
exit when T >= T_Last;
T := T + Step;
Line 85 ⟶ 129:
end if;
SDL.Video.Windows.Makers.Create (Win =>
Title => "Archimedean spiral",
Position => SDL.Natural_Coordinates'(X => 10, Y => 10),
Size => SDL.Positive_Sizes'(Width, Height),
Flags => 0);
Renderer.Set_Draw_Colour ((0, 0, 0, 255));
Renderer.Set_Draw_Colour ((0, 220, 0, 255));
Draw_Archimedean_Spiral;
Wait;
SDL.Finalise;
end Archimedean_Spiral;</
=={{header|ALGOL 68}}==
ASCII art.
{{Trans|ALGOL W}}
<syntaxhighlight lang="algol68">
BEGIN # draw an Archimedian spiral using ASCII art #
# Translation of Applesoft Basic via AWK and Algol W #
PROC max = ( INT x, y )INT: IF x > y THEN x ELSE y FI;
PROC min = ( INT x, y )INT: IF x < y THEN x ELSE y FI;
[ 1 : 255, 1 : 255 ]CHAR arr;
FOR i FROM 1 LWB arr TO 1 UPB arr DO
FOR j FROM 2 LWB arr TO 2 UPB arr DO arr[ i, j ] := " " OD
OD;
INT x min := 1 UPB arr + 1, y min := 2 UPB arr + 1;
INT x max := 1 LWB arr - 1, y max := 2 LWB arr - 1;
REAL m = 6 * pi, h = 96, s = 0.02;
REAL w = 1.5 * h;
REAL t := s;
WHILE t <= m DO # build spiral #
REAL r = t + 1;
INT x = ROUND ( r * cos( t ) + w );
INT y = ROUND ( r * sin( t ) + h );
IF x >= 1 LWB arr AND y >= 2 LWB arr
AND x <= 1 UPB arr AND y <= 2 UPB arr
THEN
arr[ x, y ] := "*";
x min := min( x min, x );
x max := max( x max, x );
y min := min( y min, y );
y max := max( y max, y );
FI;
t +:= s
OD;
FOR i FROM x min TO x max DO # print spiral #
FOR j FROM y min TO y max DO
CHAR c = arr[ i, j ];
print( ( c, c ) )
OD;
print( ( newline ) )
OD
END
</syntaxhighlight>
{{out}}
<pre style="font-size: 50%;">
**************
******** ********
****** ****
**** ******
**** ****
**** ****
**** ****
**** ****************** **
**** **** ****** **
** **** **** ****
**** ** **** **
** **** **** **
** **** ** **
** ** ********** **** **
** **** **** **** ** **
** ** ** **** ** **
** ** **** ** ** **
** ** ** **** ** **
** ** ** ****** ** **
** ** ** **** **
** ** **** ** **
** ** ** **** **
** ** **** **** **
** ** ****** **** ****
** **** ************** **
** ** **
**** ** ****
** **** ****
**** **** ******
** ****** ******
** ******** ********
** **********
**
****
******
******
********
********
</pre>
=={{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, x, y;
string(255) array arr ( 1 :: 255 );
real h, w, m, s, t;
for i := 1 until 255 do arr( i ) := " ";
x_min := y_min := 9999;
x_max := y_max := 0;
h := 96;
w := h + h / 2;
m := 6 * PI;
s := 0.02;
t := s;
while t <= m do begin % build spiral %
real r;
r := t + 1;
x := round(r * cos(t) + w);
y := round(r * sin(t) + h);
if x > 0 and y > 0 and x < 256 and y < 256 then 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)
end if_x_and_y_in_range ;
t := t + s
end while__t_le_m ;
for i := x_min until x_max do begin % print spiral %
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 style="font-size: 50%;">
**************
******** ********
****** ****
**** ******
**** ****
**** ****
**** ****
**** ****************** **
**** **** ****** **
** **** **** ****
**** ** **** **
** **** **** **
** **** ** **
** ** ********** **** **
** **** **** **** ** **
** ** ** **** ** **
** ** **** ** ** **
** ** ** **** ** **
** ** ** ****** ** **
** ** ** **** **
** ** **** ** **
** ** ** **** **
** ** **** **** **
** ** ****** **** ****
** **** ************** **
** ** **
**** ** ****
** **** ****
**** **** ******
** ****** ******
** ******** ********
** **********
**
****
******
******
********
********
</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}}==
'''Works in: [[Dyalog APL]]'''
Uses Dyalog's [https://sharpplot.com/ SharpPlot] integration, which works on all supported platforms.
<syntaxhighlight lang="apl"> 'InitCauseway' 'View' ⎕CY 'sharpplot'
InitCauseway ⍬ ⍝ initialise current namespace
sp←⎕NEW Causeway.SharpPlot
sp.DrawPolarChart {⍵(360|⍵)}⌽⍳720
View sp</syntaxhighlight>
[https://i.imgur.com/hZDqjjM.png See the plot on imgur.]
=={{header|AutoHotkey}}==
Requires [https://github.com/tariqporter/Gdip GDIP]
<syntaxhighlight lang="autohotkey">if !pToken := Gdip_Startup()
{
MsgBox, 48, gdiplus error!, Gdiplus failed to start. Please ensure you have gdiplus on your system
ExitApp
}
OnExit, Exit
SysGet, MonitorPrimary, MonitorPrimary
SysGet, WA, MonitorWorkArea, %MonitorPrimary%
WAWidth := WARight-WALeft
WAHeight := WABottom-WATop
Gui, 1: -Caption +E0x80000 +LastFound +AlwaysOnTop +ToolWindow +OwnDialogs
Gui, 1: Show, NA
hwnd1 := WinExist()
hbm := CreateDIBSection(WAWidth, WAHeight)
hdc := CreateCompatibleDC()
obm := SelectObject(hdc, hbm)
G := Gdip_GraphicsFromHDC(hdc)
Gdip_SetSmoothingMode(G, 4)
pPen := Gdip_CreatePen(0xffff0000, 3)
;--------------------------------
a := 1, b := 4, th := 0.1, step := 0.1
loop, 720
{
th += step
r := a + b * th
x1 := r * Cos(th)
y1 := r * Sin(th)
x1 += A_ScreenWidth/2
y1 += A_ScreenHeight/2
if (x2 && y2)
Gdip_DrawLine(G, pPen, x1, y1, x2, y2)
x2 := x1, y2 := y1
if GetKeyState("Esc", "P")
break
; next two lines are optional to watch it draw
; Sleep 10
; UpdateLayeredWindow(hwnd1, hdc, WALeft, WATop, WAWidth, WAHeight)
}
UpdateLayeredWindow(hwnd1, hdc, WALeft, WATop, WAWidth, WAHeight)
;--------------------------------
return
Exit:
Gdip_DeletePen(pPen)
SelectObject(hdc, obm)
DeleteObject(hbm)
DeleteDC(hdc)
Gdip_DeleteGraphics(G)
Gdip_Shutdown(pToken)
ExitApp
Return</syntaxhighlight>
=={{header|AWK}}==
<syntaxhighlight lang="awk">
# syntax: GAWK -f ARCHIMEDEAN_SPIRAL.AWK
# converted from Applesoft BASIC
Line 142 ⟶ 469:
function max(x,y) { return((x > y) ? x : y) }
function min(x,y) { return((x < y) ? x : y) }
</syntaxhighlight>
{{out}}
<pre>
Line 183 ⟶ 510:
*****
</pre>
=={{header|BASIC}}==
==={{header|AmigaBASIC}}===
{{trans|Locomotive Basic}}
[[File:Amigabasic spiral.png|thumb|Output]]
<syntaxhighlight lang="qbasic">a=1.5
b=1.5
pi=3.141592
PSET (320,100)
FOR t=0 TO 40*pi STEP .1
r=a+b*t
LINE -(320+2*r*SIN(t),100+r*COS(t))
NEXT</syntaxhighlight>
==={{header|Applesoft BASIC}}===
<
120 LET W = H + H / 2
130 HGR2
Line 205 ⟶ 545:
280 HPLOT X,Y
290 NEXT
</syntaxhighlight>
==={{header|BASIC256}}===
<syntaxhighlight lang="basic256">
# Basic-256 ver 1.1.4
# Archimedean Spiral
Line 221 ⟶ 561:
i = 1 : t = 0 : xn = 0 : yn = 0 # Initial values
iter = 150 : q = 30
line x,0,x,height
Line 237 ⟶ 576:
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 262 ⟶ 634:
90 X0 = X : Y0 = Y
100 NEXT T
110 GOTO 110</
==={{header|FreeBASIC}}===
<
' compile with: fbc -s gui
Line 284 ⟶ 656:
PSet(halfscrn + x, halfscrn - y), RGB(255, 255, 255)
Next
' empty keyboard buffer
Line 290 ⟶ 661:
Print : Print "hit any key to end program"
Sleep
End</
==={{header|GW-BASIC}}===
<syntaxhighlight lang="gwbasic">10 A = 0
20 B = 1
30 SCREEN 1
40 FOR THETA = 0 TO 160 STEP .01
50 R = A + B*THETA
60 X = R*COS(THETA)
70 Y = R*SIN(THETA)
80 PSET (160+X, 100-Y),3
90 NEXT THETA
100 IF INKEY$="" THEN GOTO 100
110 SCREEN 2:SCREEN 0
120 END</syntaxhighlight>
==={{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}}
[[File:Cpcbasic spiral.png|thumb|Output]]
<syntaxhighlight lang="locobasic">10 a=1.5:b=2
20 mode 2:rad:move 320,200
30 for t=0 to 40*pi step 0.2
40 r=a+b*t
50 draw r*sin(t)+320,r*cos(t)+200
60 next
70 while inkey$="":wend</syntaxhighlight>
==={{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 327 ⟶ 747:
print "Thank you and Goodbye"
end
End</
==={{header|
<
WINDOW (-2.67, -2!)-(2.67, 2!)
PI = 4 * ATN(1)
Line 341 ⟶ 761:
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 390 ⟶ 854:
closegraph();
}
</syntaxhighlight>
=={{header|C sharp|C#}}==
<syntaxhighlight lang="csharp">using System;
using System.Linq;
using System.Drawing;
using System.Diagnostics;
using System.Drawing.Drawing2D;
class Program
{
const int width = 380;
const int height = 380;
static PointF archimedeanPoint(int degrees)
{
const double a = 1;
const double b = 9;
double t = degrees * Math.PI / 180;
double r = a + b * t;
return new PointF { X = (float)(width / 2 + r * Math.Cos(t)), Y = (float)(height / 2 + r * Math.Sin(t)) };
}
static void Main(string[] args)
{
var bm = new Bitmap(width, height);
var g = Graphics.FromImage(bm);
g.SmoothingMode = SmoothingMode.AntiAlias;
g.FillRectangle(new SolidBrush(Color.White), new Rectangle { X = 0, Y = 0, Width = width, Height = height });
var pen = new Pen(Color.OrangeRed, 1.5f);
var spiral = Enumerable.Range(0, 360 * 3).AsParallel().AsOrdered().Select(archimedeanPoint);
var p0 = new PointF(width / 2, height / 2);
foreach (var p1 in spiral)
{
g.DrawLine(pen, p0, p1);
p0 = p1;
}
g.Save(); // is this really necessary ?
bm.Save("archimedes-csharp.png");
Process.Start("archimedes-csharp.png"); // Launches default photo viewing app
}
}
</syntaxhighlight>
=={{header|C++}}==
[[File:SpiralCpp.png|200px|thumb|right]]
<
#include <windows.h>
#include <string>
Line 505 ⟶ 1,012:
spiral s; s.draw( 16, 8 ); return 0;
}
</syntaxhighlight>
=={{header|
{{Works with| Incanter}}
<syntaxhighlight lang="clojure">
(use '(incanter core stats charts io))
(defn Arquimidean-function
[a b theta]
(+ a (* theta b)))
(defn transform-pl-xy [r theta]
(let [x (* r (sin theta))
y (* r (cos theta))]
[x y]))
(defn arq-spiral [t] (transform-pl-xy (Arquimidean-function 0 7 t) t))
(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 555 ⟶ 1,082:
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 625 ⟶ 1,152:
</syntaxhighlight>
=={{header|
<syntaxhighlight lang="basic">bgcolor 0, 0, 0
cls graphics
fgcolor 255, 255, 0
define pi = 3.14, size = 80
define x = 250, y = 200
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.online/show/#cod=JcwxCsAgEETRfk8xdQQRol08TSK4IAZUUG8f11TDg88kzqHz0yKMtjTg4QzNf3rkFFBwCQCk1S4euN+KBoWxVTlvTWkKlF9Xxgma4CRNHw== Run it]
<syntaxhighlight lang=text>
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}}==
<syntaxhighlight lang="focal">1.1 S A=1.5
1.2 S B=2
1.3 S N=250
1.4 F T=1,N; D 2
1.5 X FSKP(2*N)
1.6 Q
2.1 S R=A+B*T; D 3
2.2 X FPT(2*T,X1+512,Y1+390)
2.3 S R=A+B*(T+1); D 4
2.4 X FVEC(2*T+1,X2-X1,Y2-Y1)
3.1 S X1=R*FSIN(.2*T)
3.2 S Y1=R*FCOS(.2*T)
4.1 S X2=R*FSIN(.2*(T+1))
4.2 S Y2=R*FCOS(.2*(T+1))</syntaxhighlight>
This program uses FOCAL-11 on a DEC GT40 vector graphics terminal.
=={{header|Frege}}==
Line 653 ⟶ 1,249:
{{Works with|Frege|3.23.888}}
<
import Java.IO
Line 741 ⟶ 1,337:
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 795 ⟶ 1,437:
log.Fatal(err)
}
}</
=={{header|Haskell}}==
Line 802 ⟶ 1,444:
{{libheader|Juicy.Pixels}}
{{libheader|Rasterific}}
<
-- stack --resolver lts-7.0 --install-ghc runghc --package Rasterific --package JuicyPixels
Line 828 ⟶ 1,470:
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 834 ⟶ 1,476:
=={{header|J}}==
[[File:Archimedian spiral j.png|200px|thumb|right]]
<
'aspect 1' plot (*^)j.0.01*i.1400</
<div style="clear:both"></div>
Line 842 ⟶ 1,484:
[[File:archimedian_spiral.png|300px|thumb|right]]
{{works with|Java|8}}
<
import static java.lang.Math.*;
import javax.swing.*;
Line 925 ⟶ 1,567:
});
}
}</
=={{header|JavaScript}}==
===ES5===
{{Works with|Chrome}}
[[File:ASjs.png|200px|right|thumb|Output ASjs.png]]
<
<!-- ArchiSpiral.html -->
<html>
Line 955 ⟶ 1,598:
}
</script></body></html>
</syntaxhighlight>
{{Output}}
<pre>
Line 961 ⟶ 1,604:
spiral as a png-file, for example.
</pre>
===ES6===
Assumes the same HTML canvas embedding as above, but is functionally composed.
Defines and logs a set of points, before rendering them to canvas.
<syntaxhighlight lang="html"><html>
<head>
<title>Archimedean spiral</title>
<style>h3 {font-family:sans-serif; color:gray;}</style>
</head>
<body onload="main('red')(15)">
<h3>Archimedean spiral</h3></p>
<canvas id="spiral" width="640" height="640" style="border: 2px outset;"></canvas>
<script></syntaxhighlight>
<syntaxhighlight lang="javascript">const main = strColor => intCycles => {
const
ai = 0.05,
ri = 0.1,
cvs = document.getElementById('spiral'),
ctx = cvs.getContext('2d'),
s = cvs.width / 2,
points = enumFromTo(1)(
Math.PI * 2 * intCycles / ai
).map(i => [Math.cos, Math.sin].map(
f => ri * i * f(ai * i) + s
));
return (
console.log(points),
ctx.fillStyle = 'white',
ctx.fillRect(0, 0, cvs.width, cvs.height),
ctx.beginPath(),
points.forEach(xy => ctx.lineTo(...xy)),
ctx.strokeStyle = strColor,
ctx.stroke(),
points
);
};
// enumFromTo :: Int -> Int -> [Int]
const enumFromTo = m => n =>
Array.from({
length: 1 + n - m
}, (_, i) => m + i);</syntaxhighlight>
<syntaxhighlight lang="html"></script></body></html></syntaxhighlight>
=={{header|jq}}==
{{works with|jq}}
'''Works with gojq, the Go implementation of jq'''
====SVG version====
<syntaxhighlight lang="jq">def spiral($zero; $turns; $step):
def pi: 1 | atan * 4;
def p2: (. * 100 | round) / 100;
def svg:
400 as $width
| 400 as $height
| 2 as $swidth # stroke
| "blue" as $stroke
| (range($zero; $turns * 2 * pi; $step) as $theta
| (((($theta)|cos) * 2 * $theta + ($width/2)) |p2) as $x
| (((($theta)|sin) * 2 * $theta + ($height/2))|p2) as $y
| if $theta == $zero
then "<path fill='transparent' style='stroke:\($stroke); stroke-width:\($swidth)' d='M \($x) \($y)"
else " L \($x) \($y)"
end),
"' />";
"<svg width='100%' height='100%'
xmlns='http://www.w3.org/2000/svg'>",
svg,
"</svg>" ;
spiral(0; 10; 0.025)
</syntaxhighlight>
{{out}}
[https://ibb.co/kMSDzx1 PNG version of SVG file]
(Please feel free to upload to RC)
====ASCII Art Version====
{{trans|awk}}
<syntaxhighlight lang="jq">def spiral($a; $b; $step; $h):
def min($x;$y): if $x <= $y then $x else $y end;
def max($x;$y): if $x <= $y then $y else $x end;
def pi: 1 | atan * 4;
(6 * pi) as $m
| ($h * 1.5) as $w
| { x_min: 9999, y_min: 9999,
x_max: 0, y_max: 0,
arr: [] }
| reduce range($step; $m+$step; $step) as $t (.;
.r = $a + $b * $t
| ((.r * ($t|cos) + $w) | round) as $x
| ((.r * ($t|sin) + $h) | round) as $y
| if $x <= 0 or $y <= 0 then .
elif $x >= 280 then .
elif $y >= 192 then .
else .arr[$x][$y] = "*"
| .x_min = min(.x_min; $x)
| .x_max = max(.x_max; $x)
| .y_min = min(.y_min; $y)
| .y_max = max(.y_max; $y)
end )
# ... and print it
| .arr as $arr
| range(.x_min; .x_max + 1) as $i
| reduce range(.y_min; .y_max+1) as $j ( "";
. + ($arr[$i][$j] // " ") )
| "\(.)\n" ;
spiral(1; 1; 0.02; 96)</syntaxhighlight>
{{out}}
As for [[#awk|awk]].
=={{header|Julia}}==
{{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 995 ⟶ 1,756:
=={{header|Kotlin}}==
{{trans|Java}}
<
import java.awt.*
Line 1,070 ⟶ 1,831:
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
cycles=40
step=0.001
x=0
y=0
function love.load()
x = love.graphics.getWidth()/2
y = love.graphics.getHeight()/2
end
function love.draw()
love.graphics.print("a="..a,16,16)
love.graphics.print("b="..b,16,32)
for i=0,cycles*math.pi,step do
love.graphics.points(x+(a + b*i)*math.cos(i),y+(a + b*i)*math.sin(i))
end
end
</syntaxhighlight>
=={{header|M2000 Interpreter}}==
<syntaxhighlight lang="m2000 interpreter">
module Archimedean_spiral {
smooth on ' enable GDI+
def r(θ)=5+3*θ
cls #002222,0
pen #FFFF00
refresh 5000
every 1000 {
\\ redifine window (console width and height) and place it to center (symbol ;)
Window 12, random(10, 18)*1000, random(8, 12)*1000;
move scale.x/2, scale.y/2
let N=2, k1=pi/120, k=k1, op=5, op1=1
for i=1 to int(1200*min.data(scale.x, scale.y)/18000)
pen op
swap op, op1
Width 3 {draw angle k, r(k)*n}
k+=k1
next
refresh 5000
\\ press space to exit loop
if keypress(32) then exit
}
pen 14
cls 5
refresh 50
}
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}}
<syntaxhighlight lang="nim">import math
import gintro/[glib, gobject, gtk, gio, cairo]
const
Width = 601
Height = 601
Limit = 12 * math.PI
Origin = (x: float(Width div 2), y: float(Height div 2))
B = floor((Width div 2) / Limit)
#---------------------------------------------------------------------------------------------------
proc draw(area: DrawingArea; context: Context) =
## Draw the spiral.
var theta = 0.0
var delta = 0.01
var (prevx, prevy) = Origin
# Clear the region.
context.moveTo(0, 0)
context.setSource(0.0, 0.0, 0.0)
context.paint()
# Draw the spiral.
context.setSource(1.0, 1.0, 0.0)
context.moveTo(Origin.x, Origin.y)
while theta < Limit:
let r = B * theta
let x = Origin.x + r * cos(theta) # X-coordinate on drawing area.
let y = Origin.y + r * sin(theta) # Y-coordinate on drawing area.
context.lineTo(x, y)
context.stroke()
# Set data for next round.
context.moveTo(x, y)
prevx = x
prevy = y
theta += delta
#---------------------------------------------------------------------------------------------------
proc onDraw(area: DrawingArea; context: Context; data: pointer): bool =
## Callback to draw/redraw the drawing area contents.
area.draw(context)
result = true
#---------------------------------------------------------------------------------------------------
proc activate(app: Application) =
## Activate the application.
let window = app.newApplicationWindow()
window.setSizeRequest(Width, Height)
window.setTitle("Archimedean spiral")
# Create the drawing area.
let area = newDrawingArea()
window.add(area)
# Connect the "draw" event to the callback to draw the spiral.
discard area.connect("draw", ondraw, pointer(nil))
window.showAll()
#———————————————————————————————————————————————————————————————————————————————————————————————————
let app = newApplication(Application, "Rosetta.spiral")
discard app.connect("activate", activate)
discard app.run()</syntaxhighlight>
=={{header|PARI/GP}}==
Line 1,094 ⟶ 2,058:
[[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,114 ⟶ 2,078:
ArchiSpiral(640,5,1); \\ArchiSpiral2.png
}
</
{{Output}}
Line 1,124 ⟶ 2,088:
*** The Archimedean spiral: size=640 loops=5 c=1
</pre>
=={{header|PascalABC.NET}}==
[[File:Arch1.png|200px|thumb|right|Arch spiral PascalABC.NET]]
<syntaxhighlight lang="delphi">
uses PlotWPF,GraphWPF;
begin
Window.SetSize(600,600);
var seq := Range(0,20,0.1);
var xx := seq.Select(t -> t * Cos(t));
var yy := seq.Select(t -> t * Sin(t));
LineGraphWPF.Create(xx,yy,Colors.Black);
end.
</syntaxhighlight>
=={{header|Perl}}==
{{trans|
<
use constant PI => 3.14159265;
Line 1,140 ⟶ 2,122:
$img->write(file => 'Archimedean-spiral.png');
</syntaxhighlight>
=={{header|
{{trans|zkl}}
{{libheader|Phix/pGUI}}
{{libheader|Phix/online}}
You can run this online [http://phix.x10.mx/p2js/Archimedean_spiral.htm here].
<!--<syntaxhighlight lang="phix">(phixonline)-->
<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>
<span style="color: #004080;">Ihandle</span> <span style="color: #000000;">dlg</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">canvas</span>
<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><span style="color: #0000FF;">)</span>
<span style="color: #004080;">integer</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">w</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">h</span><span style="color: #0000FF;">}</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">IupGetIntInt</span><span style="color: #0000FF;">(</span><span style="color: #000000;">canvas</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"DRAWSIZE"</span><span style="color: #0000FF;">),</span>
<span style="color: #000000;">a</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">b</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">5</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">cx</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">floor</span><span style="color: #0000FF;">(</span><span style="color: #000000;">w</span><span style="color: #0000FF;">/</span><span style="color: #000000;">2</span><span style="color: #0000FF;">),</span> <span style="color: #000000;">cy</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">floor</span><span style="color: #0000FF;">(</span><span style="color: #000000;">h</span><span style="color: #0000FF;">/</span><span style="color: #000000;">2</span><span style="color: #0000FF;">)</span>
<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: #000000;">r</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">rad</span><span style="color: #0000FF;">*</span><span style="color: #000000;">b</span> <span style="color: #0000FF;">+</span> <span style="color: #000000;">a</span>
<span style="color: #004080;">integer</span> <span style="color: #000000;">x</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">cx</span> <span style="color: #0000FF;">+</span> <span style="color: #7060A8;">floor</span><span style="color: #0000FF;">(</span><span style="color: #000000;">r</span><span style="color: #0000FF;">*</span><span style="color: #7060A8;">cos</span><span style="color: #0000FF;">(</span><span style="color: #000000;">rad</span><span style="color: #0000FF;">)),</span>
<span style="color: #000000;">y</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">cy</span> <span style="color: #0000FF;">+</span> <span style="color: #7060A8;">floor</span><span style="color: #0000FF;">(</span><span style="color: #000000;">r</span><span style="color: #0000FF;">*</span><span style="color: #7060A8;">sin</span><span style="color: #0000FF;">(</span><span style="color: #000000;">rad</span><span style="color: #0000FF;">))</span>
<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>
<span style="color: #7060A8;">cdCanvasFlush</span><span style="color: #0000FF;">(</span><span style="color: #000000;">cddbuffer</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">return</span> <span style="color: #004600;">IUP_DEFAULT</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
<span style="color: #008080;">function</span> <span style="color: #000000;">map_cb</span><span style="color: #0000FF;">(</span><span style="color: #004080;">Ihandle</span> <span style="color: #000000;">ih</span><span style="color: #0000FF;">)</span>
<span style="color: #000000;">cdcanvas</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">cdCreateCanvas</span><span style="color: #0000FF;">(</span><span style="color: #004600;">CD_IUP</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">ih</span><span style="color: #0000FF;">)</span>
<span style="color: #000000;">cddbuffer</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">cdCreateCanvas</span><span style="color: #0000FF;">(</span><span style="color: #004600;">CD_DBUFFER</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">cdcanvas</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">cdCanvasSetBackground</span><span style="color: #0000FF;">(</span><span style="color: #000000;">cddbuffer</span><span style="color: #0000FF;">,</span> <span style="color: #004600;">CD_WHITE</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">cdCanvasSetForeground</span><span style="color: #0000FF;">(</span><span style="color: #000000;">cddbuffer</span><span style="color: #0000FF;">,</span> <span style="color: #004600;">CD_RED</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">return</span> <span style="color: #004600;">IUP_DEFAULT</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
<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;">Icallback</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"map_cb"</span><span style="color: #0000FF;">),</span>
<span style="color: #008000;">"ACTION"</span><span style="color: #0000FF;">,</span> <span style="color: #7060A8;">Icallback</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"redraw_cb"</span><span style="color: #0000FF;">)})</span>
<span style="color: #000000;">dlg</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">IupDialog</span><span style="color: #0000FF;">(</span><span style="color: #000000;">canvas</span><span style="color: #0000FF;">,</span><span style="color: #008000;">`TITLE="Archimedean spiral"`</span><span style="color: #0000FF;">)</span>
<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>
<span style="color: #008080;">if</span> <span style="color: #7060A8;">platform</span><span style="color: #0000FF;">()!=</span><span style="color: #004600;">JS</span> <span style="color: #008080;">then</span>
<span style="color: #7060A8;">IupMainLoop</span><span style="color: #0000FF;">()</span>
<span style="color: #7060A8;">IupClose</span><span style="color: #0000FF;">()</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">procedure</span>
<span style="color: #000000;">main</span><span style="color: #0000FF;">()</span>
<!--</syntaxhighlight>-->
=={{header|Processing}}==
Processing examples are animated, with a new point / segment added each draw() frame. Because Processing includes multiple built-in ways for drawing in rotating frames of reference, there are several ways to approach the Archimedean spiral problem.
===Java 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.
<syntaxhighlight lang="processing">float x, y;
float theta;
float rotation;
void setup() {
size(300, 300);
theta = 0;
rotation = 0.1;
background(255);
}
void draw() {
translate(width/2.0, height/2.0);
x = theta*cos(theta/PI);
y = theta*sin(theta/PI);
point(x, y);
theta = theta + rotation;
// check restart
if (x>width/2.0) frameCount=-1;
}</syntaxhighlight>
====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().
<syntaxhighlight lang="processing">float theta;
float rotation;
void setup() {
size(300, 300);
theta = 0;
rotation = 0.1;
background(255);
}
void draw() {
translate(width/2.0, height/2.0);
theta += rotation;
rotate(theta/PI);
point(theta, 0);
// check restart
if (theta>width/2.0) frameCount=-1;
}</syntaxhighlight>
====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().
<syntaxhighlight lang="processing">PVector pv;
float rotation;
void setup() {
size(300, 300);
rotation = 0.1;
pv = new PVector(rotation, 0);
background(255);
}
void draw() {
translate(width/2.0, height/2.0);
pv.setMag(pv.mag()+rotation);
println(pv.mag());
pv.rotate(rotation/PI);
point(pv.x, pv.y);
// check restart
if (pv.mag()>width/2.0) frameCount=-1;
}</syntaxhighlight>
====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.
<syntaxhighlight lang="processing">float px, py, x, y;
float theta;
float rotation;
void setup() {
size(300, 300);
px = py = x = y = theta = 0;
rotation = 0.1;
background(255);
}
void draw() {
translate(width/2.0, height/2.0);
x = theta*cos(theta/PI);
y = (theta)*sin(theta/PI);
line(x, y,
theta = theta + rotation;
px = x;
py = y;
// check restart
if (px>width/2.0) frameCount=-1;
}</syntaxhighlight>
====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.
<syntaxhighlight lang="processing">float x, y, px, py;
float theta;
float rotation;
void setup() {
size(300, 300);
x = y = px = py = theta = 0;
rotation = 0.1;
background(255);
}
void draw() {
// find coordinates with rotating reference frame
pushMatrix();
x = screenX(theta, 0);
popMatrix();
translate(width/2.0, height/2.0);
theta += rotation;
line(px, py, x, y);
px = x;
py = y;
if (theta>width/2.0) frameCount=-1; // start over
}</syntaxhighlight>
==={{header|
====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.
<syntaxhighlight lang="python">theta = 0
rotation = 0.1
def setup():
size(300, 300)
background(255)
def draw():
global theta
translate(width / 2.0, height / 2.0)
x = theta *
y = theta *
point(x,
theta =
if x > width / 2.0:
background(255)
theta = 0</syntaxhighlight>
=={{header|Python}}==
Using the '''turtle''' module.
<
from math import *
color("blue")
Line 1,272 ⟶ 2,338:
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,302 ⟶ 2,384:
;; 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}}==
(formerly Perl 6)
{{works with|Rakudo|2018.10}}
<syntaxhighlight lang="raku" line>use Image::PNG::Portable;
my ($w, $h) = (400, 400);
my $png = Image::PNG::Portable.new: :width($w), :height($h);
(0, .025 ... 52*π).race.map: -> \Θ {
$png.set: |((cis( Θ / π ) * Θ).reals »+« ($w/2, $h/2))».Int, 255, 0, 255;
}
$png.write: 'Archimedean-spiral-perl6.png';</syntaxhighlight>
=={{header|REXX}}==
Line 1,308 ⟶ 2,406:
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,327 ⟶ 2,425:
y= h + r*sin(t); yy= y % 2 /* " " " Y " " */
if x<0 | y<0 | x>mw | y>mh then iterate /*Is X or Y out of bounds? Then skip.*/
if LOx==. then do; LOx= xx; HIx= xx; LOy= yy; HIy= yy
end /* [↑] find the minimums and maximums.*/
LOx= min(LOx, xx); HIx= max(HIx, xx) /*determine the X MIN and MAX. */
Line 1,336 ⟶ 2,434:
exit /*stick a fork in it, we're all done. */
/*──────────────────────────────────────────────────────────────────────────────────────*/
pi:
plot:
r2r:
/*──────────────────────────────────────────────────────────────────────────────────────*/
numeric
if a=pi * 2 / 3 then return -.5; q= x*x; z= 1
do k=2 by 2 until p=z; p= z; _= -_ *q/(k*k-k); z= z+_; end; return z
/*──────────────────────────────────────────────────────────────────────────────────────*/
if x=pi * .5
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</syntaxhighlight>
{{out|output|text= when using the following inputs: <tt> 13 , 5 , db </tt>}}
Line 1,550 ⟶ 2,647:
=={{header|Ring}}==
<
/*
+---------------------------------------------------------------------------------------------------------
Line 1,655 ⟶ 2,752:
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}}==
{{libheader|RubyGems}}
{{libheader|JRubyArt}}
JRubyArt is an implementation of Processing in ruby, that uses JRuby to provide the interoperability with the java libraries.
<syntaxhighlight lang="ruby">
INCR = 0.1
attr_reader :x, :theta
def setup
sketch_title 'Archimedian Spiral'
@theta = 0
@x = 0
background(255)
translate(width / 2.0, height / 2.0)
begin_shape
(0..50*PI).step(INCR) do |theta|
@x = theta * cos(theta / PI)
curve_vertex(x, theta * sin(theta / PI))
end
end_shape
end
def settings
size(300, 300)
end
</syntaxhighlight>
=={{header|Rust}}==
<
extern crate bmp;
Line 1,689 ⟶ 2,825:
// 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 1,705 ⟶ 2,841:
proc sgplot;
series x=x y=y;
run;</
=={{header|Scala}}==
===Java Swing Interoperability===
<syntaxhighlight lang="scala">
object ArchimedeanSpiral extends App {
Line 1,776 ⟶ 2,912:
)
}</
=={{header|Scheme}}==
{{libheader|Scheme/PsTk}}
<
(import (scheme base)
(scheme complex)
Line 1,835 ⟶ 2,952:
(draw-spiral canvas))
(tk-event-loop tk))
</syntaxhighlight>
=={{header|Scilab}}==
<syntaxhighlight lang="text">a = 3;
b = 2;
theta = linspace(0,10*%pi,1000);
r = a + b .* theta;
//1. Plot using polar coordinates
scf(1);
polarplot(theta,r);
//2. Plot using rectangular coordinates
//2.1 Convert coordinates using Euler's formula
z = r .* exp(%i .* theta);
x = real(z);
y = imag(z);
scf(2);
plot2d(x,y);</syntaxhighlight>
=={{header|Seed7}}==
<
include "draw.s7i";
include "keybd.s7i";
Line 1,863 ⟶ 3,000:
theta +:= delta;
end while;
ignore(getc(KEYBOARD));
end func;</
=={{header|Sidef}}==
{{trans|
<
define π = Num.pi
Line 1,883 ⟶ 3,020:
}
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 1,893 ⟶ 3,030:
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 1,962 ⟶ 3,099:
update ;# lay out widgets before trying to draw
draw
vwait forever ;# go into event loop until window is closed</
=={{header|
{{trans|Sidef}}
{{libheader|DOME}}
<syntaxhighlight lang="wren">import "graphics" for Canvas, Color
import "dome" for Window
class Game {
static init() {
Window.title = "Archimedean Spiral"
__height = 400
Canvas.resize(__width, __height)
Window.resize(__width, __height)
var col = Color.red
static spiral(col) {
var y = ((theta/Num.pi).sin * theta + __height/2).truncate
Canvas.pset(x, y, col)
theta = theta + 0.025
}
}
static update() {}
static draw(dt) {}
}</syntaxhighlight>
{{out}}
[[File:Wren-Archimedean_spiral.png]]
=={{header|XPL0}}==
Looks a lot like the C++ image.
<syntaxhighlight lang="xpl0">real A, B, R, T, X, Y;
[SetVid($12); \set 640x480 graphics
A:= 0.0; B:= 3.0; T:= 0.0;
Move(320, 240); \start at center of screen
repeat R:= A + B*T;
X:= R*Cos(T); Y:= R*Sin(T);
Line(fix(X)+320, 240-fix(Y), 4\red\);
T:= T + 0.03; \increase angle (Theta)
until T >= 314.159; \50 revs
]</syntaxhighlight>
=={{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,012 ⟶ 3,163:
}
bitmap.writeJPGFile("archimedeanSpiral.jpg");
}(0,5,7);</
|