Ulam spiral (for primes): Difference between revisions

{{trans|Python}}

 

V d = 0

y = y - n I/ 2

 

show_spiral(10, symbol' ‘# ’, space' ‘ ’)

 

{{out}}

{{trans|Fortran}}

Compacted and optimized solution.

ULAM CSECT

USING ULAM,R13 set base register

SPIRAL DC (NS*NS)CL1' '

YREGS

{{out}}

<pre>

The specification of package generic_ulam is as follows:

 

Size: Positive;

-- determines the size of the square

-- and New_Line N times

 

Here is the implementation:

subtype Index is Natural range 0 .. Size-1;

end Print_Spiral;

 

The folowing implementation prints a 29*29 spiral with the primes represented as numbers, and a 10*10 spiral with the primes as boxes. It uses the generic function Prime_Numbers.Is_Prime, as specified in [[Prime decomposition#Ada]].

 

 

procedure Ulam is

NL;

Visual.Print_Spiral;

 

{{out}}

<> <> <>

<> <> </pre>

 

=={{header|C}}==

#include <stdio.h>

#include <stdint.h>

return 0;

}

{{out}}

Run with a side-length of 29

 

The following shows a spiral that's not necessarily square, which has questionable merit:

#include <stdlib.h>

 

}

return 0;

 

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

=== parametric version ===

#include <iostream>

#include <string>

ulam.display( '#' );

return 0;

{{out}}

<pre>

=== generic version ===

ulam.hpp

 

#include <cmath>

}

return os;

ulam.cpp

#include <iostream>

#include "ulam.hpp"

 

return EXIT_SUCCESS;

{{out}}

<pre>[ --- --- --- --- 61 --- 59 --- ---]

 

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

