Archimedean spiral: Difference between revisions

{{task}}

 

The [[wp:Archimedean_spiral|Archimedean spiral]] is a spiral named after the Greek mathematician Archimedes.

;Task

Draw an Archimedean spiral.

 

 

=={{header|Ada}}==

{{libheader|SDLAda}}

 

with SDL.Video.Windows.Makers;

with SDL.Events.Events;

 

T_Last : constant := 100.0;

 

 

procedure Draw_Archimedean_Spiral is

use Ada.Numerics.Elementary_Functions;

Pi : constant := Ada.Numerics.Pi;

T : Float;

R : Float;

loop

R := A + B * T;

exit when T >= T_Last;

T := T + Step;

end if;

 

Title => "Archimedean spiral",

Position => SDL.Natural_Coordinates'(X => 10, Y => 10),

Size => SDL.Positive_Sizes'(Width, Height),

Flags => 0);

 

Draw_Archimedean_Spiral;

 

Wait;

SDL.Finalise;

 

=={{header|AWK}}==

# syntax: GAWK -f ARCHIMEDEAN_SPIRAL.AWK

# converted from Applesoft BASIC

function max(x,y) { return((x > y) ? x : y) }

function min(x,y) { return((x < y) ? x : y) }

{{out}}

<pre>

*****

</pre>

=={{header|BASIC}}==

 

==={{header|Applesoft BASIC}}===

120 LET W = H + H / 2

130 HGR2

280 HPLOT X,Y

290 NEXT

 

==={{header|BASIC256}}===

# Basic-256 ver 1.1.4

# Archimedean Spiral

i = 1 : t = 0 : xn = 0 : yn = 0 # Initial values

iter = 150 : q = 30

 

line x,0,x,height

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"

 

 

 

 

==={{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

90 X0 = X : Y0 = Y

100 NEXT T

 

==={{header|FreeBASIC}}===

' compile with: fbc -s gui

 

PSet(halfscrn + x, halfscrn - y), RGB(255, 255, 255)

Next

 

' empty keyboard buffer

Print : Print "hit any key to end program"

Sleep

 

==={{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;

 

==={{header|Run BASIC}}===

'runs in Run Basic

'Run Basic website http://www.runbasic.com

print "Thank you and Goodbye"

end

 

WINDOW (-2.67, -2!)-(2.67, 2!)

PI = 4 * ATN(1)

Y = (A + B * T) * SIN(T)

LINE -(X, Y)

 

==={{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

{{out}}

Screenshot [http://edmundgriffiths.com/zx81archspiral.jpg here].

 

=={{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.

#include<graphics.h>

#include<stdio.h>

closegraph();

}

 

=={{header|C++}}==

[[File:SpiralCpp.png|200px|thumb|right]]

#include <windows.h>

#include <string>

spiral s; s.draw( 16, 8 ); return 0;

}

 

 

 

 

 

 

 

=={{header|Common Lisp}}==

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)))

 

 

 

 

 

 

 

 

 

=={{header|Frege}}==

{{Works with|Frege|3.23.888}}

 

 

import Java.IO

drawSpiral g

f <- File.new "SpiralFrege.png"

 

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|Go}}==

{{works with|go|1.9}}

Creates a PNG file using only built-in packages.

 

import (

log.Fatal(err)

}

 

=={{header|Haskell}}==

{{libheader|Juicy.Pixels}}

{{libheader|Rasterific}}

-- stack --resolver lts-7.0 --install-ghc runghc --package Rasterific --package JuicyPixels

 

polyline points

 

 

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?]]

=={{header|J}}==

[[File:Archimedian spiral j.png|200px|thumb|right]]

 

<div style="clear:both"></div>

[[File:archimedian_spiral.png|300px|thumb|right]]

{{works with|Java|8}}

import static java.lang.Math.*;

import javax.swing.*;

});

}

 

=={{header|JavaScript}}==

{{Works with|Chrome}}

[[File:ASjs.png|200px|right|thumb|Output ASjs.png]]

<!-- ArchiSpiral.html -->

<html>

}

</script></body></html>

{{Output}}

<pre>

