Circles of given radius through two points: Difference between revisions
Circles of given radius through two points (view source)
Revision as of 10:43, 7 April 2024
, 2 months ago→{{header|11l}}: make Error a non-fatal exception
Thundergnat (talk | contribs) (Rename Perl 6 -> Raku, alphabetize, minor clean-up) |
Alextretyak (talk | contribs) (→{{header|11l}}: make Error a non-fatal exception) |
||
(33 intermediate revisions by 21 users not shown) | |||
Line 1:
[[Category:Geometry]]
{{task}}
[[File:2 circles through 2 points.jpg|
Given two points on a plane and a radius, usually two circles of given radius can be drawn through the points.
Line 30 ⟶ 31:
* [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|11l}}==
{{trans|Python}}
<syntaxhighlight lang="11l">T Circle
Float x, y, r
F String()
R ‘Circle(x=#.6, y=#.6, r=#.6)’.format(.x, .y, .r)
F (x, y, r)
.x = x
.y = y
.r = r
T Error
String msg
F (msg)
.msg = msg
F circles_from_p1p2r(p1, p2, r) X(Error)
‘Following explanation at http://mathforum.org/library/drmath/view/53027.html’
I r == 0.0
X Error(‘radius of zero’)
V (x1, y1) = p1
V (x2, y2) = p2
I p1 == p2
X Error(‘coincident points gives infinite number of Circles’)
V (dx, dy) = (x2 - x1, y2 - y1)
V q = sqrt(dx ^ 2 + dy ^ 2)
I q > 2.0 * r
X Error(‘separation of points > diameter’)
V (x3, y3) = ((x1 + x2) / 2, (y1 + y2) / 2)
V d = sqrt(r ^ 2 - (q / 2) ^ 2)
V c1 = Circle(x' x3 - d * dy / q,
y' y3 + d * dx / q,
r' abs(r))
V c2 = Circle(x' x3 + d * dy / q,
y' y3 - d * dx / q,
r' abs(r))
R (c1, c2)
L(p1, p2, r) [((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)]
print("Through points:\n #.,\n #.\n and radius #.6\nYou can construct the following circles:".format(p1, p2, r))
X.try
V (c1, c2) = circles_from_p1p2r(p1, p2, r)
print(" #.\n #.\n".format(c1, c2))
X.handle Error v
print(" ERROR: #.\n".format(v.msg))</syntaxhighlight>
{{out}}
<pre>
Through points:
(0.1234, 0.9876),
(0.8765, 0.2345)
and radius 2.000000
You can construct the following circles:
Circle(x=1.863112, y=1.974212, r=2.000000)
Circle(x=-0.863212, y=-0.752112, r=2.000000)
Through points:
(0, 2),
(0, 0)
and radius 1.000000
You can construct the following circles:
Circle(x=0.000000, y=1.000000, r=1.000000)
Circle(x=0.000000, y=1.000000, r=1.000000)
Through points:
(0.1234, 0.9876),
(0.1234, 0.9876)
and radius 2.000000
You can construct the following circles:
ERROR: coincident points gives infinite number of Circles
Through points:
(0.1234, 0.9876),
(0.8765, 0.2345)
and radius 0.500000
You can construct the following circles:
ERROR: separation of points > diameter
Through points:
(0.1234, 0.9876),
(0.1234, 0.9876)
and radius 0.000000
You can construct the following circles:
ERROR: radius of zero
</pre>
=={{header|Action!}}==
{{libheader|Action! Tool Kit}}
{{libheader|Action! Real Math}}
<syntaxhighlight lang="action!">INCLUDE "H6:REALMATH.ACT"
PROC Circles(CHAR ARRAY sx1,sy1,sx2,sy2,sr)
REAL x1,y1,x2,y2,r,x,y,bx,by,pb,cb,xx,yy
REAL two,tmp1,tmp2,tmp3
ValR(sx1,x1) ValR(sy1,y1)
ValR(sx2,x2) ValR(sy2,y2)
ValR(sr,r) IntToReal(2,two)
Print("p1=(") PrintR(x1) Put(32)
PrintR(y1) Print(") p2=(")
PrintR(x2) Put(32) PrintR(y2)
Print(") r=") PrintR(r) Print(" -> ")
IF RealEqual(r,rzero) THEN
PrintE("Radius is zero, no circles") PutE()
RETURN
FI
RealSub(x2,x1,tmp1) ;tmp1=x2-x1
RealDiv(tmp1,two,x) ;x=(x2-x1)/2
RealSub(y2,y1,tmp1) ;tmp1=y2-y1
RealDiv(tmp1,two,y) ;y=(y2-y1)/2
RealAdd(x1,x,bx) ;bx=x1+x
RealAdd(y1,y,by) ;bx=x1+x
RealMult(x,x,tmp1) ;tmp1=x^2
RealMult(y,y,tmp2) ;tmp2=y^2
RealAdd(tmp1,tmp2,tmp3) ;tmp3=x^2+y^2
Sqrt(tmp3,pb) ;pb=sqrt(x^2+y^2)
IF RealEqual(pb,rzero) THEN
PrintE("Infinite circles")
ELSEIF RealGreater(pb,r) THEN
PrintE("Points are too far, no circles")
ELSE
RealMult(r,r,tmp1) ;tmp1=r^2
RealMult(pb,pb,tmp2) ;tmp2=pb^2
RealSub(tmp1,tmp2,tmp3) ;tmp3=r^2-pb^2
Sqrt(tmp3,cb) ;cb=sqrt(r^2-pb^2)
RealMult(y,cb,tmp1) ;tmp1=y*cb
RealDiv(tmp1,pb,xx) ;xx=y*cb/pb
RealMult(x,cb,tmp1) ;tmp1=x*cb
RealDiv(tmp1,pb,yy) ;yy=x*cb/pb
RealSub(bx,xx,tmp1) ;tmp1=bx-xx
Print("c1=(") PrintR(tmp1) Put(32)
RealAdd(by,yy,tmp1) ;tmp1=by+yy
PrintR(tmp1) Print(") c2=(")
RealAdd(bx,xx,tmp1) ;tmp1=bx+xx
PrintR(tmp1) Put(32)
RealSub(by,yy,tmp1) ;tmp1=by-yy
PrintR(tmp1) PrintE(")")
FI
PutE()
RETURN
PROC Main()
Put(125) PutE() ;clear the screen
MathInit()
Circles("0.1234","0.9876","0.8765","0.2345","2.0")
Circles("0.0000","2.0000","0.0000","0.0000","1.0")
Circles("0.1234","0.9876","0.1234","0.9876","2.0")
Circles("0.1234","0.9876","0.8765","0.2345","0.5")
Circles("0.1234","0.9876","0.1234","0.9876","0.0")
RETURN</syntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Circles_of_given_radius_through_two_points.png Screenshot from Atari 8-bit computer]
<pre>
p1=(.1234 .9876) p2=(.8765 .2345) r=2 -> c1=(1.86311176 1.97421176) c2=(-0.86321176 -0.75211176)
p1=(0 2) p2=(0 0) r=1 -> c1=(0 1) c2=(0 1)
p1=(.1234 .9876) p2=(.1234 .9876) r=2 -> Infinite circles
p1=(.1234 .9876) p2=(.8765 .2345) r=.5 -> c1=(1.19528365 1.30638365) c2=(-0.1953836533 -0.0842836533)
p1=(.1234 .9876) p2=(.1234 .9876) r=0 -> Radius is zero, no circles
</pre>
=={{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 #
Line 139 ⟶ 322:
print circles( 0.1234, 0.9876, 0.1234, 0.9876, 2.0 );
print circles( 0.1234, 0.9876, 0.8765, 0.2345, 0.5 );
print circles( 0.1234, 0.9876, 0.1234, 0.9876, 0.0 )</
{{out}}
<pre>
Line 148 ⟶ 331:
One circle : radius: 0.0000 @( 0.1234, 0.9876)
</pre>
=={{header|Arturo}}==
<syntaxhighlight lang="arturo">getPoint: function [p]-> ~{(x: |p\0|, y: |p\1|)}
getCircle: function [c]-> ~{(x: |c\0|, y: |c\1|, r: |c\2|)}
circles: function [p1, p2, r][
if r = 0 -> return "radius of zero"
if p1 = p2 -> return "coincident points gives infinite number of circles"
[dx, dy]: @[p2\0 - p1\0, p2\1 - p1\1]
q: sqrt add dx*dx dy*dy
if q > 2*r -> return "separation of points > diameter"
p3: @[(p1\0 + p2\0)/ 2, (p1\1 + p2\1) / 2]
d: sqrt (r*r) - (q/2)*(q/2)
return @[
@[(p3\0 - d*dy/q), (p3\1 + d*dx/q), abs r],
@[(p3\0 + d*dy/q), (p3\1 - d*dx/q), abs r]
]
]
loop [
[[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]
] 'tr [
[p1, p2, r]: tr
print ["Through points:\n " getPoint p1 "\n " getPoint p2]
print ["and radius" (to :string r)++"," "you can construct the following circles:"]
if? string? cic: <= circles p1 p2 r -> print [" ERROR:" cic]
else [
[c1, c2]: cic
print [" " getCircle c1]
print [" " getCircle c2]
]
print ""
]</syntaxhighlight>
{{out}}
<pre>Through points:
(x: 0.1234, y: 0.9876)
(x: 0.8764999999999999, y: 0.2345)
and radius 2.0, you can construct the following circles:
(x: 1.863111801658189, y: 1.974211801658189, r: 2.0)
(x: -0.8632118016581896, y: -0.7521118016581892, r: 2.0)
Through points:
(x: 0.0, y: 2.0)
(x: 0.0, y: 0.0)
and radius 1.0, you can construct the following circles:
(x: 0.0, y: 1.0, r: 1.0)
(x: 0.0, y: 1.0, r: 1.0)
Through points:
(x: 0.1234, y: 0.9876)
(x: 0.1234, y: 0.9876)
and radius 2.0, you can construct the following circles:
ERROR: coincident points gives infinite number of circles
Through points:
(x: 0.1234, y: 0.9876)
(x: 0.8764999999999999, y: 0.2345)
and radius 0.5, you can construct the following circles:
ERROR: separation of points > diameter
Through points:
(x: 0.1234, y: 0.9876)
(x: 0.1234, y: 0.9876)
and radius 0.0, you can construct the following circles:
ERROR: radius of zero</pre>
=={{header|AutoHotkey}}==
<
d := sqrt((x2-x1)**2 + (y2-y1)**2)
x3 := (x1+x2)/2 , y3 := (y1+y2)/2
Line 166 ⟶ 422:
return "no solution"
return cx1 "," cy1 " & " cx2 "," cy2
}</
Examples:<
(
0.1234 0.9876 0.8765 0.2345 2.0
Line 180 ⟶ 436:
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
Line 190 ⟶ 446:
=={{header|AWK}}==
<syntaxhighlight lang="awk">
# syntax: GAWK -f CIRCLES_OF_GIVEN_RADIUS_THROUGH_TWO_POINTS.AWK
# converted from PL/I
Line 220 ⟶ 476:
return(sprintf("%7.4f %7.4f %7.4f %7.4f",bx-x1,by+y1,bx+x1,by-y1))
}
</syntaxhighlight>
{{out}}
<pre>
Line 231 ⟶ 487:
0.1234 0.9876 0.1234 0.9876 0.00 radius of zero gives no circles
</pre>
=={{header|BASIC}}==
==={{header|BASIC256}}===
{{trans|Liberty BASIC}}
<syntaxhighlight lang="basic256">
function twoCircles(x1, y1, x2, y2, radio)
if x1 = x2 and y1 = y2 then #Si los puntos coinciden
if radio = 0 then #a no ser que radio=0
print "Los puntos son los mismos "
return ""
else
print "Hay cualquier número de círculos a través de un solo punto ("; x1; ", "; y1; ") de radio "; int(radio)
return ""
end if
end if
r2 = sqr((x1-x2)^2+(y1-y2)^2) / 2 #distancia media entre puntos
if radio < r2 then
print "Los puntos están demasiado separados ("; 2*r2; ") - no hay círculos de radio "; int(radio)
return ""
end if
#si no, calcular dos centros
cx = (x1+x2) / 2 #punto medio
cy = (y1+y2) / 2
#debe moverse desde el punto medio a lo largo de la perpendicular en dd2
dd2 = sqr(radio^2 - r2^2) #distancia perpendicular
dx1 = x2-cx #vector al punto medio
dy1 = y2-cy
dx = 0-dy1 / r2*dd2 #perpendicular:
dy = dx1 / r2*dd2 #rotar y escalar
print " -> Circulo 1 ("; cx+dy; ", "; cy+dx; ")" #dos puntos, con (+)
print " -> Circulo 2 ("; cx-dy; ", "; cy-dx; ")" #y (-)
return ""
end function
# p1 p2 radio
x1 = 0.1234 : y1 = 0.9876 : x2 = 0.8765 : y2 = 0.2345 : radio = 2.0
print "Puntos "; "("; x1; ","; y1; "), ("; x2; ","; y2; ")"; ", Radio "; int(radio)
print twoCircles (x1, y1, x2, y2, radio)
x1 = 0.0000 : y1 = 2.0000 : x2 = 0.0000 : y2 = 0.0000 : radio = 1.0
print "Puntos "; "("; x1; ","; y1; "), ("; x2; ","; y2; ")"; ", Radio "; int(radio)
print twoCircles (x1, y1, x2, y2, radio)
x1 = 0.1234 : y1 = 0.9876 : x2 = 0.12345 : y2 = 0.9876 : radio = 2.0
print "Puntos "; "("; x1; ","; y1; "), ("; x2; ","; y2; ")"; ", Radio "; int(radio)
print twoCircles (x1, y1, x2, y2, radio)
x1 = 0.1234 : y1 = 0.9876 : x2 = 0.8765 : y2 = 0.2345 : radio = 0.5
print "Puntos "; "("; x1; ","; y1; "), ("; x2; ","; y2; ")"; ", Radio "; int(radio)
print twoCircles (x1, y1, x2, y2, radio)
x1 = 0.1234 : y1 = 0.9876 : x2 = 1234 : y2 = 0.9876 : radio = 0.0
print "Puntos "; "("; x1; ","; y1; "), ("; x2; ","; y2; ")"; ", Radio "; int(radio)
print twoCircles (x1, y1, x2, y2, radio)
end
</syntaxhighlight>
=={{header|C}}==
<
#include<math.h>
Line 353 ⟶ 604:
return 0;
}
</syntaxhighlight>
{{out|test run}}
<pre>
Line 368 ⟶ 619:
No circles can be drawn through (0.1234,0.9876)
</pre>
=={{header|C sharp|C#}}==
{{works with|C sharp|6}}
<
public class CirclesOfGivenRadiusThroughTwoPoints
{
Line 442 ⟶ 692:
}
}</
{{out}}
<pre>
Line 455 ⟶ 705:
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>
Line 486 ⟶ 735:
if(half_distance > r) return std::make_tuple(NONE, ans1, ans2);
if(half_distance - r == 0) return std::make_tuple(ONE_DIAMETER, center, ans2);
double root =
ans1.x = center.x + root * (p1.y - p2.y);
ans1.y = center.y + root * (p2.x - p1.x);
Line 522 ⟶ 771:
for(int i = 0; i < size; ++i)
print(find_circles(points[i*2], points[i*2 + 1], radius[i]));
}</
{{out}}
<pre>
Two solutions: 1.
Only one solution: 0 1
Infinitely many circles can be drawn
Line 534 ⟶ 783:
=={{header|D}}==
{{trans|Python}}
<
class ValueException : Exception {
Line 595 ⟶ 844:
writefln(" ERROR: %s\n", v.msg);
}
}</
{{out}}
<pre>Through points:
Line 624 ⟶ 873:
ERROR: radius of zero
</pre>
=={{header|Delphi}}==
{{libheader| System.SysUtils}}
{{libheader| System.Types}}
{{libheader| System.Math}}
{{Trans|C}}
<syntaxhighlight lang="delphi">
program Circles_of_given_radius_through_two_points;
{$APPTYPE CONSOLE}
uses
System.SysUtils,
System.Types,
System.Math;
const
Cases: array[0..9] of TPointF = ((
x: 0.1234;
y: 0.9876
), (
x: 0.8765;
y: 0.2345
), (
x: 0.0000;
y: 2.0000
), (
x: 0.0000;
y: 0.0000
), (
x: 0.1234;
y: 0.9876
), (
x: 0.1234;
y: 0.9876
), (
x: 0.1234;
y: 0.9876
), (
x: 0.8765;
y: 0.2345
), (
x: 0.1234;
y: 0.9876
), (
x: 0.1234;
y: 0.9876
));
radii: array of double = [2.0, 1.0, 2.0, 0.5, 0.0];
procedure FindCircles(p1, p2: TPointF; radius: double);
var
separation, mirrorDistance: double;
begin
separation := p1.Distance(p2);
if separation = 0.0 then
begin
if radius = 0 then
write(format(#10'No circles can be drawn through (%.4f,%.4f)', [p1.x, p1.y]))
else
write(format(#10'Infinitely many circles can be drawn through (%.4f,%.4f)',
[p1.x, p1.y]));
exit;
end;
if separation = 2 * radius then
begin
write(format(#10'Given points are opposite ends of a diameter of the circle with center (%.4f,%.4f) and radius %.4f',
[(p1.x + p2.x) / 2, (p1.y + p2.y) / 2, radius]));
exit;
end;
if separation > 2 * radius then
begin
write(format(#10'Given points are farther away from each other than a diameter of a circle with radius %.4f',
[radius]));
exit;
end;
mirrorDistance := sqrt(Power(radius, 2) - Power(separation / 2, 2));
write(#10'Two circles are possible.');
write(format(#10'Circle C1 with center (%.4f,%.4f), radius %.4f and Circle C2 with center (%.4f,%.4f), radius %.4f',
[(p1.x + p2.x) / 2 + mirrorDistance * (p1.y - p2.y) / separation, (p1.y + p2.y)
/ 2 + mirrorDistance * (p2.x - p1.x) / separation, radius, (p1.x + p2.x) / 2
- mirrorDistance * (p1.y - p2.y) / separation, (p1.y + p2.y) / 2 -
mirrorDistance * (p2.x - p1.x) / separation, radius]));
end;
begin
for var i := 0 to 4 do
begin
write(#10'Case ', i + 1,')');
findCircles(cases[2 * i], cases[2 * i + 1], radii[i]);
end;
readln;
end.</syntaxhighlight>
=={{header|EasyLang}}==
{{trans|AWK}}
<syntaxhighlight>
func$ fmt a b .
return "(" & a & " " & b & ")"
.
proc test m1x m1y m2x m2y r . .
print "Points: " & fmt m1x m1y & " " & fmt m2x m2y & " Radius: " & r
if r = 0
print "Radius of zero gives no circles"
print ""
return
.
x = (m2x - m1x) / 2
y = (m2y - m1y) / 2
bx = m1x + x
by = m1y + y
pb = sqrt (x * x + y * y)
if pb = 0
print "Coincident points give infinite circles"
print ""
return
.
if pb > r
print "Points are too far apart for the given radius"
print ""
return
.
cb = sqrt (r * r - pb * pb)
x1 = y * cb / pb
y1 = x * cb / pb
print "Circles: " & fmt (bx - x1) (by + y1) & " " & fmt (bx + x1) (by - y1)
print ""
.
test 0.1234 0.9876 0.8765 0.2345 2.0
test 0.0000 2.0000 0.0000 0.0000 1.0
test 0.1234 0.9876 0.1234 0.9876 2.0
test 0.1234 0.9876 0.8765 0.2345 0.5
test 0.1234 0.9876 0.1234 0.9876 0.0
</syntaxhighlight>
=={{header|Elixir}}==
{{trans|Ruby}}
<
def circle(p, p, r) when r>0.0 do
raise ArgumentError, message: "Infinite number of circles, points coincide."
Line 664 ⟶ 1,049:
end
IO.puts ""
end)</
{{out}}
Line 704 ⟶ 1,089:
=={{header|ERRE}}==
<syntaxhighlight lang="text">
PROGRAM CIRCLES
Line 756 ⟶ 1,141:
END FOR
END PROGRAM
</syntaxhighlight>
=={{header|F Sharp|F#}}==
<syntaxhighlight lang="fsharp">open System
let add (a:double, b:double) (x:double, y:double) = (a + x, b + y)
Line 793 ⟶ 1,177:
printfn "%A" (circlePoints (0.1234, 0.9876) (0.1234, 0.1234) 0.0)
0 // return an integer exit code</
{{out}}
<pre>Some ((-0.8632118017, -0.7521118017), (1.863111802, 1.974211802))
Line 800 ⟶ 1,184:
<null>
<null></pre>
=={{header|Factor}}==
<
formatting io kernel literals locals math math.distances
math.functions prettyprint sequences strings ;
Line 896 ⟶ 1,279:
] each ;
MAIN: circles-demo</
{{out}}
<pre>
Line 914 ⟶ 1,297:
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)
Line 1,021 ⟶ 1,403:
Center(2,1) = MP(1) + dd*(P2(2) - P1(2))/dm
Center(2,2) = MP(2) - dd*(P2(1) - P1(1))/dm
end subroutine find_center</
{{out}}
Line 1,061 ⟶ 1,443:
===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.
Line 1,123 ⟶ 1,505:
20 CLOSE(IN) !Finihed with input.
END !Finished. </
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
Line 1,156 ⟶ 1,538:
One 'circle', centred on the co-incident points. R is zero!
</pre>
=={{header|FreeBASIC}}==
<syntaxhighlight lang="freebasic">Type Point
As Double x,y
Declare Property length As Double
End Type
Property point.length As Double
Return Sqr(x*x+y*y)
End Property
Sub circles(p1 As Point,p2 As Point,radius As Double)
Print "Points ";"("&p1.x;","&p1.y;"),("&p2.x;","&p2.y;")";", Rad ";radius
Var ctr=Type<Point>((p1.x+p2.x)/2,(p1.y+p2.y)/2)
Var half=Type<Point>(p1.x-ctr.x,p1.y-ctr.y)
Var lenhalf=half.length
If radius<lenhalf Then Print "Can't solve":Print:Exit Sub
If lenhalf=0 Then Print "Points are the same":Print:Exit Sub
Var dist=Sqr(radius^2-lenhalf^2)/lenhalf
Var rot= Type<Point>(-dist*(p1.y-ctr.y) +ctr.x,dist*(p1.x-ctr.x) +ctr.y)
Print " -> Circle 1 ("&rot.x;","&rot.y;")"
rot= Type<Point>(-(rot.x-ctr.x) +ctr.x,-((rot.y-ctr.y)) +ctr.y)
Print" -> Circle 2 ("&rot.x;","&rot.y;")"
Print
End Sub
Dim As Point p1=(.1234,.9876),p2=(.8765,.2345)
circles(p1,p2,2)
p1=Type<Point>(0,2):p2=Type<Point>(0,0)
circles(p1,p2,1)
p1=Type<Point>(.1234,.9876):p2=p1
circles(p1,p2,2)
p1=Type<Point>(.1234,.9876):p2=Type<Point>(.8765,.2345)
circles(p1,p2,.5)
p1=Type<Point>(.1234,.9876):p2=p1
circles(p1,p2,0)
Sleep</syntaxhighlight>
{{out}}
<pre>Points (0.1234,0.9876),(0.8765,0.2345), Rad 2
-> Circle 1 (-0.8632118016581893,-0.7521118016581889)
-> Circle 2 (1.863111801658189,1.974211801658189)
Points (0,2),(0,0), Rad 1
-> Circle 1 (0,1)
-> Circle 2 (0,1)
Points (0.1234,0.9876),(0.1234,0.9876), Rad 2
Points are the same
Points (0.1234,0.9876),(0.8765,0.2345), Rad 0.5
Can't solve
Points (0.1234,0.9876),(0.1234,0.9876), Rad 0
Points are the same</pre>
=={{header|Go}}==
<
import (
Line 1,231 ⟶ 1,667:
fmt.Println()
}
}</
{{out}}
<pre>
Line 1,263 ⟶ 1,699:
Center: {0.1234 0.9876}
</pre>
=={{header|Groovy}}==
{{trans|Java}}
<syntaxhighlight lang="groovy">class Circles {
private static class Point {
private final double x, y
Point(Double x, Double y) {
this.x = x
this.y = y
}
double distanceFrom(Point other) {
double dx = x - other.x
double dy = y - other.y
return Math.sqrt(dx * dx + dy * dy)
}
@Override
boolean equals(Object other) {
//if (this == other) return true
if (other == null || getClass() != other.getClass()) return false
Point point = (Point) other
return x == point.x && y == point.y
}
@Override
String toString() {
return String.format("(%.4f, %.4f)", x, y)
}
}
private static Point[] findCircles(Point p1, Point p2, double r) {
if (r < 0.0) throw new IllegalArgumentException("the radius can't be negative")
if (r == 0.0.toDouble() && p1 != p2) throw new IllegalArgumentException("no circles can ever be drawn")
if (r == 0.0.toDouble()) return [p1, p1]
if (Objects.equals(p1, p2)) throw new IllegalArgumentException("an infinite number of circles can be drawn")
double distance = p1.distanceFrom(p2)
double diameter = 2.0 * r
if (distance > diameter) throw new IllegalArgumentException("the points are too far apart to draw a circle")
Point center = new Point((p1.x + p2.x) / 2.0, (p1.y + p2.y) / 2.0)
if (distance == diameter) return [center, center]
double mirrorDistance = Math.sqrt(r * r - distance * distance / 4.0)
double dx = (p2.x - p1.x) * mirrorDistance / distance
double dy = (p2.y - p1.y) * mirrorDistance / distance
return [
new Point(center.x - dy, center.y + dx),
new Point(center.x + dy, center.y - dx)
]
}
static void main(String[] args) {
Point[] p = [
new Point(0.1234, 0.9876),
new Point(0.8765, 0.2345),
new Point(0.0000, 2.0000),
new Point(0.0000, 0.0000)
]
Point[][] points = [
[p[0], p[1]],
[p[2], p[3]],
[p[0], p[0]],
[p[0], p[1]],
[p[0], p[0]],
]
double[] radii = [2.0, 1.0, 2.0, 0.5, 0.0]
for (int i = 0; i < radii.length; ++i) {
Point p1 = points[i][0]
Point p2 = points[i][1]
double r = radii[i]
printf("For points %s and %s with radius %f\n", p1, p2, r)
try {
Point[] circles = findCircles(p1, p2, r)
Point c1 = circles[0]
Point c2 = circles[1]
if (Objects.equals(c1, c2)) {
printf("there is just one circle with center at %s\n", c1)
} else {
printf("there are two circles with centers at %s and %s\n", c1, c2)
}
} catch (IllegalArgumentException ex) {
println(ex.getMessage())
}
println()
}
}
}</syntaxhighlight>
{{out}}
<pre>For points (0.1234, 0.9876) and (0.8765, 0.2345) with radius 2.000000
there are two circles with centers at (1.8631, 1.9742) and (-0.8632, -0.7521)
For points (0.0000, 2.0000) and (0.0000, 0.0000) with radius 1.000000
there is just one circle with center at (0.0000, 1.0000)
For points (0.1234, 0.9876) and (0.1234, 0.9876) with radius 2.000000
an infinite number of circles can be drawn
For points (0.1234, 0.9876) and (0.8765, 0.2345) with radius 0.500000
the points are too far apart to draw a circle
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|Haskell}}==
<
sub (a, b) (x, y) = (a - x, b - y)
magSqr (a, b) = (a ^^ 2) + (b ^^ 2)
Line 1,300 ⟶ 1,836:
((0.1234, 0.9876), (0.1234, 0.9876), 2),
((0.1234, 0.9876), (0.8765, 0.2345), 0.5),
((0.1234, 0.9876), (0.1234, 0.1234), 0)]</
{{out}}
<pre>Just ((-0.8632118016581896,-0.7521118016581892),(1.8631118016581893,1.974211801658189))
Line 1,307 ⟶ 1,843:
Nothing
Nothing</pre>
=={{header|Icon}} and {{header|Unicon}}==
{{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],
Line 1,332 ⟶ 1,867:
if d = r2 then return "Single circle at ("||cx1||","||cy1||")"
return "("||cx1||","||cy1||") and ("||cx2||","||cy2||")"
end</
{{out}}
Line 1,344 ⟶ 1,879:
->
</pre>
=={{header|J}}==
2D computations are often easier using the complex plane.
<
circles =: verb define"1
Line 1,392 ⟶ 1,926:
│0.1234 0.9876 0.1234 0.9876 0 │Degenerate point at 0.1234 0.9876 │
└───────────────────────────────┴────────────────────────────────────────────────────┘
</syntaxhighlight>
=={{header|Java}}==
{{trans|Kotlin}}
<
public class Circles {
Line 1,481 ⟶ 2,014:
}
}
}</
{{out}}
<pre>For points (0.1234, 0.9876) and (0.8765, 0.2345) with radius 2.000000
Line 1,497 ⟶ 2,030:
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]];
Line 1,544 ⟶ 2,076:
[[0.1234, 0.9876], [0.1234, 0.9876], 0.0]
].forEach((t,i) => console.log(`Test: ${i}: ${findC(...t)}`));
</
Output:
<syntaxhighlight lang="javascript">
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
Line 1,553 ⟶ 2,085:
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
</syntaxhighlight>
=={{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.
Line 1,584 ⟶ 2,115:
elif ($cx1 and $cy1 and $cx2 and $cy2) | not then "no solution"
else [$cx1, $cy1, $cx2, $cy2 ]
end;</
'''Examples''':
<
[0.1234, 0.9876, 0.8765, 0.2345, 2],
[0.0000, 2.0000, 0.0000, 0.0000, 1],
Line 1,593 ⟶ 2,124:
[0.1234, 0.9876, 0.1234, 0.9876, 0]
)
| "\(.) ───► \(circle_centers)"</
{{out}}
<
[0.1234,0.9876,0.8765,0.2345,2] ───► [1.8631118016581893,1.974211801658189,-0.8632118016581896,-0.7521118016581892]
Line 1,602 ⟶ 2,133:
[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
[0.1234,0.9876,0.1234,0.9876,0] ───► [0.1234,0.9876]</
=={{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'''
<syntaxhighlight lang="julia">
immutable Point{T<:FloatingPoint}
x::T
Line 1,650 ⟶ 2,180:
return (cp, "Two Solutions")
end
</syntaxhighlight>
'''Main'''
<syntaxhighlight lang="julia">
tp = [Point(0.1234, 0.9876),
Point(0.0000, 2.0000),
Line 1,681 ⟶ 2,211:
end
end
</syntaxhighlight>
{{out}}
Line 1,696 ⟶ 2,226:
(0.1234, 0.9876), 0.0000
</pre>
=={{header|Kotlin}}==
<
typealias IAE = IllegalArgumentException
Line 1,761 ⟶ 2,290:
println()
}
}</
{{out}}
Line 1,780 ⟶ 2,309:
there is just one circle with center at (0.1234, 0.9876)
</pre>
=={{header|Lambdatalk}}==
<syntaxhighlight lang="scheme">
input: OP1=(x1,y1), OP2=(x2,y2), r
output: OC = OH + HC
where OH = (OP1+OP2)/2
and HC = j*|HC|
where j is the unit vector rotated -90° from P1P2
and |HC| = √(r^2 - (|P1P2|/2)^2) if exists
{def circleby2points
{lambda {:x1 :y1 :x2 :y2 :r}
{if {= :r 0}
then radius is zero
else {if {and {= :x1 :x2} {= :y1 :y2}}
then same points
else {let { {:r :r}
{:vx {- :x2 :x1}} {:vy {- :y2 :y1}} // v = P1P2
{:hx {/ {+ :x1 :x2} 2}} {:hy {/ {+ :y1 :y2} 2}} } // h = OH
{let { {:r :r} {:vx :vx} {:vy :vy} {:hx :hx} {:hy :hy} // closure
{:d {sqrt {+ {* :px :px} {* :py :py}}} } } // d = |P1P2|
{if {> :d {* 2 :r}} // d > diam
then no circle, points are too far apart
else {if {= :d {* 2 :r}} // d = diam
then one circle: opposite ends of diameter with centre (:hx,:hy)
else {let { {:r :r} {:hx :hx} {:hy :hy} // closure
{:jx {- {/ :vy :d}}} {:jy {/ :vx :d}} // j unit -90° to P1P2
{:d {sqrt {- {* :r :r} {/ {* :d :d} 4}}}} } // |HC|
two circles: {br}({+ :hx {* :d :jx}},{+ :hy {* :d :jy}}) // OH + j*|HC|
{br}({- :hx {* :d :jx}},{- :hy {* :d :jy}}) // OH - j*|HC|
}}}}}}}}}
{circleby2points -1 0 1 0 0.5}
-> no circle:
points are too far apart
{circleby2points -1 0 1 0 1}
-> one circle:
opposite ends of diameter with centre (0,0)
{circleby2points -1 0 1 0 {sqrt 2}}
-> two circles:
(0,1.0000000000000002)
(0,-1.0000000000000002)
rosetta's task:
{circleby2points 0.1234 0.9876 0.8765 0.2345 2.0}
-> two circles:
(1.8631118016581893,1.974211801658189)
(-0.8632118016581896,-0.7521118016581892)
{circleby2points 0.0000 2.0000 0.0000 0.0000 1.0}
-> one circle: opposite ends of diameter with centre (0,1)
{circleby2points 0.1234 0.9876 0.1234 0.9876 2.0}
-> same points
{circleby2points 0.1234 0.9876 0.8765 0.2345 0.5}
-> no circle, points are too far apart
{circleby2points 0.1234 0.9876 0.1234 0.9876 0.0}
-> radius is zero
</syntaxhighlight>
=={{header|Liberty BASIC}}==
<syntaxhighlight lang="lb">
'[RC] Circles of given radius through two points
for i = 1 to 5
Line 1,828 ⟶ 2,419:
end sub
</syntaxhighlight>
Output:
<
1) 0.1234 0.9876 0.8765 0.2345 2
(1.8631118,1.9742118)
Line 1,844 ⟶ 2,435:
5) 0.1234 0.9876 0.1234 0.9876 0
It will be a single point (0.1234,0.9876) of radius 0
</syntaxhighlight>
=={{header|Lua}}==
{{trans|C}}
<
local dx = (p1.x-p2.x)
local dy = (p1.y-p2.y)
Line 1,897 ⟶ 2,487:
print("Case "..i)
findCircles(cases[i*2-1], cases[i*2], radii[i])
end</
{{out}}
<pre>Case 1
Line 1,915 ⟶ 2,505:
Case 5
No circles can be drawn through (0.1234, 0.9876)</pre>
=={{header|Maple}}==
<
local c1, c2, p1, p2;
use geometry in
Line 1,944 ⟶ 2,533:
drawCircles(0.1234, 0.9876, 0.1234, 0.9876, 2.0);
drawCircles(0.1234, 0.9876, 0.8765, 0.2345, 0.5);
drawCircles(0.1234, 0.9876, 0.1234, 0.9876, 0.0);</
{{out}}
[[File:Circles1_Maple.png]]
Line 1,954 ⟶ 2,543:
The circle is a point at [.1234, .9876].
</pre>
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<syntaxhighlight lang="mathematica">Off[Solve::ratnz];
circs::invrad = "The radius is invalid.";
circs::equpts = "The given points (`1`, `2`) are equivalent.";
Line 1,971 ⟶ 2,559:
Values /@
Solve[Abs[x - p1x]^2 + Abs[y - p1y]^2 ==
Abs[x - p2x]^2 + Abs[y - p2y]^2 == r^2, {x, y}];</
{{out}}
<pre>
{{-0.863212, -0.752112}, {1.86311, 1.97421}}
circs::equpts: The given points (0.1234`, 0.9876`) are equivalent.
circs[{.1234, .9876}, {.8765, .2345}, .5]
circs[{.1234, .9876}, {.1234, .9876}, 0.]
circs::invrad: The radius is invalid.</pre>
=={{header|Maxima}}==
<
vabs(a):= sqrt(a.a);
realp(e):=freeof(%i, e);
Line 2,033 ⟶ 2,612:
apply('getsol, cons(sol, d[2]));
apply('getsol, cons(sol, d[3]));
apply('getsol, cons(sol, d[4]));</
{{out}}
<syntaxhighlight lang="text">apply('getsol, cons(sol, d[1]));
two solutions
(%o9) [[x0 = 1.86311180165819, y0 = 1.974211801658189],
Line 2,047 ⟶ 2,626:
(%i12) apply('getsol, cons(sol, d[4]));
infinity many solutions
(%o12) infmany</
=={{header|МК-61/52}}==
<syntaxhighlight lang="text">П0 С/П П1 С/П П2 С/П П3 С/П П4
ИП2 ИП0 - x^2 ИП3 ИП1 - x^2 + КвКор П5
ИП0 ИП2 + 2 / П6 ИП1 ИП3 + 2 / П7
Line 2,061 ⟶ 2,639:
ИП4 2 * ИП5 - ПE x#0 97 ИПB ИПA 8 5 ИНВ С/П
ИПE x>=0 97 8 3 ИНВ С/П
ИПD ИПC ИПB ИПA С/П</
{{in}}
Line 2,071 ⟶ 2,649:
"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;
Line 2,190 ⟶ 2,767:
ReadChar
END Circles.</
=={{header|Nim}}==
{{trans|Python}}
<
type
Line 2,241 ⟶ 2,817:
except ValueError:
echo " ERROR: ", getCurrentExceptionMsg()
echo ""</
{{out}}
<pre>Through points:
Line 2,279 ⟶ 2,855:
You can construct the following circles:
ERROR: radius of zero</pre>
=={{header|OCaml}}==
Original version by [http://rosettacode.org/wiki/User:Vanyamil User:Vanyamil]
<syntaxhighlight lang="ocaml">
(* Task : Circles of given radius through two points *)
(* Types to make code even more readable *)
type point = float * float
type radius = float
type circle = Circle of radius * point
type circ_output =
NoSolution
| OneSolution of circle
| TwoSolutions of circle * circle
| InfiniteSolutions
;;
(* Actual function *)
let circles_2points_radius (x1, y1 : point) (x2, y2 : point) (r : radius) =
let (dx, dy) = (x2 -. x1, y2 -. y1) in
let dist_sq = dx *. dx +. dy *. dy in
match dist_sq, r with
(* Edge case - point circles *)
| 0., 0. -> OneSolution (Circle (r, (x1, y1)))
(* Edge case - coinciding points *)
| 0., _ -> InfiniteSolutions
| _ ->
let side_len_sq = r *. r -. dist_sq /. 4. in
let midp = ((x1 +. x2) *. 0.5, (y1 +. y2) *. 0.5) in
(* Points are too far apart; same whether r = 0 or not *)
if side_len_sq < 0. then NoSolution
(* Points are on diameter *)
else if side_len_sq = 0. then OneSolution (Circle (r, midp))
else
(* A right-angle triangle is made with the radius as hyp, dist/2 as one side *)
let side_len = sqrt (r *. r -. dist_sq /. 4.) in
let dist = sqrt dist_sq in
(* A 90-deg rotation of a vector (x, y) is obtained by either (y, -x) or (-y, x)
We need both, so pick one and the other is its negative.
*)
let (vx, vy) = (-. dy *. side_len /. dist, dx *. side_len /. dist) in
let c1 = Circle (r, (fst midp +. vx, snd midp +. vy)) in
let c2 = Circle (r, (fst midp -. vx, snd midp -. vy)) in
TwoSolutions (c1, c2)
;;
(* Relevant tests and printing *)
let 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;
] ;;
let format_output (out : circ_output) = match out with
| NoSolution -> print_endline "No solution"
| OneSolution (Circle (_, (x, y))) -> Printf.printf "One solution: (%.6f, %.6f)\n" x y
| TwoSolutions (Circle (_, (x1, y1)), Circle (_, (x2, y2))) ->
Printf.printf "Two solutions: (%.6f, %.6f) and (%.6f, %.6f)\n" x1 y1 x2 y2
| InfiniteSolutions -> print_endline "Infinite solutions"
;;
let _ =
List.iter
(fun (a, b, c) -> circles_2points_radius a b c |> format_output)
tests
;;
</syntaxhighlight>
{{out}}
<pre>
Two solutions: (1.863112, 1.974212) and (-0.863212, -0.752112)
One solution: (0.000000, 1.000000)
Infinite solutions
No solution
One solution: (0.123400, 0.987600)
</pre>
=={{header|Oforth}}==
<
| d xmid ymid r1 md |
x2 x1 - sq y2 y1 - sq + sqrt -> d
Line 2,297 ⟶ 2,948:
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}}
Line 2,318 ⟶ 2,969:
</pre>
=={{header|ooRexx}}==
{{trans|REXX}}
<
a.=''
a.1=0.1234 0.9876 0.8765 0.2345 2
Line 2,359 ⟶ 3,009:
f: Return format(arg(1),2,4) /* format a number with 4 dec dig.*/
::requires 'rxMath' library</
{{out}}
<pre> x1 y1 x2 y2 radius cir1x cir1y cir2x cir2y
Line 2,368 ⟶ 3,018:
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|OpenSCAD}}==
<syntaxhighlight lang="OpenSCAD">
// distance between two points
function distance(p1, p2) = sqrt((difference(p2.x, p1.x)) ^ 2 + (difference(p2.y, p1.y) ^ 2));
// difference between two values in any order
function difference(a, b) = let(x = a > b ? a - b : b - a) x;
// function to find the circles of given radius through two points
function circles_of_given_radius_through_two_points(p1, p2, radius) =
let(mid = (p1 + p2)/2, q = distance(p1, p2), x_dist = sqrt(radius ^ 2 - (q / 2) ^ 2) * (p1.y - p2.y) / q,
y_dist = sqrt(radius ^ 2 - (q / 2) ^ 2) * (p2.x - p1.x) / q)
// point 1 and point 2 must not be the same point
assert(p1 != p2)
// radius must be more than 0
assert(radius > 0)
// distance between points cannot be more than diameter
assert(q < radius * 2)
// return both qualifying centres
[mid + [ x_dist, y_dist ], mid - [ x_dist, y_dist ]];
// test module for circles_of_given_radius_through_two_points
module test_circles_of_given_radius_through_two_points()
{
tests = [
[ [ -10, -10, 0 ], [ 50, 0, 0 ], 100 ], [ [ 200, 0, 0 ], [ 220, -20, 0 ], 30 ],
[ [ 300, 100, 0 ], [ 350, 200, 0 ], 80 ]
];
for (t = tests)
{
let(start = t[0], end = t[1], radius = t[2])
{
// plot start and end dots - these should be at the intersections of the circles
color("green") translate(start) cylinder(h = 3, r = 4);
color("green") translate(end) cylinder(h = 3, r = 4);
// call function
centres = circles_of_given_radius_through_two_points(start, end, radius);
echo("centres", centres);
// plot results
color("yellow") translate(centres[0]) cylinder(h = 1, r = radius);
color("red") translate(centres[1]) cylinder(h = 2, r = radius);
};
};
// The following tests will stop all execution. To run them, uncomment one at a time
// should fail - same points
// echo(circles_of_given_radius_through_two_points([0,0],[0,0],1));
// should fail - points are more than diameter apart
// echo(circles_of_given_radius_through_two_points(p1 = [0,0], p2 = [0,101], radius = 50));
// should fail - radius must be greater than 0
// echo(circles_of_given_radius_through_two_points(p1= [1,1], p2 = [10,1], radius = 0));
}
test_circles_of_given_radius_through_two_points();
</syntaxhighlight>
=={{header|PARI/GP}}==
<
if(a==b, return("impossible"));
my(h=(b-a)/2,t=sqrt(r^2-abs(h)^2)/abs(h)*h);
Line 2,379 ⟶ 3,084:
circ(0.1234 + 0.9876*I, 0.1234 + 0.9876*I, 2)
circ(0.1234 + 0.9876*I, 0.8765 + 0.2345*I, .5)
circ(0.1234 + 0.9876*I, 0.1234 + 0.9876*I, 0)</
{{out}}
<pre>%1 = [1.86311180 + 1.97421180*I, -0.863211802 - 0.752111802*I]
Line 2,389 ⟶ 3,094:
=={{header|Perl}}==
{{trans|Python}}
<
sub circles {
Line 2,421 ⟶ 3,126:
);
printf "(%.4f, %.4f) and (%.4f, %.4f) with radius %.1f: %s\n", @$_[0..4], circles @$_ for @arr;</
{{out}}
<pre>(0.1234, 0.9876) and (0.8765, 0.2345) with radius 2.0: (1.8631, 1.9742) and (-0.8632, -0.7521)
Line 2,428 ⟶ 3,133:
(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}}==
<!--<syntaxhighlight lang="phix">(phixonline)-->
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #008080;">constant</span> <span style="color: #000000;">tests</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{{</span><span style="color: #000000;">0.1234</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">0.9876</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">0.8765</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">0.2345</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">2.0</span><span style="color: #0000FF;">},</span>
<span style="color: #0000FF;">{</span><span style="color: #000000;">0.0000</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">2.0000</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">0.0000</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">0.0000</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">1.0</span><span style="color: #0000FF;">},</span>
<span style="color: #0000FF;">{</span><span style="color: #000000;">0.1234</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">0.9876</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">0.1234</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">0.9876</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">2.0</span><span style="color: #0000FF;">},</span>
<span style="color: #0000FF;">{</span><span style="color: #000000;">0.1234</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">0.9876</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">0.8765</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">0.2345</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">0.5</span><span style="color: #0000FF;">},</span>
<span style="color: #0000FF;">{</span><span style="color: #000000;">0.1234</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">0.9876</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">0.1234</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">0.9876</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">0.0</span><span style="color: #0000FF;">}}</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">tests</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span>
<span style="color: #004080;">atom</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">x1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">y1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">x2</span><span style="color: #0000FF;">,</span><span style="color: #000000;">y2</span><span style="color: #0000FF;">,</span><span style="color: #000000;">r</span><span style="color: #0000FF;">}</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">tests</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">],</span>
<span style="color: #000000;">xd</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">x2</span><span style="color: #0000FF;">-</span><span style="color: #000000;">x1</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">yd</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">y1</span><span style="color: #0000FF;">-</span><span style="color: #000000;">y2</span><span style="color: #0000FF;">,</span>
<span style="color: #000000;">s2</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">xd</span><span style="color: #0000FF;">*</span><span style="color: #000000;">xd</span><span style="color: #0000FF;">+</span><span style="color: #000000;">yd</span><span style="color: #0000FF;">*</span><span style="color: #000000;">yd</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">sep</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">sqrt</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s2</span><span style="color: #0000FF;">),</span>
<span style="color: #000000;">xh</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">(</span><span style="color: #000000;">x1</span><span style="color: #0000FF;">+</span><span style="color: #000000;">x2</span><span style="color: #0000FF;">)/</span><span style="color: #000000;">2</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">yh</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">(</span><span style="color: #000000;">y1</span><span style="color: #0000FF;">+</span><span style="color: #000000;">y2</span><span style="color: #0000FF;">)/</span><span style="color: #000000;">2</span>
<span style="color: #004080;">string</span> <span style="color: #000000;">txt</span>
<span style="color: #008080;">if</span> <span style="color: #000000;">sep</span><span style="color: #0000FF;">=</span><span style="color: #000000;">0</span> <span style="color: #008080;">then</span>
<span style="color: #000000;">txt</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"same points/"</span><span style="color: #0000FF;">&</span><span style="color: #008080;">iff</span><span style="color: #0000FF;">(</span><span style="color: #000000;">r</span><span style="color: #0000FF;">=</span><span style="color: #000000;">0</span><span style="color: #0000FF;">?</span><span style="color: #008000;">"radius is zero"</span><span style="color: #0000FF;">:</span><span style="color: #008000;">"infinite solutions"</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">elsif</span> <span style="color: #000000;">sep</span><span style="color: #0000FF;">=</span><span style="color: #000000;">2</span><span style="color: #0000FF;">*</span><span style="color: #000000;">r</span> <span style="color: #008080;">then</span>
<span style="color: #000000;">txt</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">sprintf</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"opposite ends of diameter with centre {%.4f,%.4f}"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">xh</span><span style="color: #0000FF;">,</span><span style="color: #000000;">yh</span><span style="color: #0000FF;">})</span>
<span style="color: #008080;">elsif</span> <span style="color: #000000;">sep</span><span style="color: #0000FF;">></span><span style="color: #000000;">2</span><span style="color: #0000FF;">*</span><span style="color: #000000;">r</span> <span style="color: #008080;">then</span>
<span style="color: #000000;">txt</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">sprintf</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"too far apart (%.4f > %.4f)"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">sep</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2</span><span style="color: #0000FF;">*</span><span style="color: #000000;">r</span><span style="color: #0000FF;">})</span>
<span style="color: #008080;">else</span>
<span style="color: #004080;">atom</span> <span style="color: #000000;">md</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">sqrt</span><span style="color: #0000FF;">(</span><span style="color: #000000;">r</span><span style="color: #0000FF;">*</span><span style="color: #000000;">r</span><span style="color: #0000FF;">-</span><span style="color: #000000;">s2</span><span style="color: #0000FF;">/</span><span style="color: #000000;">4</span><span style="color: #0000FF;">),</span> <span style="color: #000000;">xs</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">md</span><span style="color: #0000FF;">*</span><span style="color: #000000;">xd</span><span style="color: #0000FF;">/</span><span style="color: #000000;">sep</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">ys</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">md</span><span style="color: #0000FF;">*</span><span style="color: #000000;">yd</span><span style="color: #0000FF;">/</span><span style="color: #000000;">sep</span>
<span style="color: #000000;">txt</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">sprintf</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"{%.4f,%.4f} and {%.4f,%.4f}"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">xh</span><span style="color: #0000FF;">+</span><span style="color: #000000;">ys</span><span style="color: #0000FF;">,</span><span style="color: #000000;">yh</span><span style="color: #0000FF;">+</span><span style="color: #000000;">xs</span><span style="color: #0000FF;">,</span><span style="color: #000000;">xh</span><span style="color: #0000FF;">-</span><span style="color: #000000;">ys</span><span style="color: #0000FF;">,</span><span style="color: #000000;">yh</span><span style="color: #0000FF;">-</span><span style="color: #000000;">xs</span><span style="color: #0000FF;">})</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"points {%.4f,%.4f}, {%.4f,%.4f} with radius %.1f ==> %s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">x1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">y1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">x2</span><span style="color: #0000FF;">,</span><span style="color: #000000;">y2</span><span style="color: #0000FF;">,</span><span style="color: #000000;">r</span><span style="color: #0000FF;">,</span><span style="color: #000000;">txt</span><span style="color: #0000FF;">})</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<!--</syntaxhighlight>-->
{{out}}
<pre>
Line 2,465 ⟶ 3,168:
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),
Line 2,509 ⟶ 3,211:
Return(res);
End;
End;</
{{out}}
<pre> x1 y1 x2 y2 r cir1x cir1y cir2x cir2y
Line 2,519 ⟶ 3,221:
0.1234 0.9876 0.1234 0.9876 0 radius of zero gives no circles.
</pre>
=={{header|PureBasic}}==
<syntaxhighlight lang="purebasic">DataSection
DataStart:
Data.d 0.1234, 0.9876, 0.8765, 0.2345, 2.0
Data.d 0.0000, 2.0000, 0.0000, 0.0000, 1.0
Data.d 0.1234, 0.9876, 0.1234, 0.9876, 2.0
Data.d 0.1234, 0.9876, 0.9765, 0.2345, 0.5
Data.d 0.1234, 0.9876, 0.1234, 0.9876, 0.0
DataEnd:
EndDataSection
Macro MaxRec : (?DataEnd-?DataStart)/SizeOf(P2r)-1 : EndMacro
Structure Pxy : x.d : y.d : EndStructure
Structure P2r : p1.Pxy : p2.Pxy : r.d : EndStructure
Structure PData : Prec.P2r[5] : EndStructure
Procedure.s cCenter(Rec.i)
If Rec<0 Or Rec>MaxRec : ProcedureReturn "Data set number incorrect." : EndIf
*myP.PData=?DataStart
r.d=*myP\Prec[Rec]\r
If r<=0.0 : ProcedureReturn "Illegal radius." : EndIf
r2.d=2.0*r
x1.d=*myP\Prec[Rec]\p1\x : x2.d=*myP\Prec[Rec]\p2\x
y1.d=*myP\Prec[Rec]\p1\y : y2.d=*myP\Prec[Rec]\p2\y
d.d=Sqr(Pow(x2-x1,2)+Pow(y2-y1,2))
If d=0.0 : ProcedureReturn "Identical points, infinite number of circles." : EndIf
If d>r2 : ProcedureReturn "No circles possible." : EndIf
z.d=Sqr(Pow(r,2)-Pow(d/2.0,2))
x3.d =(x1+x2)/2.0 : y3.d =(y1+y2)/2.0
cx1.d=x3+z*(y1-y2)/d : cy1.d=y3+z*(x2-x1)/d
cx2.d=x3-z*(y1-y2)/d : cy2.d=y3-z*(x2-x1)/d
If d=r2 : ProcedureReturn "Single circle at ("+StrD(cx1)+","+StrD(cy1)+")" : EndIf
ProcedureReturn "("+StrD(cx1)+","+StrD(cy1)+") and ("+StrD(cx2)+","+StrD(cy2)+")"
EndProcedure
If OpenConsole("")
For i=0 To MaxRec : PrintN(cCenter(i)) : Next : Input()
EndIf</syntaxhighlight>
{{out}}
<pre>(1.8631118017,1.9742118017) and (-0.8632118017,-0.7521118017)
Single circle at (0,1)
Identical points, infinite number of circles.
No circles possible.
Illegal radius.</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
Line 2,568 ⟶ 3,313:
print(' %r\n %r\n' % circles_from_p1p2r(p1, p2, r))
except ValueError as v:
print(' ERROR: %s\n' % (v.args[0],))</
{{out}}
Line 2,607 ⟶ 3,352:
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)
Line 2,636 ⟶ 3,380:
;; returns a vector which is orthogonal to the geven one
(define orth (match-lambda [(vector x y) (vector y (- x))]))
</syntaxhighlight>
{{out|Testing}}
Line 2,660 ⟶ 3,404:
Drawing circles:
<
(require 2htdp/image)
Line 2,676 ⟶ 3,420:
((compose (point p1) (point p2) (circ x1 r) (circ x2 r))
(empty-scene 100 100))
</syntaxhighlight>
=={{header|Raku}}==
(formerly Perl 6)
{{works with|Rakudo|2020.08.1}}
<syntaxhighlight lang="raku" line>multi sub circles (@A, @B where ([and] @A Z== @B), 0.0) { 'Degenerate point' }
multi sub circles (@A, @B where ([and] @A Z== @B), $) { 'Infinitely many share a point' }
multi sub circles (@A, @B, $radius) {
Line 2,701 ⟶ 3,445:
for @input {
say .list.
}</
{{out}}
<pre>([0.1234, 0.9876], [0.8765, 0.2345], 2.0): 1.86311180165819 1.97421180165819 and -0.863211801658189 -0.752111801658189
Line 2,713 ⟶ 3,457:
for it often makes calculations easier with plane geometry:
<syntaxhighlight lang="raku"
multi sub circles ($a, $b where $a == $b, $) { 'Infinitely many share a point' }
multi sub circles ($a, $b, $r) {
Line 2,732 ⟶ 3,476:
for @input {
say .join(', '), ': ', circles(|$_).join(' and ');
}</
{{out}}
Line 2,740 ⟶ 3,484:
0.1234+0.9876i, 0.8765+0.2345i, 0.5: Too far apart
0.1234+0.9876i, 0.1234+0.9876i, 0: Degenerate point</pre>
=={{header|REXX}}==
{{trans|XPL0}}
<br>The REXX language doesn't have a '''sqrt''' function, so one is included below.
<
@.=; @.1= 0.1234 0.9876 0.8765 0.2345 2
@.2= 0 2 0 0 1
Line 2,753 ⟶ 3,497:
say ' ════════ ════════ ════════ ════════ ══════ ════════ ════════ ════════ ════════'
do j=1 while @.j\==''; parse var @.j p1 p2 p3 p4 r /*points, radii*/
say
end
exit
/*──────────────────────────────────────────────────────────────────────────────────────*/
2circ: procedure; parse arg px py qx qy r .; x= (qx-px)/2; y= (qy-py)/2
bx= px + x;
pb= sqrt(x**2 + y**2)
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.'
cb= sqrt(r**2 - pb**2);
/*──────────────────────────────────────────────────────────────────────────────────────*/
if pos(.,f)>0 & pos('E',f)=0 then f= strip(f,'T',0) /*strip trailing 0s if .& ¬E*/
return left( strip(f, 'T', .), length(_) ) /*strip trailing dec point. */
Line 2,772 ⟶ 3,517:
numeric form; parse value format(x,2,1,,0) 'E0' with g "E" _ .; g=g *.5'e'_ % 2
do j=0 while h>9; m.j=h; h=h%2+1; end /*j*/
do k=j+5 to 0 by -1; numeric digits m.k; g=(g+x/g)*.5; end /*k*/; return g</
{{out|output|text= when using the default inputs:}}
<pre>
x1 y1 x2 y2 radius circle1x circle1y circle2x circle2y
Line 2,783 ⟶ 3,528:
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
Line 2,853 ⟶ 3,597:
see "(" + (cx+dy) + ", " + (cy+dx) + ")" + nl
see "(" + (cx-dy) + ", " + (cy-dx) + ")" + nl + nl
</syntaxhighlight>
Output:
<pre>
Line 2,873 ⟶ 3,617:
It will be a single point (0.1234,0.9876) of radius 0
</pre>
=={{header|Ruby}}==
{{trans|Python}}
<
Circle = Struct.new(:x, :y, :r)
Line 2,912 ⟶ 3,655:
end
puts
end</
{{out}}
<pre>
Line 2,949 ⟶ 3,692:
#<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>"
Line 2,997 ⟶ 3,739:
html "<td>";cx+dy;"</td><td>";cy+dx;"</td>" 'two points, with (+)
html "<td>";cx-dy;"</td><td>";cy-dx;"</td></TR>" 'and (-)
RETURN</
{{Out}}<TABLE BORDER="1">
<TR ALIGN="CENTER" BGCOLOR="wheat"><TD>No.</TD><TD>x1</TD><TD>y1</TD><TD>x2
Line 3,011 ⟶ 3,753:
<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)]
Line 3,071 ⟶ 3,812:
describe_circle(p.0, p.1, r);
}
}</
{{out}}
<pre>Points: ((0.1234, 0.9876), (0.8765, 0.2345)), Radius: 2.0000
Line 3,088 ⟶ 3,829:
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._
Line 3,144 ⟶ 3,884:
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
Line 3,152 ⟶ 3,892:
(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)
Line 3,218 ⟶ 3,957:
'((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))
</syntaxhighlight>
{{out}}
Line 3,228 ⟶ 3,967:
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";
Line 3,299 ⟶ 4,037:
point(cases[index][3], cases[index][4]), cases[index][5]);
end for;
end func;</
{{out}}
Line 3,316 ⟶ 4,054:
Radius of zero. No circles can be drawn through (0.1234, 0.9876)
</pre>
=={{header|Sidef}}==
{{trans|
<
if (a == b) {
Line 3,353 ⟶ 4,090:
input.each {|a|
say (a.join(', '), ': ', circles(a...).join(' and '))
}</
{{out}}
<pre>
Line 3,362 ⟶ 4,099:
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
Line 3,384 ⟶ 4,120:
return(J(2, 2, .))
}
}</
Examples:
<
:b=0.8765\0.2345
: centers(a,b,2)
Line 3,425 ⟶ 4,161:
1 | .1234 .1234 |
2 | .9876 .9876 |
+-----------------+</
=={{header|Swift}}==
{{trans|F#}}
<
struct Point: Equatable {
Line 3,509 ⟶ 4,244:
}
</syntaxhighlight>
{{out}}
Line 3,518 ⟶ 4,253:
No ans
No ans</pre>
=={{header|Tcl}}==
{{trans|Python}}
<
lassign $p1 x1 y1
lassign $p2 x2 y2
Line 3,552 ⟶ 4,286:
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
Line 3,570 ⟶ 4,304:
puts "\tERROR: $msg"
}
}</
{{out}}
<pre>
Line 3,586 ⟶ 4,320:
Circle:(0.1234, 0.9876, 0.0)
</pre>
=={{header|VBA}}==
{{trans|Phix}}<
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)
Line 3,622 ⟶ 4,355:
Debug.Print "points " & "{" & x1 & ", " & y1 & "}" & ", " & "{" & x2 & ", " & y2 & "}" & " with radius " & R & " ==> " & txt
Next i
End Sub</
<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.
Line 3,628 ⟶ 4,361:
points {0,1234, 0,9876}, {0,8765, 0,2345} with radius 0,5 ==> too far apart 1,06504423382318 > 1
points {0,1234, 0,9876}, {0,1234, 0,9876} with radius 0 ==> same points/radius is zero</pre>
=={{header|Visual Basic .NET}}==
{{trans|C#}}
<
Public Shared Sub Main()
For Each valu In New Double()() {
Line 3,696 ⟶ 4,428:
End Function
End Structure
End Class</
{{out}}
<pre>Points (0.1234, 0.9876) and (0.8765, 0.2345) with radius 2:
Line 3,710 ⟶ 4,442:
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
Line 3,798 ⟶ 4,529:
ENDDEFINE
</syntaxhighlight>
{{out}}
<pre>
Line 3,827 ⟶ 4,558:
Points (0.1234,0.9876), (0.1234,0.9876) Radius 0.0000.
Points are coincident.
</pre>
=={{header|V (Vlang)}}==
{{trans|Go}}
<syntaxhighlight lang="v (vlang)">import math
const (
two = "two circles."
r0 = "R==0.0 does not describe circles."
co = "coincident points describe an infinite number of circles."
cor0 = "coincident points with r==0.0 describe a degenerate circle."
diam = "Points form a diameter and describe only a single circle."
far = "Points too far apart to form circles."
)
struct Point {
x f64
y f64
}
fn circles(p1 Point, p2 Point, r f64) (Point, Point, string) {
mut case := ''
c1, c2 := p1, p2
if p1 == p2 {
if r == 0 {
return p1, p1, cor0
}
case = co
return c1, c2, case
}
if r == 0 {
return p1, p2, r0
}
dx := p2.x - p1.x
dy := p2.y - p1.y
q := math.hypot(dx, dy)
if q > 2*r {
case = far
return c1, c2, case
}
m := Point{(p1.x + p2.x) / 2, (p1.y + p2.y) / 2}
if q == 2*r {
return m, m, diam
}
d := math.sqrt(r*r - q*q/4)
ox := d * dx / q
oy := d * dy / q
return Point{m.x - oy, m.y + ox}, Point{m.x + oy, m.y - ox}, two
}
struct Cir {
p1 Point
p2 Point
r f64
}
const td = [
Cir{Point{0.1234, 0.9876}, Point{0.8765, 0.2345}, 2.0},
Cir{Point{0.0000, 2.0000}, Point{0.0000, 0.0000}, 1.0},
Cir{Point{0.1234, 0.9876}, Point{0.1234, 0.9876}, 2.0},
Cir{Point{0.1234, 0.9876}, Point{0.8765, 0.2345}, 0.5},
Cir{Point{0.1234, 0.9876}, Point{0.1234, 0.9876}, 0.0},
]
fn main() {
for tc in td {
println("p1: $tc.p1")
println("p2: $tc.p2")
println("r: $tc.r")
c1, c2, case := circles(tc.p1, tc.p2, tc.r)
println(" $case")
match case {
cor0, diam{
println(" Center: $c1")
}
two {
println(" Center 1: $c1")
println(" Center 2: $c2")
}
else{}
}
println('')
}
}</syntaxhighlight>
{{out}}
<pre>
p1: Point{
x: 0.1234
y: 0.9876
}
p2: Point{
x: 0.8765
y: 0.2345
}
r: 2
two circles.
Center 1: Point{
x: 1.863111801658189
y: 1.9742118016581887
}
Center 2: Point{
x: -0.8632118016581891
y: -0.7521118016581888
}
p1: Point{
x: 0
y: 2
}
p2: Point{
x: 0
y: 0
}
r: 1
Points form a diameter and describe only a single circle.
Center: Point{
x: 0
y: 1
}
p1: Point{
x: 0.1234
y: 0.9876
}
p2: Point{
x: 0.1234
y: 0.9876
}
r: 2
coincident points describe an infinite number of circles.
p1: Point{
x: 0.1234
y: 0.9876
}
p2: Point{
x: 0.8765
y: 0.2345
}
r: 0.5
Points too far apart to form circles.
p1: Point{
x: 0.1234
y: 0.9876
}
p2: Point{
x: 0.1234
y: 0.9876
}
r: 0
coincident points with r==0.0 describe a degenerate circle.
Center: Point{
x: 0.1234
y: 0.9876
}
</pre>
=={{header|Wren}}==
{{trans|Go}}
{{libheader|Wren-math}}
<syntaxhighlight lang="wren">import "./math" for Math
var Two = "Two circles."
var R0 = "R == 0 does not describe circles."
var Co = "Coincident points describe an infinite number of circles."
var CoR0 = "Coincident points with r == 0 describe a degenerate circle."
var Diam = "Points form a diameter and describe only a single circle."
var Far = "Points too far apart to form circles."
class Point {
construct new(x, y) {
_x = x
_y = y
}
x { _x }
y { _y }
==(p) { _x == p.x && _y == p.y }
toString { "(%(_x), %(_y))" }
}
var circles = Fn.new { |p1, p2, r|
var c1 = Point.new(0, 0)
var c2 = Point.new(0, 0)
if (p1 == p2) {
if (r == 0) return [p1, p1, CoR0]
return [c1, c2, Co]
}
if (r == 0) return [p1, p2, R0]
var dx = p2.x - p1.x
var dy = p2.y - p1.y
var q = Math.hypot(dx, dy)
if (q > 2*r) return [c1, c2, Far]
var m = Point.new((p1.x + p2.x)/2, (p1.y + p2.y)/2)
if (q == 2*r) return [m, m, Diam]
var d = (r*r - q*q/4).sqrt
var ox = d * dx / q
var oy = d * dy / q
return [Point.new(m.x - oy, m.y + ox), Point.new(m.x + oy, m.y - ox), Two]
}
var td = [
[Point.new(0.1234, 0.9876), Point.new(0.8765, 0.2345), 2.0],
[Point.new(0.0000, 2.0000), Point.new(0.0000, 0.0000), 1.0],
[Point.new(0.1234, 0.9876), Point.new(0.1234, 0.9876), 2.0],
[Point.new(0.1234, 0.9876), Point.new(0.8765, 0.2345), 0.5],
[Point.new(0.1234, 0.9876), Point.new(0.1234, 0.9876), 0.0]
]
for (tc in td) {
System.print("p1: %(tc[0])")
System.print("p2: %(tc[1])")
System.print("r : %(tc[2])")
var res = circles.call(tc[0], tc[1], tc[2])
System.print(" %(res[2])")
if (res[2] == CoR0 || res[2] == Diam) {
System.print(" Center: %(res[0])")
} else if (res[2] == Two) {
System.print(" Center 1: %(res[0])")
System.print(" Center 2: %(res[1])")
}
System.print()
}</syntaxhighlight>
{{out}}
<pre>
p1: (0.1234, 0.9876)
p2: (0.8765, 0.2345)
r : 2
Two circles.
Center 1: (1.8631118016582, 1.9742118016582)
Center 2: (-0.86321180165819, -0.75211180165819)
p1: (0, 2)
p2: (0, 0)
r : 1
Points form a diameter and describe only a single circle.
Center: (0, 1)
p1: (0.1234, 0.9876)
p2: (0.1234, 0.9876)
r : 2
Coincident points describe an infinite number of circles.
p1: (0.1234, 0.9876)
p2: (0.8765, 0.2345)
r : 0.5
Points too far apart to form circles.
p1: (0.1234, 0.9876)
p2: (0.1234, 0.9876)
r : 0
Coincident points with r == 0 describe a degenerate circle.
Center: (0.1234, 0.9876)
</pre>
Line 3,838 ⟶ 4,823:
The method used here is a streamlining of these steps.
<
proc Circles; real Data; \Show centers of circles, given points P & Q and radius
Line 3,862 ⟶ 4,847:
[0.1234, 0.9876, 0.1234, 0.9876, 0.0]];
for I:= 0 to 4 do Circles(Tbl(I));
]</
{{out}}
Line 3,872 ⟶ 4,857:
Radius = zero gives no circles
</pre>
=={{header|Yabasic}}==
{{trans|Liberty BASIC}}
<syntaxhighlight lang="yabasic">
sub twoCircles (x1, y1, x2, y2, radio)
if x1 = x2 and y1 = y2 then //Si los puntos coinciden
if radio = 0 then //a no ser que radio=0
print "Los puntos son los mismos\n"
return true
else
print "Hay cualquier numero de circulos a traves de un solo punto (", x1, ",", y1, ") de radio ", radio : print
return true
end if
end if
r2 = sqr((x1-x2)^2+(y1-y2)^2) / 2 //distancia media entre puntos
if radio < r2 then
print "Los puntos estan demasiado separados (", 2*r2, ") - no hay circulos de radio ", radio : print
return true
end if
//si no, calcular dos centros
cx = (x1+x2) / 2 //punto medio
cy = (y1+y2) / 2
//debe moverse desde el punto medio a lo largo de la perpendicular en dd2
dd2 = sqr(radio^2 - r2^2) //distancia perpendicular
dx1 = x2-cx //vector al punto medio
dy1 = y2-cy
dx = 0-dy1 / r2*dd2 //perpendicular:
dy = dx1 / r2*dd2 //rotar y escalar
print " -> Circulo 1 (", cx+dy, ", ", cy+dx, ")" //dos puntos, con (+)
print " -> Circulo 2 (", cx-dy, ", ", cy-dx, ")\n" //y (-)
end sub
for i = 1 to 5
read x1, y1, x2, y2, radio
print "Puntos ", "(", x1, ",", y1, "), (", x2, ",", y2, ")", ", Radio ", radio
twoCircles (x1, y1, x2, y2, radio)
next
end
//p1 p2 radio
data 0.1234, 0.9876, 0.8765, 0.2345, 2.0
data 0.0000, 2.0000, 0.0000, 0.0000, 1.0
data 0.1234, 0.9876, 0.1234, 0.9876, 2.0
data 0.1234, 0.9876, 0.8765, 0.2345, 0.5
data 0.1234, 0.9876, 0.1234, 0.9876, 0.0
</syntaxhighlight>
=={{header|zkl}}==
{{trans|C}}
<
delta:=(a-c).hypot(b-d);
switch(delta){ // could just catch MathError
Line 3,909 ⟶ 4,940:
else print(cs);
println();
}</
{{out}}
<pre>
Line 3,923 ⟶ 4,954:
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
Line 3,952 ⟶ 4,982:
1190 PRINT "(";cx+dy;",";cy+dx;")"
1200 PRINT "(";cx-dy;",";cy-dx;")"
1210 RETURN</
|