(defun ulam-spiral (n)

(loop for a in (spiral n n (* n n)) do

(when (> n 1) (loop for a from 2 to (isqrt n)

never (zerop (mod n a)))))

 

{{out}}

=={{header|Crystal}}==

{{trans|Go}}

RIGHT

UP

 

puts generate 7, 1, "*"

 

{{out}}

=={{header|D}}==

{{trans|python}}

 

int cell(in int n, int x, int y, in int start=1) pure nothrow @safe @nogc {

void main() {

35.showSpiral;

{{out}}

<pre> # # # #

===Alternative Version===

This generates a PGM image, using the module from the Grayscale Image Task;

 

uint cell(in uint n, int x, int y, in uint start=1) pure nothrow @safe @nogc {

 

img.savePGM("ulam_spiral.pgm");

 

=={{header|EchoLisp}}==

The plot libray includes a '''plot-spiral''' function. The nice result is here : [http://www.echolalie.org/echolisp/help.html#plot-spiral EchoLisp Ulam spiral] .

(lib 'plot)

 

(define (ulam n nmax) (if ( prime? n) *red* (gray (// n nmax))))

(plot-spiral ulam 1000) ;; range [0...1000]

 

=={{header|Elixir}}==

{{trans|Ruby}}

defp cell(n, x, y, start) do

y = y - div(n, 2)

Ulam.show_spiral(9)

Ulam.show_spiral(25)

 

{{out}}

 

=={{header|ERRE}}==

 

!$INTEGER

!$DIM SPIRAL$[N,N]

GEN_ULAM(N,1)

{{out}}

<pre>

=={{header|Factor}}==

{{trans|J}}

math.matrices math.primes math.ranges math.statistics

prettyprint sequences sequences.repeating ;

: ulam-demo ( -- ) 21 ulam-spiral simple-table. ;

 

{{out}}

<pre>

{{works with|GNU Forth|0.7.0}}

All array manipulations were taken from Rosetta Code examples.

43 constant border \ grid size is border x border

border border * constant size

: ulam.spiral run.crawler leave.primes draw.grid ; \ draws the spiral. Execute this word to run.

{{out}}

<pre style="height:60ex;overflow:scroll">

{{works with|Fortran|95 and later}}

Only works with odd sized squares

implicit none

 

end if

end function

Output:

<pre> O O O O O O O

===But if you can use complex numbers...===

Notice that there each move comes in pairs, lengths 1,1, 2,2, 3,3, 4,4, ... with a quarter turn for each move. The order of the work area must be an odd number so that there is a definite middle element to start with and the worm fits between the bounds of the work area rather than striking one wall and leaving tiles unused.

SUBROUTINE ULAMSPIRAL(START,ORDER) !Idle scribbles can lead to new ideas.

Careful with phasing: each lunge's first number is the second placed along its direction.

CALL ULAMSPIRAL(1,49)

END

One could escalate to declaring function IsPrime to be PURE so that it may be used in array expressions, such as CANVAS = SPLOT(ISPRIME(TILE)) where CANVAS is an array of single characters, but that would require another large array. Trying instead to do the conversion only a line at a time in the WRITE statement as SPLOT(ISPRIME(TILE(1:ORDER,L))) failed, only one symbol per line appeared. So instead, an older-style implicit DO-loop, and the results are...

<pre>

This is actually better handled graphically.

 

#define SIZE 639

 

 

sleep

 

=={{header|Fōrmulæ}}==

 

 

 

 

=={{header|Go}}==

{{trans|Kotlin}}

 

import (

generate(9, 1, 0) // with digits

generate(9, 1, '*') // with *

 

=={{header|Haskell}}==

As a program the given task then formulates as following:

 

import Data.Numbers.Primes

 

 

Here we refference the function <code>swirl n</code>, which for a given (possibly infinite) list returns <code>n</code> whorls of a spiral.

The spiral is formed in a way we would fold a paper band: first we chop the band into pieces of increasing length, then we take necessary amount of pieces, finally we fold all pieces into the spiral, starting with the empty table by rotating it and adding pieces of data one by one:

 

 

chop n lst = let (x,(y,z)) = splitAt n <$> splitAt n lst

 

spool = foldl (\table piece -> piece : rotate table) [[]]

 

That's it!

Pretty printing the table of strings with given column width is simple:

 

 

{{Out}}

 

Simple graphical output could be done using <code>Diagrams</code> framework:

import Diagrams.Backend.SVG.CmdLine

 

dots x = (circle 1 # if isPrime x then fc black else fc white) :: Diagram B

 

 

=={{header|J}}==

Let's start with our implementation of [[Spiral_matrix#J|spiral]]:

 

 

We can get a spiral starting with 1 in the center of the square by subtracting these values from the square of our size argument:

 

0 1 2 3 4

15 16 17 18 5

11 2 1 6 19

12 3 4 5 18

 

Next, we want to determine which of these numbers are prime:

 

0 0 1 0 0

0 0 0 1 0

1 1 0 0 1

0 1 0 1 0

 

And, finally, we want to use these values to select from a pair of characters:

 

o

o

oo o

o o

 

If we want our spiral to start with some value other than 1, we'd add that value - 1 to our numbers right before the prime check. For this, we want a function which returns 0 when there's no left argument and one less than the left argument when it that value present. We can use : for this -- it takes two verbs, the left of which is used when no left argument is present and the right one is used when a left argument is present. (And note that in J, : is a token forming character, so we will need to leave a space to the left of : so that it does not form a different token):

 

0

3 (0: :(<:@[)) ''

 

We also want to specify that our initial computations only respect the right argument, and we should maybe add a space after every character to get more of a square aspect ratio in typical text displays:

 

 

And here it is in action:

 

o o

o o o

o o o o

o

 

To transform these spirals to the orientation which has recently been added as a part of the task, you could flip them horizontally (|."1) and vertically (|.)

=={{header|Java}}==

{{works with|Java|1.5+}}

 

public class Ulam{

}

}

{{out}}

<pre>[ --- --- --- --- 61 --- 59 --- ---]

[[File:ulam_large_java.gif|300px|thumb|right]]

{{works with|Java|8}}

import javax.swing.*;

 

});

}

 

=== Small scale Ulam Spiral ===

[[File:ulam_spiral_java.gif|300px|thumb|right]]

{{works with|Java|8}}

import javax.swing.*;

 

});

}

 

=={{header|JavaScript}}==

{{trans|PARI/GP}}

{{Works with|Chrome}} (or any other browser supporting Canvas tag)

<!-- UlamSpiral.html -->

<html>

</body>

</html>

{{Output}}

 

matrix 'signature': Matrix(101x101) 1208 dots

</pre>

 

=={{header|Julia}}==

{{works with|Julia|0.6}}

 

 

function ulamspiral(ord::Int)

 

M = ulamspiral(9)

 

{{out}}

=={{header|Kotlin}}==

{{trans|Java}}

fun generate(n: Int, i: Int = 1, c: Char = '*') {

require(n > 1)

Ulam.generate(9, c = '0')

Ulam.generate(9)

 

=={{header|Lua}}==

print("n = " .. n)

local function isprime(p)

 

-- filling a 132 column terminal (with a 2-wide glyph to better preserve aspect ratio)

{{out}}

<pre>n = 66.0

██ ██ ██ ██ ██

</pre>

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

iCCWSpiralEast[n_Integer]:=Table[(1/2 (-1)^# ({1,-1} (Abs[#^2-t]-#)+#^2-t-Mod[#,2])&)[Round[Sqrt[t]]],{t,0,n-1}]

n=20

pts=Pick[pts,PrimeQ[start+Range[n^2]-1],True];

grid=Table[({i,j}/.(Alternatives@@pts)->"#")/.{_,_}->" ",{j,Round[n/2],-Round[n/2],-1},{i,-Round[n/2],Round[n/2],1}];

{{out}}

<pre> * * *

* * *

* * * * </pre>

 

=={{header|Nim}}==

 

===Displaying in terminal===

 

const N = 51 # Grid width and height.

grid.fill()

for row in grid:

 

{{out}}

Writing in a file, it is possible to create much bigger images.

 

 

const

image.fill(BG)

image.apply(grid)

 

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

{{Works with|PARI/GP|2.7.4 and above}}

 

\\ Ulam spiral (plotting/printing)

\\ 4/19/16 aev

plotulamspir(200); \\ ULAMspiral2.png

}

 

{{Output}}

 

In the first part of the source are some support routines, from way back in the 1980s, written when the mainframe terminals only offered capitals and the habit lingered. They are there only so as to facilitate some gestures towards checking. The remainder is simple enough, and uses complex numbers to follow the spiral, which of course have to be implemented via ad-hoc code as they're not supported by the compiler. The scheme could be recast into the (line,column) form, counting downwards for the screen line, but array(i,j) = (x,y) means less standing upside down when devising the arithmetic for the directions, at the cost of a "downto" loop for output. An even more tricky scheme would be to ascertain N from (line,column) as the lines were written rather than compute the whole spiral first. Such a function exists.

Program Ulam; Uses crt;

{Concocted by R.N.McLean (whom God preserve), ex Victoria university, NZ.}

Until (wot <= 0) or (wot > Mstyle); {Alas, "Enter" must be pressed.}

END.

=== using FreePascal ===

PROGRAM Ulam.pas;

 

Free Pascal Compiler version 3.2.0 [2020/06/14] for x86_64

The free and readable alternative at C/C++ speeds

(*)

 

 

END.

Output:

61 59

, ,

, ,

 

=== using FreePascal (short version) ===

PROGRAM Ulam8.pas;

 

For debian Linux: apt -y install fpc

It contains a text IDE called fp

 

(*)

CONST

 

n = SIZE * ord ( Odd ( SIZE ) ) ;

 

 

END.

Output:

61 59

=={{header|Perl}}==

{{trans|python}}{{libheader|ntheory}}

use Imager;

 

}

 

{{out}}

Creates an image file <tt>ulam.png</tt> in current directory similar to the one on MathWorld. The square dimension can be optionally specified.

 

=={{header|Phix}}==

{{out}}

<pre>

o o

</pre>

 

=={{header|PicoLisp}}==

 

(de ceil (A)

(ulam 9) )

 

{{out}}

<pre>

 

=={{header|PowerShell}}==

function New-UlamSpiral ( [int]$N )

{

 

New-UlamSpiral 100

{{out}}

<pre>

 

=={{header|Python}}==

from __future__ import print_function, division

from math import sqrt

show_spiral(9, symbol='', space=' - ')

# for filling giant terminals

{{out}}

<pre>

- 43 - - - 47 - - -

73 - - - - - 79 - -

</pre>

 

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

 

## Plotting Ulam spiral (for primes) 2/12/17 aev

## plotulamspirR(n, clr, fn, ttl, psz=600), where: n - initial size;

plotulamspirR(100, "red", "UlamSpiralR1", "Ulam Spiral: ");

plotulamspirR(200, "red", "UlamSpiralR2", "Ulam Spiral: ",1240);

 

{{Output}}

{{trans|Python}}

 

(require (only-in math/number-theory prime?))

(show-spiral 50 #:symbol "*" #:start 42)

; for filling giant terminals

 

{{out}}

=={{header|Raku}}==

(formerly Perl 6)

(my %world){0}{0} = 0;

 

while ++$side < $max {

}

 

}

 

}

 

sub braille-graphics (%a) {

}

 

my $cell = 0x2800;

}

print "\n";

}

{{out}}

<pre>⠔⠀⠀⠀⢐⠀⠁⠀⠀⠀⢐⠁⠀⢀⠀⠄⠄⠀⢀⠀⠀⠅⢀⠁⢅⢄⠀⢀⠔⠁⠀⠀⠀⢀⢀⠀⠀⠀⠁⢀⢀⠀⠀⢔⠁⢔⠄⠀⢄⠐⠀⠀⢀⠁⠐⠄⠀⢑⠄⠁⠄⠀⠁⠄⠀⠀⠀⢐⠀⠄⠐⠀⢁⢀⠀⠀⠄⠀⢕⠐

===counter-clockwise===

parse arg size init char . /*obtain optional arguments from the CL*/

if size=='' | size=="," then size= 79 /*Not specified? Then use the default.*/

do j=17 by 6 until j*j > x; if x//j ==0 then return 0

if x//(j+2) ==0 then return 0

{{out|output|text=&nbsp; when using the default input:}}

 

===clockwise===

This REXX version is presented here to show the difference between a clockwise and a counter-clockwise Ulam (prime) spiral.

parse arg size init char . /*obtain optional arguments from the CL*/

if size=='' | size=="," then size= 79 /*Not specified? Then use the default.*/

do j=17 by 6 until j*j > x; if x//j ==0 then return 0

if x//(j+2) ==0 then return 0

{{out|output|text=&nbsp; when using the default input:}}

 

 

=={{header|Ring}}==

# Project : Ulam spiral (for primes)

next

}

Outputimage:

 

It finds the number from the position ( the coordinates ).

{{trans|Python}}

 

def cell(n, x, y, start=1)

show_spiral(9)

show_spiral(25)

 

{{out}}

===Another Version===

computes the next spiral position.

 

def spiral_generator(x=0, y=0)

puts "\nN : #{n}"

ulam_spiral(n)

 

{{out}}

{{trans|Kotlin}}

{{works with|Rust|1.11.0}}

 

enum Direction { RIGHT, UP, LEFT, DOWN }

writeln!(f, "")

}

main.rs :

use ulam::*;

 

print!("{}", Ulam::new(9, 1, '\0'));

print!("{}", Ulam::new(9, 1, '*'));

{{out}}

<pre>[ --- --- --- --- 61 --- 59 --- ---]

=={{header|Scala}}==

{{trans|Kotlin}}

generate(9)()

generate(9)('*')

true

}

 

=={{header|Sidef}}==

{{trans|Perl}}

 

var (n=512, start=1, file='ulam.png')

}

 

Output image: [https://github.com/trizen/rc/blob/master/img/ulam-spiral-sidef.png Ulam spiral]

 

This uses a coroutine to walk around the circle, laying glyphs every prime number of tiles. Some more elaborate, interactive Tk GUIs for playing with Ulam spirals are at [http://wiki.tcl.tk/11363 Ulam Spiral] and [http://wiki.tcl.tk/23052 Ulam Spiral Demo] on the Tcl'ers Wiki.

 

if {$n == 1} {return 0}

if {$n in {2 3 5}} {return 1}

}

 

 

The mark used is Unicode's OGHAM FEATHER MARK .. the closest I could find to a Tcl logo.

 

=={{header|VBScript}}==

Function build_spiral(n)

'declare a two dimentional array

'test with 9

build_spiral(9)

 

{{Out}}

{{libheader|Wren-str}}

{{libheader|Wren-fmt}}

 

var Direction = Enum.create("Direction", ["right", "up", "left", "down"])

 

Ulam.generate(9, 1, "0") // with digits

 

{{out}}

* --- --- --- --- --- * --- ---

</pre>

 

=={{header|Yabasic}}==

{{trans|Phix}}

local p

next

print

 

=={{header|zkl}}==

 

Using [[Extensible prime generator#zkl]] and the PPM class from http://rosettacode.org/wiki/Bitmap/Bresenham%27s_line_algorithm#zkl.

var offsets=Utils.cycle( T(0,1),T(-1,0),T(0,-1),T(1,0) ); // (N,E,S,W), lazy

const BLACK=0, WHITE=0xff|ff|ff, GREEN=0x00|ff|00, EMPTY=0x080|80|80;

}

 

{{out}}

A PPM image similar to that shown in Raku but denser. A green dot marks the center.

 

http://www.zenkinetic.com/Images/RosettaCode/ulamSpiral.png