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.

</pre>

 

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

 

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>

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

 

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

 

my ($x1, $y1, $x2, $y2, $r) = @_;

# delta x, delta y between points

my ($dx, $dy) = ($x2 - $x1, $y2 - $y1);

my $q = sqrt($dx**2 + $dy**2);

# halfway point

my ($x3, $y3) = (($x1 + $x2) / 2, ($y1 + $y2) / 2);

# distance along the mirror line

my $d = sqrt($r**2-($q/2)**2);

 

}

 

 

{{out}}

{{out}}

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

 

 

 

 

 

{{out}}

<pre>

</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;")"