Assumes the same HTML canvas embedding as above, but is functionally composed.

Defines and logs a set of points, before rendering them to canvas.

<h3>Archimedean spiral</h3></p>

<canvas id="spiral" width="640" height="640" style="border: 2px outset;"></canvas>

const

ai = 0.05,

 

points = enumFromTo(1)(

).map(i => [Math.cos, Math.sin].map(

f => ri * i * f(ai * i) + s

points.forEach(xy => ctx.lineTo(...xy)),

 

ctx.stroke(),

points

Array.from({

length: 1 + n - m

 

=={{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)

 

{{out}}

=={{header|Kotlin}}==

{{trans|Java}}

 

import java.awt.*

f.isVisible = true

}

 

=={{header|Maple}}==

plots[polarplot](1+2*theta, theta = 0 .. 6*Pi)

 

The built-in function PolarPlot easily creates the desired plot

 

=={{header|MATLAB}}==

b = 1;

turns = 2;

theta = 0:0.1:2*turns*pi;

 

=={{header|PARI/GP}}==

[[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

ArchiSpiral(640,5,1); \\ArchiSpiral2.png

}

{{Output}}

 

=={{header|Perl}}==

use constant PI => 3.14159265;

 

 

$img->write(file => 'Archimedean-spiral.png');

 

=={{header|Phix}}==

{{trans|zkl}}

 

=={{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.

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;

// check restart

if (x>width/2.0) frameCount=-1;

 

Rotates the canvas matrix using the built-in rotate() and draws a simple point, rather than computing rotated coordinates with sin()/cos().

float rotation;

 

// check restart

if (theta>width/2.0) frameCount=-1;

 

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;

 

// check restart

if (pv.mag()>width/2.0) frameCount=-1;

 

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;

// check restart

if (px>width/2.0) frameCount=-1;

 

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;

py = y;

if (theta>width/2.0) frameCount=-1; // start over

 

 

 

=={{header|Python}}==

Using the '''turtle''' module.

 

from math import *

color("blue")

goto(x, y)

up()

 

=={{header|R}}==

 

=={{header|Racket}}==

 

[[File:archemedian-spiral-racket.png]]

(require plot

racket/math)

;; writes to a file so hopefully, I can post it to RC...

(plot-file (list (archemedian-spiral-renderer2d 0.0 24 4))

 

=={{header|REXX}}==

 

Note: &nbsp; the value of &nbsp; <big><big> ''a'' </big></big> &nbsp; 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.*/

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.*/

end /* [↑] find the minimums and maximums.*/

LOx= min(LOx, xx); HIx= max(HIx, xx) /*determine the X MIN and MAX. */

exit /*stick a fork in it, we're all done. */

/*──────────────────────────────────────────────────────────────────────────────────────*/

/*──────────────────────────────────────────────────────────────────────────────────────*/

/*──────────────────────────────────────────────────────────────────────────────────────*/

{{out|output|text=&nbsp; when using the following inputs: &nbsp; <tt> &nbsp; 13 &nbsp; , &nbsp; 5 &nbsp; , &nbsp; db </tt>}}

 

 

=={{header|Ring}}==

/*

+---------------------------------------------------------------------------------------------------------

return

 

=={{header|Rust}}==

extern crate bmp;

 

// 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;

proc sgplot;

series x=x y=y;

 

=={{header|Scala}}==

===Java Swing Interoperability===

 

object ArchimedeanSpiral extends App {

)

 

 

=={{header|Scheme}}==

{{libheader|Scheme/PsTk}}

 

(import (scheme base)

(scheme complex)

(draw-spiral canvas))

(tk-event-loop tk))

 

=={{header|Seed7}}==

 

include "draw.s7i";

include "keybd.s7i";

theta +:= delta;

end while;

ignore(getc(KEYBOARD));

 

=={{header|Sidef}}==

define π = Num.pi

 

}

 

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

gen x=(1+t)*cos(t)

gen y=(1+t)*sin(t)

 

=={{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

update ;# lay out widgets before trying to draw

draw

 

 

=={{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

}

bitmap.writeJPGFile("archimedeanSpiral.jpg");