Constrained random points on a circle: Difference between revisions

=={{header|11l}}==

{{trans|Julia}}

V canvas = [[0B] * (2*hi+1)] * (2*hi+1)

V i = 0

print(canvas[i].map(j -> I j {‘♦ ’} E ‘ ’).join(‘’))

 

=={{header|Ada}}==

 

with Ada.Numerics.Discrete_Random;

procedure Circle is

Ada.Text_IO.Put_Line ("Chosen from precalculated:");

Print_Points (My_Circle_Precalculated);

 

Output:

{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-1.18.0/algol68g-1.18.0-9h.tiny.el5.centos.fc11.i386.rpm/download 1.18.0-9h.tiny]}}

{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d] - due to use of '''format'''[ted] ''transput''}}

printf(($g"[2J"$,REPR 27)); # ansi.sys #

 

gotoxy(2*radius+1, 2*radius+1);

newline(stand in)

Sample output:

<pre>

=={{header|AutoHotkey}}==

Requires the GDI+ standard library by tic: http://www.autohotkey.com/forum/viewtopic.php?t=32238<br /> Works with individual pixels.

 

pToken := Gdip_Startup()

 

Gdip_DisposeImage(pBitmap)

 

=={{header|BASIC}}==

 

==={{header|BBC BASIC}}===

ORIGIN 640, 512

FOR i% = 1 TO 1000

r = SQR(x%^2 + y%^2)

IF r >= 10 IF r <= 15 PLOT x%*2, y%*2

 

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

Pre calculate and plot 100 points to the console

 

#define Intrange(f,l) int(Rnd*(((l)+1)-(f))+(f))

print "done"

Sleep

Console output:

<pre>

 

</pre>

 

=={{header|C}}==

#include <stdlib.h>

 

 

return 0;

. . .

. . . .

. . . .

.

 

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

 

using System.Diagnostics;

using System.Drawing;

for (int count = 0; count < 100; count++)

{

g.FillEllipse(brush, new Rectangle(290 + 19 * p.X, 290 + 19 * p.Y, 10, 10));

}

}

}

 

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

[[File:constrained_rnd_pts_on_circle.png]]

#include <windows.h>

#include <list>

}

//--------------------------------------------------------------------------------------------------

 

=={{header|Clojure}}==

(:import [java.awt Color Graphics Dimension]

[javax.swing JFrame JPanel]))

(.setDefaultCloseOperation JFrame/DISPOSE_ON_CLOSE)

.pack

 

=={{header|COBOL}}==

identification division.

program-id. circle.

 

end program circle.

<pre>

 

 

=={{header|CoffeeScript}}==

NUM_POINTS = 100

MIN_R = 10

plot random_circle_points()

 

The output may be a bit distorted, since even monospace fonts take more vertical space per character than horizontal space.

> coffee foo.coffee

* * * * *

* * *

 

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

(loop with x with y with cnt = 0

with scr = (loop repeat 31 collect (loop repeat 31 collect " "))

(setf (elt (elt scr y) x) "@ ")

(incf cnt))

 

=={{header|D}}==

This uses std.complex because D built-in complex numbers will be deprecated.

 

