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.

*   [http://mathforum.org/library/drmath/view/53027.html Finding the Center of a Circle from 2 Points and Radius] from Math forum @ Drexel

<br><br>

 

=={{header|ALGOL 68}}==

Calculations based on the C solution.

MODE POINT = STRUCT( REAL x, REAL y );

# returns TRUE if p1 is the same point as p2, FALSE otherwise #

print circles( 0.1234, 0.9876, 0.1234, 0.9876, 2.0 );

print circles( 0.1234, 0.9876, 0.8765, 0.2345, 0.5 );

{{out}}

<pre>

One circle : radius: 0.0000 @( 0.1234, 0.9876)

</pre>

 

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

 

return 0;

}

{{out|test run}}

<pre>

No circles can be drawn through (0.1234,0.9876)

</pre>

{{works with|C sharp|6}}

public class CirclesOfGivenRadiusThroughTwoPoints

{

}

{{out}}

<pre>

Points (0.1234, 0.9876) and (0.1234, 0.9876) with radius 0:

(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

 

let add (a:double, b:double) (x:double, y:double) = (a + x, b + y)

printfn "%A" (circlePoints (0.1234, 0.9876) (0.1234, 0.1234) 0.0)

 

{{out}}

<pre>Some ((-0.8632118017, -0.7521118017), (1.863111802, 1.974211802))

<null>

<null></pre>

=={{header|Factor}}==

formatting io kernel literals locals math math.distances

math.functions prettyprint sequences strings ;

] each ;

 

{{out}}

<pre>

one degenerate circle found at (0.1234, 0.9876).

</pre>

=={{header|Fortran}}==

! Implemented by Anant Dixit (Nov. 2014)

! Transpose elements in find_center to obtain correct results. R.N. McLean (Dec 2017)

Center(2,1) = MP(1) + dd*(P2(2) - P1(2))/dm

Center(2,2) = MP(2) - dd*(P2(1) - P1(1))/dm

 

{{out}}

===Using complex numbers===

Fortran 66 made standard the availability of complex number arithmetic. This version however takes advantage of facilities offered in F90 so as to perform some array-based arithmetic, though the opportunities in this small routine are thin: two statements become one (look for CMPLX). More seriously, the MODULE facility allows the definition of an array SQUAWK which contains an explanatory text associated with each return code. The routine has a troublesome variety of possible odd conditions to report. An older approach would be to have a return message CHARACTER variable to present the remark, at the cost of filling up that variable with text every time. By returning an integer code, less effort is required, but there is no explication of the return codes. One could still have an array of messages (and prior to F90, array index counting started at one only, so no starting with -3 for errorish codes) but making that array available would require some sort of COMMON storage. The MODULE facility eases this problem.

CHARACTER*(*) SQUAWK(-3:2) !Holds a schedule of complaints.

PARAMETER (SQUAWK = (/ !According to what might go wrong.

 

20 CLOSE(IN) !Finihed with input.

 

Results: little attempt has been made to present a fancy layout, "free-format" output does well enough. Notably, complex numbers are presented in brackets with a comma as ''(x,y)''; a FORMAT statement version would have to supply those decorations. Free-format input also expects such bracketing when reading complex numbers. The supplied data format however does ''not'' include the brackets and so is improper. Suitable data would be

One 'circle', centred on the co-incident points. R is zero!

</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|Java}}==

{{trans|Kotlin}}

 

public class Circles {

}

}

{{out}}

<pre>For points (0.1234, 0.9876) and (0.8765, 0.2345) with radius 2.000000

For points (0.1234, 0.9876) and (0.1234, 0.9876) with radius 0.000000

there is just one circle with center at (0.1234, 0.9876)</pre>

=={{header|JavaScript}}==

 

====ES6====

 

const pAng = (p1, p2) => Math.atan(p1.map((e, i) => e - p2[i]).reduce((p, c) => c / p, 1));

const solveF = (p, r) => t => [r*Math.cos(t) + p[0], r*Math.sin(t) + p[1]];

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

].forEach((t,i) => console.log(`Test: ${i}: ${findC(...t)}`));

 

Output:

Test: 0: p1: 0.1234,0.9876, p2: 0.8765,0.2345, r:2 Result: Circle at 1.8631118016581891,1.974211801658189 Circle at -0.863211801658189,-0.7521118016581889

Test: 1: p1: 0,2, p2: 0,0, r:1 Result: Points on diameter. Circle at: 0,1

Test: 3: p1: 0.1234,0.9876, p2: 0.8765,0.2345, r:0.5 Result: No intersection. Points further apart than circle diameter

Test: 4: p1: 0.1234,0.9876, p2: 0.1234,0.9876, r:0 Result: Radius Zero

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

 

typealias IAE = IllegalArgumentException

println()

}

 

{{out}}

there is just one circle with center at (0.1234, 0.9876)

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

=={{header|Lua}}==

{{trans|C}}

local dx = (p1.x-p2.x)

local dy = (p1.y-p2.y)

print("Case "..i)

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

{{out}}

<pre>Case 1

Case 5

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

=={{header|Maple}}==

