Circles of given radius through two points: Difference between revisions

{{task}}

 

Given two points on a plane and a radius, usually two circles of given radius can be drawn through the points.

# If the points form a diameter then return two identical circles ''or'' return a single circle, according to which is the most natural mechanism for the implementation language.

# If the points are too far apart then no circles can be drawn.

 

;Task detail:

* Write a function/subroutine/method/... that takes two points and a radius and returns the two circles through those points, ''or some indication of special cases where two, possibly equal, circles cannot be returned''.

* Show here the output for the following inputs:

0.1234, 0.9876 0.8765, 0.2345 2.0

0.0000, 2.0000 0.0000, 0.0000 1.0

0.1234, 0.9876 0.1234, 0.9876 2.0

0.1234, 0.9876 0.8765, 0.2345 0.5

 

 

=={{header|AutoHotkey}}==

d := sqrt((x2-x1)**2 + (y2-y1)**2)

x3 := (x1+x2)/2 , y3 := (y1+y2)/2

return "no solution"

return cx1 "," cy1 " & " cx2 "," cy2

(

0.1234 0.9876 0.8765 0.2345 2.0

obj := StrSplit(A_LoopField, " ")

MsgBox, % CircleCenter(obj[1], obj[2], obj[3], obj[4], obj[5])

{{out}}

<pre>0.1234 0.9876 0.8765 0.2345 2.0 > 1.863112,1.974212 & -0.863212,-0.752112

</pre>

 

=={{header|BASIC}}==

 

 

 

=={{header|C}}==

#include<math.h>

 

int main()

{

 

{0.0000, 2.0000}, {0.0000, 0.0000},

{0.1234, 0.9876}, {0.1234, 0.9876},

{0.1234, 0.9876}, {0.8765, 0.2345},

{0.1234, 0.9876}, {0.1234, 0.9876}

 

 

printf("\nCase %d)",i+1);

findCircles(cases[2*i],cases[2*i+1],radii[i]);

 

}

{{out|test run}}

<pre>

No circles can be drawn through (0.1234,0.9876)

</pre>

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

{{works with|C++11}}

#include <iostream>

#include <cmath>

if(half_distance > r) return std::make_tuple(NONE, ans1, ans2);

if(half_distance - r == 0) return std::make_tuple(ONE_DIAMETER, center, ans2);

ans1.x = center.x + root * (p1.y - p2.y);

ans1.y = center.y + root * (p2.x - p1.x);

for(int i = 0; i < size; ++i)

print(find_circles(points[i*2], points[i*2 + 1], radius[i]));

{{out}}

<pre>

Only one solution: 0 1

Infinitely many circles can be drawn

=={{header|D}}==

{{trans|Python}}

 

class ValueException : Exception {

writefln(" ERROR: %s\n", v.msg);

}

{{out}}

<pre>Through points:

ERROR: radius of zero

</pre>

 

=={{header|Elixir}}==

{{trans|Ruby}}

def circle(p, p, r) when r>0.0 do

raise ArgumentError, message: "Infinite number of circles, points coincide."

end

IO.puts ""

 

{{out}}

 

=={{header|ERRE}}==

PROGRAM CIRCLES

 

END FOR

END PROGRAM

 

=={{header|Fortran}}==

! Implemented by Anant Dixit (Nov. 2014)

program circles

implicit none

subroutine find_center(P1,P2,R,Center)

implicit none

 

 

{{out}}

Radius : 2.0000

Two distinct circles found.

 

 

</pre>

 

=={{header|Go}}==

 

import (

fmt.Println()

}

{{out}}

<pre>

Center: {0.1234 0.9876}

</pre>

 

=={{header|Haskell}}==

sub (a, b) (x, y) = (a - x, b - y)

magSqr (a, b) = (a ^^ 2) + (b ^^ 2)

((0.1234, 0.9876), (0.1234, 0.9876), 2),

((0.1234, 0.9876), (0.8765, 0.2345), 0.5),

{{out}}

<pre>Just ((-0.8632118016581896,-0.7521118016581892),(1.8631118016581893,1.974211801658189))

{{trans|AutoHotKey}}

Works in both languages.

A := [ [0.1234, 0.9876, 0.8765, 0.2345, 2.0],

[0.0000, 2.0000, 0.0000, 0.0000, 1.0],

if d = r2 then return "Single circle at ("||cx1||","||cy1||")"

return "("||cx1||","||cy1||") and ("||cx2||","||cy2||")"

 

{{out}}

->

</pre>

=={{header|J}}==

 

2D computations are often easier using the complex plane.

 

circles =: verb define"1

│0.1234 0.9876 0.1234 0.9876 0 │Degenerate point at 0.1234 0.9876 │

└───────────────────────────────┴────────────────────────────────────────────────────┘

 

=={{header|jq}}==

{{works with|jq|1.4}}

In this section, a point in the plane will be represented by its Cartesian co-ordinates expressed as a JSON array: [x,y].

# Input should be an array [x1, y1, x2, y2, r] giving the co-ordinates

# of the two points and a radius.

elif ($cx1 and $cy1 and $cx2 and $cy2) | not then "no solution"

else [$cx1, $cy1, $cx2, $cy2 ]

'''Examples''':

[0.1234, 0.9876, 0.8765, 0.2345, 2],

[0.0000, 2.0000, 0.0000, 0.0000, 1],

[0.1234, 0.9876, 0.1234, 0.9876, 0]

)

{{out}}

 

[0.1234,0.9876,0.8765,0.2345,2] ───► [1.8631118016581893,1.974211801658189,-0.8632118016581896,-0.7521118016581892]

[0.1234,0.9876,0.1234,0.9876,2] ───► infinitely many circles can be drawn

[0.1234,0.9876,0.8765,0.2345,0.5] ───► points are too far from each other

=={{header|Julia}}==

This solution uses the package [https://github.com/timholy/AffineTransforms.jl AffineTransforms.jl] to introduce a coordinate system (u, v) centered on the midpoint between the two points and rotated so that these points are on the u-axis. In this system, solving for the circles' centers is trivial. The two points are cast as complex numbers to aid in determining the location of the midpoint and rotation angle.

 

'''Types and Functions'''

immutable Point{T<:FloatingPoint}

x::T

return (cp, "Two Solutions")

end

 

'''Main'''

tp = [Point(0.1234, 0.9876),

Point(0.0000, 2.0000),

end

end

 

{{out}}

(0.1234, 0.9876), 0.0000

</pre>

 

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

'[RC] Circles of given radius through two points

for i = 1 to 5

 

end sub

 

Output:

1) 0.1234 0.9876 0.8765 0.2345 2

(1.8631118,1.9742118)

5) 0.1234 0.9876 0.1234 0.9876 0

It will be a single point (0.1234,0.9876) of radius 0

 

circs::invrad = "The radius is invalid.";

circs::equpts = "The given points (`1`, `2`) are equivalent.";

Values /@

Solve[Abs[x - p1x]^2 + Abs[y - p1y]^2 ==

{{out}}

circs::equpts: The given points (0.1234`, 0.9876`) are equivalent.

circs::invrad: The radius is invalid.</pre>

=={{header|Maxima}}==

vabs(a):= sqrt(a.a);

realp(e):=freeof(%i, e);

apply('getsol, cons(sol, d[2]));

apply('getsol, cons(sol, d[3]));

{{out}}

two solutions

(%o9) [[x0 = 1.86311180165819, y0 = 1.974211801658189],

(%i12) apply('getsol, cons(sol, d[4]));

infinity many solutions

=={{header|МК-61/52}}==

ИП2 ИП0 - x^2 ИП3 ИП1 - x^2 + КвКор П5

ИП0 ИП2 + 2 / П6 ИП1 ИП3 + 2 / П7

ИП4 2 * ИП5 - ПE x#0 97 ИПB ИПA 8 5 ИНВ С/П

ИПE x>=0 97 8 3 ИНВ С/П

 

{{in}}

"8.L" if the points are coincident; "8.-" if the points are opposite ends of a diameter of the circle, РY and РZ are coordinates of the center; "8.Г" if the points are farther away from each other than a diameter of a circle; else РX, РY and РZ, РT are coordinates of the circles centers.

</pre>

 

=={{header|Nim}}==

{{trans|Python}}

 

type

 

proc circles(p1, p2: Point, r: float): tuple[c1, c2: Circle] =

"radius of zero")

"coincident points gives infinite number of Circles")

 

# dist between points

let q = sqrt(dx*dx + dy*dy)

"separation of points > diameter")

 

echo " ", c1

echo " ", c2

echo " ERROR: ", getCurrentExceptionMsg()

{{out}}

<pre>Through points:

You can construct the following circles:

ERROR: radius of zero</pre>

 

=={{header|ooRexx}}==

{{trans|REXX}}

a.=''

a.1=0.1234 0.9876 0.8765 0.2345 2

f: Return format(arg(1),2,4) /* format a number with 4 dec dig.*/

 

{{out}}

<pre> x1 y1 x2 y2 radius cir1x cir1y cir2x cir2y

0.1234 0.9876 0.8765 0.2345 0.5 points are too far apart for the given radius

0.1234 0.9876 0.1234 0.9876 0.0 radius of zero gives no circles.</pre>

 

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

if(a==b, return("impossible"));

my(h=(b-a)/2,t=sqrt(r^2-abs(h)^2)/abs(h)*h);

circ(0.1234 + 0.9876*I, 0.1234 + 0.9876*I, 2)

circ(0.1234 + 0.9876*I, 0.8765 + 0.2345*I, .5)

{{out}}

<pre>%1 = [1.86311180 + 1.97421180*I, -0.863211802 - 0.752111802*I]

%5 = "impossible"</pre>

 

 

 

 

 

 

}

 

 

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

{{trans|REXX}}

Dcl 1 *(5),

2 m1x Dec Float Init(0.1234, 0,0.1234,0.1234,0.1234),

Return(res);

End;

{{out}}

<pre> x1 y1 x2 y2 r cir1x cir1y cir2x cir2y

0.1234 0.9876 0.1234 0.9876 0 radius of zero gives no circles.

</pre>

 

=={{header|Python}}==

The function raises the ValueError exception for the special cases

and uses try - except to catch these and extract the exception detail.

 

from math import sqrt

 

print(' %r\n %r\n' % circles_from_p1p2r(p1, p2, r))

except ValueError as v:

 

{{out}}

You can construct the following circles:

ERROR: radius of zero</pre>

=={{header|Racket}}==

Using library `plot/utils` for simple vector operations.

 

#lang racket

(require plot/utils)

;; returns a vector which is orthogonal to the geven one

(define orth (match-lambda [(vector x y) (vector y (- x))]))

 

{{out|Testing}}

Drawing circles:

 

(require 2htdp/image)

 

((compose (point p1) (point p2) (circ x1 r) (circ x2 r))

(empty-scene 100 100))

 

=={{header|REXX}}==

{{trans|XPL0}}

@.=; @.1= 0.1234 0.9876 0.8765 0.2345 2

@.2= 0 2 0 0 1

say ' ════════ ════════ ════════ ════════ ══════ ════════ ════════ ════════ ════════'

do j=1 while @.j\==''; parse var @.j p1 p2 p3 p4 r /*points, radii*/

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

if r = 0 then return 'radius of zero yields no circles.'

if pb==0 then return 'coincident points give infinite circles.'

if pb >r then return 'points are too far apart for the specified radius.'

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

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

sqrt: procedure; arg x; if x=0 then return 0; d=digits(); numeric digits; h=d+6; m.=9

numeric form; parse value format(x,2,1,,0) 'E0' with g "E" _ .; g=g *.5'e'_ % 2

<pre>

x1 y1 x2 y2 radius circle1x circle1y circle2x circle2y

0.1234 0.9876 0.1234 0.9876 0 ───► radius of zero gives no circles.

</pre>

 

=={{header|Ruby}}==

{{trans|Python}}

Circle = Struct.new(:x, :y, :r)

 

end

puts

{{out}}

<pre>

#<struct Circle x=0.1234, y=0.9876, r=0.0>

</pre>

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

html "<TABLE border=1>"

html "<tr bgcolor=wheat align=center><td>No.</td><td>x1</td><td>y1</td><td>x2</td><td>y2</td><td>r</td><td>cir x1</td><td>cir y1</td><td>cir x2</td><td>cir y2</td></tr>"

html "<td>";cx+dy;"</td><td>";cy+dx;"</td>" 'two points, with (+)

html "<td>";cx-dy;"</td><td>";cy-dx;"</td></TR>" 'and (-)

{{Out}}<TABLE BORDER="1">

<TR ALIGN="CENTER" BGCOLOR="wheat"><TD>No.</TD><TD>x1</TD><TD>y1</TD><TD>x2

<TD ALIGN="LEFT" COLSPAN="4">It will be a single point (0.1234,0.9876) of radius 0</TD></TR>

</TABLE>

=={{header|Rust}}==

{{trans|C}}

 

#[derive(Clone,Copy)]

describe_circle(p.0, p.1, r);

}

{{out}}

<pre>Points: ((0.1234, 0.9876), (0.8765, 0.2345)), Radius: 2.0000

Points: ((0.1234, 0.9876), (0.1234, 0.9876)), Radius: 0.0000

No circles can be drawn through (0.1234, 0.9876)</pre>

=={{header|Scala}}==

import math._

 

Circle(V2(mid.x + d * diff.y / diff.distance, mid.y - d * diff.x / diff.distance), abs(radius))).distinct

}