void main() {

 

writefln("%-(%s\n%)", table);

{{out}}

<pre>

* * * *

** </pre>

 

=={{header|EchoLisp}}==

Using the '''plot''' library. For a greater visual appeal, points are plotted as circles of random radius and color. The resulting image is at [http://www.echolalie.org/echolisp/images/circle.png].

(lib 'math)

(lib 'plot)

(plot-circle x y (random radius)))

(plot-edit))

 

=={{header|Elixir}}==

===Algorithm 1: Generate random pairs===

{{works with|Elixir|1.1}}

defp generate_point(0, _, _, set), do: set

defp generate_point(n, f, condition, set) do

end

 

 

'''Example output:'''

{{trans|Ruby}}

{{works with|Elixir|1.2}}

def circle do

range = -15..15

end

 

 

{{out|Example}}

{{works with|Euphoria|4.0.3, 4.0.0 or later}}

This program generates the set of 404 possible points in the ring. It randomly chooses 100 pairs from the set. The 100 pairs are a subset of that set because duplicates are discarded.

 

sequence validpoints = {}

printf(1, "\nNumber of discarded coordinate pairs : %d", length(discardedpoints) )

printf(1, "\nNumber of randomly picked coordinate pairs : %d\n", length(rand100points) )

Output:

<pre>

Number of discarded coordinate pairs : 557

Number of randomly picked coordinate pairs : 100

for i = 1 to length(validpoints) do --simple each pixel output to screen surface

dummy=pixelColor(surface,validpoints[i][1]+18,validpoints[i][2]+18,#AA0202FF) --i is index number of each subsequence 'chunk'.

dummy=stringColor(surface,0,83,sprintf("Number of discarded coordinate pairs : %d", length(discardedpoints) ),#0202AAFF)

 

[[File:Fuzzy_circle_Euphoria.png]] That particular program used a -16 to +16 square area, so more was discarded.

 

This version uses method 1 from the task description and just calculates 100 suitable points to plot.

The INTERACTIVE bit just permits this code in a .fsx file to be run with the interactive interpreter or compiled to an exe.

let main args =

let rnd = new System.Random()

[<EntryPoint>]

let main args = CirclePoints.main args

An example of the output:

<pre>

=={{header|Factor}}==

{{works with|Factor|0.99 2020-01-23}}

math.statistics math.vectors random sequences strings ;

 

[ sum-of-squares 100 225 between? ] filter 100 sample

[ 15 v+n ] map 31 31 32 <matrix> [ matrix-set-nths ] keep

{{out}}

<pre>

 

=={{header|Falcon}}==

// Generate points in [min,max]^2 with constraint

function random_point (min, max, constraint)

>

end

Example output:

<pre>

x x

x x x x

</pre>

 

=={{header|Fortran}}==

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

implicit none

end do

Output

<pre>

* * ** *

*</pre>

 

=={{header|gnuplot}}==

[[File:RingRandPntsGnu.png|right|thumb|Output RingRandPntsGnu.png]]

 

## Ring of random points 2/18/17 aev

reset

set output

unset print

{{Output}}

<pre>

=={{header|Go}}==

'''Algorithm 1:'''

 

import (

}

fmt.Println(u, "unique points")

'''Algorithm 2:'''

 

import (

}

fmt.Println(u, "unique points")

{{out}}

<pre>

=={{header|Haskell}}==

Using [[Knuth shuffle#Haskell|Knuth Shuffle]]

import Control.Monad

import Control.Arrow

let canvas = foldl (\cs [x,y] -> replaceAt (31*(x+15)+y+15) "/ " cs ) blanco (take 100 pts)

-- show canvas

Output (added a trailing space per 'pixel'

<pre>*Main> task

 

=={{header|Hy}}==

; We can't use random.sample because that samples without replacement.

(plt.plot xs ys "bo")

 

=={{header|Icon}} and {{header|Unicon}}==

Generate random points in the bounded by the outside edge. Reject any found out of the prescribed bounds and stop when the required numbers of points have been generated. [[File:Fuzzycircle-unicon.PNG|thumb|plot of 2000, 100, 120]]

 

procedure main(A) # points, inside r, outside r in pixels - default to task values

WDone()

 

 

=={{header|J}}==

This version deals 100 distinct coordinates from the set of acceptable coordinates (much like dealing cards from a shuffled deck):

 

 

Example use (<code><nowiki>gen''</nowiki></code> generates the points, the rest of the example code deals with rendering them as a text array):

*

**

* * *

 

=={{header|Java}}==

 

public class FuzzyCircle {

}

}

Output:

<pre>

=={{header|JavaScript}}==

JavaScript embedded in HTML, using canvas:

<body>

<canvas id="cv" width="320" height="320"></canvas>

}

 

 

=={{header|Julia}}==

{{works with|Julia|0.6}}

This solution uses the "pick random x, y and cull" rather than the "calculate valid and choose randomly" approach.

canvas = falses(2hi + 1, 2hi + 1)

i = 0

end

 

 

{{out}}

 

=={{header|Kotlin}}==

 

fun main(args: Array<String>) {

}

for (i in 0..30) println(points[i].joinToString(""))

 

Sample output:

o o

</pre>

 

=={{header|Liberty BASIC}}==

 

nomainwin

[quit]

close #w

 

=={{header|Locomotive Basic}}==

 

20 FOR J=1 TO 100

30 X=INT(RND*30-15)

70 PLOT 320+10*X,200+10*Y:LOCATE 1,1:PRINT J

80 NEXT

 

[[File:Points on a circle locomotive basic.png]]

 

=={{header|Maple}}==

i := 1:

while i < 100 do

end if:

end do:

 

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

This algorithm generates 500 pairs of random integers between +/- 15, picks out the ones that satisfy the inequality, and then takes the first 100 of those. It oversamples to reduce the chance of having less than 100 "candidates", which is not impossible, though extremely unlikely.

 

 

=={{header|MATLAB}}==

Uses the Monte-Carlo method described above.

 

 

xCoordinates = [];

yCoordinates(numPoints+1:end) = [];

 

Output:

[[File:Matlab-randomDisc-output.png]]

 

=={{header|Maxima}}==

local(goodp, random_int),

goodp(x, y):=block([r: sqrt(x^2+y^2)],

p: randomDisc(100)$

 

=={{header|Nim}}==

{{trans|Python}}

 

type Point = tuple[x, y: int]

for x in -15..15:

for y in -15..15:

possiblePoints.add((x,y))

 

randomize()

 

for x in -15..15:

let key = (x, y)

if key in world and world[key] > 0:

else:

 

=={{header|OCaml}}==

 

let d = sqrt(x ** 2.0 +. y ** 2.0) in

10.0 <= d && d <= 15.0

g.(y).[x] <- 'o'

) points;

 

 

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

my(v=vector(404),t=0,i=0,vx=vy=vector(100));

for(x=1,14,for(y=1,14,

);

plothraw(vx,vy)

 

=={{header|Perl}}==

===Graphical output===

while (@points < 100) {

my ($x, $y) = (int(rand(31))-15, int(rand(31)) - 15);

 

print "@$_ pt\n" for @points;

 

Randomly generates points and reject ones not in the ring. Writes an EPS file.

 

===Plain-text output===

 

for $x (@range) {

push @matrix, ' ' x @range for 1..@range;

substr $matrix[15+$$_[1]], 15+$$_[0], 1, '*' for @sample;

{{out}}

<pre> * * *

 

=={{header|Phix}}==

{{out}}

<pre>

 

=={{header|PicoLisp}}==

(use (X Y)

(do 100

10 ) )

(set (nth Area (+ 16 X) (+ 16 Y)) "#") ) )

Output:

<pre> #

=={{header|PL/I}}==

===version 1===

constrain: procedure options (main);

declare 1 point (100),

end;

end constrain;

Output:

<pre>

</pre>

===version 2===

annulus: procedure options (main);

/* version 1 does not handle (0/15) etc. this does. */

Return(d);

End;

'''output'''

<pre> *

=={{header|PowerShell}}==

{{works with|PowerShell|3}}

$MaxR2 = 15 * 15

}

{{out}}

<pre> ***

=={{header|Prolog}}==

Works with SWI-Prolog

 

circle :-

send(D, display, C))),

send(D, open).

[[FILE:Prolog-Circle.jpg‎ ]]

 

=={{header|PureBasic}}==

StartDrawing(ImageOutput(0))

For i=1 To 100

OpenWindow(0,#PB_Ignore,#PB_Ignore,ImageWidth(0),ImageHeight(0),Title$,Flags)

ImageGadget(0,0,0,ImageWidth(0),ImageHeight(0),ImageID(0))

[[File:PureBasic_Circle_plot.png‎|155px]]

 

=={{header|Python}}==

Note that the diagram shows the number of points at any given position (up to a maximum of 9 points).

>>> from random import choice

>>> world = defaultdict(int)

1 1 1

2 2 1

If the number of samples is increased to 1100:

 

>>> for x in range(-15,16):

2131181233 424

47414232164

 

=={{header|R}}==

RMin <- 10

RMax <- 15

plot(X[Valid][1:NPts],Y[Valid][1:NPts], pch=19, cex=0.25, col="blue",

xlab="x",ylab="y",main="Fuzzy circle", xlim=c(-RMax,RMax), ylim=c(-RMax,RMax) )

 

Example of solution

 

=={{header|Racket}}==

 

(require plot plot/utils)

#(15 15)))]

#:when (<= 10 (vmag xy) 15))

 

=={{header|Raku}}==

(formerly Perl 6)

{{works with|rakudo|2015.09}}

 

my @points = gather for @range X @range -> ($x, $y) {

for @range X @range -> ($x, $y) { %matrix{$y}{$x} = ' ' }

%matrix{.[1]}{.[0]} = '*' for @samples;

{{out}}

<pre> *

This uses, among other things, a 0-based matrix rather than a hash, a <tt>given</tt> on the first line that allows us to print the final value of the matrix straight from its initial declaration, a <tt>for</tt> statement feeding a <tt>for</tt> statement modifier, a lambda that unpacks a single x-y argument into two variables, the functional form of pick rather than the method form, a quasi-list comprehension in the middle loop that filters each <tt>given</tt> with a <tt>when</tt>, precalculated squared limits so we don't have to take the square root, use of X- and X** to subtract and exponentiate both <tt>$x</tt> and <tt>$y</tt> in parallel.

 

 

At this point you would be justified in concluding that we are completely mad. <tt>:-)</tt>

 

-> [$x, $y] { @matrix[$x][$y] = '*' } for pick 100, do

for ^32 X ^32 -> ($x, $y) {

[$x,$y] when 100..225 given [+] ($x,$y X- 15) X** 2;

}

{{out}}

<pre> * * *

===version 1===

This REXX version uses aspect adjustment for the plot of the (sparse) annulus.

parse arg pts LO HI . /*obtain optional args from the C.L. */

if pts=='' then pts= 100 /*Not specified? Then use the default.*/

end /*pts*/ /* [↑] maintain aspect ratio on X axis*/

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

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

<pre>

===version 2===

{{trans|REXX version 1}}

* show 100 random points of an annulus with radius 10 to 15

* 18.06.2014 Walter Pachl 'derived/simplified' from REXX version 1

Do y=-high To high

Say line.y

'''output''' using default parameters

<pre>

 

===version 3===

* 19.06.2014 Walter Pachl alternate algorithm

* the idea: yl is a list of y coordinates which may have unused points

p.0=z

End

'''output''' using rexx fcaa 100 3 5 2

<pre>all points filled

 

=={{header|Ring}}==

load "guilib.ring"

 

}

label1 { setpicture(p1) show() }

 

Output:

 

[[File:CalmoSoftDrawCircle.jpg]]

 

=={{header|Ruby}}==

Create the image with [[Raster graphics operations/Ruby]]

# choose a random radius and angle

angle = rand * 2.0 * Math::PI

pngfile = __FILE__

pngfile[/\.rb/] = ".png"

 

{{out}}

 

===algorithm 2:===

range = (-15..15).to_a

points = range.product(range).select {|i,j| r2.cover?(i*i + j*j)}

pt = Hash.new(" ")

points.sample(100).each{|ij| pt[ij] = " o"}

 

{{out}}

 

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

h = 320

dim canvas(w,h)

next x

render #g

 

=={{header|Rust}}==

 

use rand::Rng;

 

precalculating_method(&mut rng);

 

=={{header|Scala}}==

import scala.math.hypot

import scala.swing.{MainFrame,Panel,SimpleSwingApplication}

contents = ui

}

 

=={{header|Sidef}}==

{{trans|Perl}}

Generates an EPS file.

while (points.len < 100) {

if ((r2 >= 100) && (r2 <= 225)) {

}

}

 

%!PS-Adobe-3.0 EPSF-3.0

%%BoundingBox 0 0 400 400

HEAD

 

 

=={{header|Swift}}==

{{trans|Rust}}

 

 

func generatePoint() -> (Int, Int) {

 

print("Precalculating method:")

 

{{out}}

 

=={{header|SystemVerilog}}==

 

bit [39:0] bitmap [40];

end

 

 

Piping the output through sed to improve the contrast of the output:

 

</pre>

 

=={{header|Tcl}}==

 

# Generate random point at specified distance from the centre

}

puts ""

Example output:

<pre>

1

</pre>

 

=={{header|XPL0}}==

[[File:DonutXPL0.gif|right]]

int X, Y, C, R2;

[SetVid($13); \set 320x200x8 graphics mode

C:= ChIn(1); \wait for keystroke

SetVid(3); \restore normal text mode

 

=={{header|zkl}}==

x:=(-15).random(16); y:=(-15).random(16);

if(not (100<=(x*x + y*y)<=225)) Void.Skip else T(x,y)

 

xy.walk(100).apply2(fcn([(x,y)],array){array[x+15 + N*(y+15)]="*"},array);

{{out}}

<pre>

=={{header|ZX Spectrum Basic}}==

{{trans|BBC_BASIC}}

20 LET x=RND*31-16

30 LET y=RND*31-16

40 LET r=SQR (x*x+y*y)

50 IF (r>=10) AND (r<=15) THEN PLOT 127+x*2,88+y*2