Archimedean spiral: Difference between revisions

=={{header|Action!}}==

Action! does not provide trigonometric functions. Therefore a simple implementation for Sin and Cos function has been provided.

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

DO UNTIL CH#$FF OD

CH=$FF

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

Window.Finalize;

SDL.Finalise;

 

=={{header|ALGOL W}}==

{{Trans|AWK}}

This version doubles the characters horiontally to give a slightly more rounded shape.

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

write()

end for_i

{{out}}

<pre>

********

********

</pre>

 

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

 

[https://i.imgur.com/hZDqjjM.png See the plot on imgur.]

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

Gdip_Shutdown(pToken)

ExitApp

 

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

 

=={{header|BASIC}}==

==={{header|AmigaBASIC}}===

{{trans|Locomotive Basic}}

b=1.5

pi=3.141592

r=a+b*t

LINE -(320+2*r*SIN(t),100+r*COS(t))

 

==={{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|GW-BASIC}}===

20 B = 1

30 SCREEN 1

100 IF INKEY$="" THEN GOTO 100

110 SCREEN 2:SCREEN 0

 

==={{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|Locomotive Basic}}===

{{trans|Commodore BASIC}}

20 mode 2:rad:move 320,200

30 for t=0 to 40*pi step 0.2

50 draw r*sin(t)+320,r*cos(t)+200

60 next

 

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

'runs in Run Basic

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

print "Thank you and Goodbye"

end

 

==={{header|QBasic}}===

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

The BQN online REPL supports some basic plotting functionality through <code>•Plot</code>. This is used to create a spiral plotting function:

 

 

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.

#include<graphics.h>

#include<stdio.h>

closegraph();

}

 

=={{header|C sharp|C#}}==

 

using System.Linq;

using System.Drawing;

}

}

 

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

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

#include <windows.h>

#include <string>

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

}

 

=={{header|Clojure}}==

{{Works with| Incanter}}

(use '(incanter core stats charts io))

 

 

(view (parametric-plot arq-spiral 0 (* 10 Math/PI)))

 

 

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

1.2 S B=2

1.3 S N=250

 

4.1 S X2=R*FSIN(.2*(T+1))

This program uses FOCAL-11 on a DEC GT40 vector graphics terminal.

 

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

<head>

<title>Archimedean spiral</title>

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

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

const

ai = 0.05,

Array.from({

length: 1 + n - m

 

=={{header|jq}}==

'''Works with gojq, the Go implementation of jq'''

====SVG version====

 

def pi: 1 | atan * 4;

 

spiral(0; 10; 0.025)

{{out}}

 

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

| "\(.)\n" ;

 

{{out}}

As for [[#awk|awk]].

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

{{libheader|LÖVE}}

{{works with|LÖVE|11.3}}

a=1

b=2

end

end

 

=={{header|M2000 Interpreter}}==

module Archimedean_spiral {

smooth on ' enable GDI+

}

Archimedean_spiral

 

=={{header|Maple}}==

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

 

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

 

=={{header|Nim}}==

{{libheader|gintro}}

 

import gintro/[glib, gobject, gtk, gio, cairo]

let app = newApplication(Application, "Rosetta.spiral")

discard app.connect("activate", activate)

 

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

{{trans|Raku}}

use constant PI => 3.14159265;

 

 

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

 

=={{header|Phix}}==

{{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 style="color: #000000;">main</span><span style="color: #0000FF;">()</span>

 

=={{header|Processing}}==

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

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

 

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

 

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

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

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

 

if x > width / 2.0:

background(255)

 

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

{{works with|Rakudo|2018.10}}

 

 

my ($w, $h) = (400, 400);

}

 

 

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

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

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

 

 

=={{header|Ring}}==

/*

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

return

 

=={{header|Ruby}}==

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

size(300, 300)

end

 

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

b = 2;

 

 

scf(2);

 

=={{header|Seed7}}==

 

include "draw.s7i";

include "keybd.s7i";

theta +:= delta;

end while;

ignore(getc(KEYBOARD));

 

=={{header|Sidef}}==

{{trans|Raku}}

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

{{trans|Sidef}}

{{libheader|DOME}}

import "dome" for Window

 

 

static draw(dt) {}

 

=={{header|XPL0}}==

Looks a lot like the C++ image.

[SetVid($12); \set 640x480 graphics

A:= 0.0; B:= 3.0; T:= 0.0;

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

}

bitmap.writeJPGFile("archimedeanSpiral.jpg");