{{out}}

<pre> p1 p2 r result

(0.1234, 0.9876) (0.8765, 0.2345) 0.5: radius is less then the distance between points

(0.1234, 0.9876) (0.1234, 0.9876) 0.0: radius of zero yields no circlesEmpty test suite.</pre>

 

=={{header|Seed7}}==

include "float.s7i";

include "math.s7i";

point(cases[index][3], cases[index][4]), cases[index][5]);

end for;

 

{{out}}

Radius of zero. No circles can be drawn through (0.1234, 0.9876)

</pre>

 

=={{header|Tcl}}==

{{trans|Python}}

lassign $p1 x1 y1

lassign $p2 x2 y2

set c2 [list [expr {$x3 + $f*$dy}] [expr {$y3 - $f*$dx}] $r]

return [list $c1 $c2]

 

{{out|Demo}}

{0.1234 0.9876} {0.8765 0.2345} 2.0

{0.0000 2.0000} {0.0000 0.0000} 1.0

puts "\tERROR: $msg"

}

{{out}}

<pre>

Circle:(0.1234, 0.9876, 0.0)

</pre>

 

=={{header|Visual FoxPro}}==

Translation of BASIC.

LOCAL p1 As point, p2 As point, rr As Double

CLOSE DATABASES ALL

 

ENDDEFINE

{{out}}

<pre>

Points (0.1234,0.9876), (0.1234,0.9876) Radius 0.0000.

Points are coincident.

<pre>

 

=={{header|XPL0}}==

The method used here is a streamlining of these steps.

 

 

proc Circles; real Data; \Show centers of circles, given points P & Q and radius

[0.1234, 0.9876, 0.1234, 0.9876, 0.0]];

for I:= 0 to 4 do Circles(Tbl(I));

 

{{out}}

Radius = zero gives no circles

</pre>

 

=={{header|zkl}}==

{{trans|C}}

delta:=(a-c).hypot(b-d);

switch(delta){ // could just catch MathError

else print(cs);

println();

{{out}}

<pre>

Circles: singularity

</pre>