local c1, c2, p1, p2;

use geometry in

drawCircles(0.1234, 0.9876, 0.1234, 0.9876, 2.0);

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

{{out}}

[[File:Circles1_Maple.png]]

The circle is a point at [.1234, .9876].

</pre>

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|Modula-2}}==

FROM EXCEPTIONS IMPORT AllocateSource,ExceptionSource,GetMessage,RAISE;

FROM FormatString IMPORT FormatString;

 

ReadChar

=={{header|Nim}}==

{{trans|Python}}

 

type

except ValueError:

echo " ERROR: ", getCurrentExceptionMsg()

{{out}}

<pre>Through points:

You can construct the following circles:

ERROR: radius of zero</pre>

 

=={{header|Oforth}}==

 

| d xmid ymid r1 md |

x2 x1 - sq y2 y1 - sq + sqrt -> d

System.Out "C1 : (" << xmid y1 y2 - md * d / + << ", " << ymid x2 x1 - md * d / + << ")" << cr

System.Out "C2 : (" << xmid y1 y2 - md * d / - << ", " << ymid x2 x1 - md * d / - << ")" << cr

 

{{out}}

 

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

%4 = [0.370374144 + 0.740625856*I, 0.629525856 + 0.481474144*I]

%5 = "impossible"</pre>

 

=={{header|Perl}}==

{{trans|Python}}

 

sub circles {

);

 

{{out}}

<pre>(0.1234, 0.9876) and (0.8765, 0.2345) with radius 2.0: (1.8631, 1.9742) and (-0.8632, -0.7521)

(0.1234, 0.9876) and (0.8765, 0.2345) with radius 0.5: Separation of points greater than diameter

(0.1234, 0.9876) and (0.1234, 0.9876) with radius 0.0: Radius is zero</pre>

=={{header|Phix}}==

{{out}}

<pre>

points {0.1234,0.9876}, {0.1234,0.9876} with radius 0.0 ==> same points/radius is zero

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

<br>The REXX language doesn't have a &nbsp; '''sqrt''' &nbsp; function, &nbsp; so one is included below.

@.=; @.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|Ring}}==

# Project : Circles of given radius through two points

 

see "(" + (cx+dy) + ", " + (cy+dx) + ")" + nl

see "(" + (cx-dy) + ", " + (cy-dx) + ")" + nl + nl

Output:

<pre>

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

</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|Scheme}}==

 

(import (scheme base)

(scheme inexact)

'((0.8765 0.2345) (0.0000 0.0000) (0.1234 0.9876) (0.8765 0.2345) (0.1234 0.9876))

'(2.0 1.0 2.0 0.5 0.0))

 

{{out}}

p1: (0.1234 0.9876) p2: (0.1234 0.9876) r: 0.0 => ((0.1234 0.9876))

</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|Sidef}}==

 

if (a == b) {

input.each {|a|

say (a.join(', '), ': ', circles(a...).join(' and '))

{{out}}

<pre>

0.1234+0.9876i, 0.1234+0.9876i, 0: Degenerate point

</pre>

=={{header|Stata}}==

Each circle center is the image of B by the composition of a rotation and homothecy centered at A. It's how the centers are computed in this implementation. The coordinates are returned as the columns of a 2x2 matrix. When the solution is not unique or does not exist, this matrix contains only missing values.

 

real matrix rot

real scalar d, u, v

return(J(2, 2, .))

}

 

Examples:

 

:b=0.8765\0.2345

: centers(a,b,2)

1 | .1234 .1234 |

2 | .9876 .9876 |

=={{header|Swift}}==

 

{{trans|F#}}

 

 

struct Point: Equatable {

var radius: Double

 

_ p1: Point,

_ p2: Point,

}

 

 

{{out}}

No ans

No ans</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|VBA}}==

tests = [{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; 0.1234, 0.9876, 0.1234, 0.9876, 0.0}]

For i = 1 To UBound(tests)

Debug.Print "points " & "{" & x1 & ", " & y1 & "}" & ", " & "{" & x2 & ", " & y2 & "}" & " with radius " & R & " ==> " & txt

Next i

<pre>points {0,1234, 0,9876}, {0,8765, 0,2345} with radius 2 ==> {1,8631, 1,9742} and {-0,8632, -0,7521}

points {0, 2}, {0, 0} with radius 1 ==> opposite ends of diameter with centre 0, 1.

=={{header|Visual Basic .NET}}==

{{trans|C#}}

Public Shared Sub Main()

For Each valu In New Double()() {

End Function

End Structure

{{out}}

<pre>Points (0.1234, 0.9876) and (0.8765, 0.2345) with radius 2:

Points (0.1234, 0.9876) and (0.2345, 0.8765) with radius 0:

No circles.</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>

 

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>

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

{{trans|Liberty BASIC}}

20 READ x1,y1,x2,y2,r

30 PRINT i;") ";x1;" ";y1;" ";x2;" ";y2;" ";r

1190 PRINT "(";cx+dy;",";cy+dx;")"

1200 PRINT "(";cx-dy;",";cy-dx;")"