Problem of Apollonius: Difference between revisions

 

;Task:

 

<br><br>

 

=={{header|Ada}}==

apollonius.ads:

type Point is record

X, Y : Long_Float := 0.0;

T1, T2, T3 : Tangentiality := External)

return Circle;

apollonius.adb:

 

package body Apollonius is

end;

end Solve_CCC;

 

example test_apollonius.adb:

with Apollonius;

 

Long_Float_IO.Put (R2.Radius, Aft => 3, Exp => 0);

Ada.Text_IO.New_Line;

 

output:

R2:

2.000 0.833 1.167</pre>

 

=={{header|AutoHotkey}}==

{{libheader|GDIP}}

#SingleInstance, Force

SetBatchLines, -1

Gdip_DrawCircle(G, pPen, x, y, r) {

Return Gdip_DrawEllipse(G, pPen, x-r, y-r, r*2, r*2)

 

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

{{works with|BBC BASIC for Windows}}

Note use made of array arithmetic.

DIM Circles{(2)} = Circle{}

Circles{(0)}.x = 0 : Circles{(0)}.y = 0 : Circles{(0)}.r = 1

c.x = c.r * w(2) - w(1)

c.y = c.r * u(2) - u(1)

'''Output:'''

<pre>

=={{header|C}}==

C99. 2D vectors are actually complex numbers. The method here is unothordox if not insane. I can't prove that it should work, though it does seem to give correct answers for test cases I tried.

#include <tgmath.h>

 

puts("set 2"); apollonius(b);

puts("set 3"); apollonius(c);

 

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

This code finds all 8 possible circles touching the three given circles.

using System;

 

}

}

 

=={{header|CoffeeScript}}==

{{trans|Java}}

class Circle

constructor: (@x, @y, @r) ->

console.log apollonius(c1, c2, c3, -1, -1, -1)

 

output

> coffee foo.coffee

{ x: 0, y: 0, r: 1 }

{ x: 2, y: 2.1, r: 3.9 }

{ x: 2, y: 0.8333333333333333, r: 1.1666666666666667 }

 

=={{header|D}}==

{{trans|Java}}

 

immutable struct Circle { double x, y, r; }

alias Ti = Tangent.internally;

solveApollonius(c1, c2, c3, Ti, Ti, Ti).writeln;

{{out}}

<pre>immutable(Circle)(2, 2.1, 3.9)

immutable(Circle)(2, 0.833333, 1.16667)

</pre>

 

=={{header|Elixir}}==

{{trans|Ruby}}

def apollonius(c1, c2, c3, s1, s2, s3) do

{x1, y1, r1} = c1

IO.inspect Circle.apollonius(c1, c2, c3, 1, 1, 1)

 

{{out}}

=={{header|F_Sharp|F#}}==

{{trans|OCaml}}

type circle = { center: point; radius: float; }

 

let r2 = solve_apollonius c1 c2 c3 (-1.) (-1.) (-1.)

print_circle r2

{{out}}

<pre>Circle(x=2.00, y=2.10, r=3.90)

=={{header|Fortran}}==

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

implicit none

 

 

end function

Output

<pre>External tangent: 2.00000000 2.10000000 3.90000000

Internal tangent: 2.00000000 0.83333333 1.16666667</pre>

=={{header|Go}}==

{{trans|Java}}

Simplified to produce only the fully interior and fully exterior solutions.

 

import (

rs := (-b - math.Sqrt(d)) / (2 * a)

return circle{m + n*rs, p + q*rs, rs}

Output:

<pre>

=={{header|Haskell}}==

{{trans|D}}

data Tangent = Externally | Internally deriving Eq

 

 

let ti = Internally

{{out}}

<pre>Circle {x = 2.0, y = 2.1, r = 3.9}

This is a translation of the Java version. [[File:Apollonius-unicon.png|thumb|Solution for Apollonius]]

 

 

record circle(x,y,r)

ys := P + Q * rs

return circle(xs,ys,rs)

 

Output:<pre>Circle(x,y,r) := (0, 0, 1)

=={{header|J}}==

'''Solution'''

 

NB.*apollonius v solves Apollonius problems

avg=. +/ % #

(, avg@dist) soln

 

'''Usage'''

0 0 1

4 0 1

2 0.83333333 1.1666667

2 2.1 3.9

 

=={{header|Java}}==

{

public double[] center;

System.out.println(solveApollonius(c1,c2,c3,-1,-1,-1));

}

 

=={{header|jq}}==

{{trans|Go}}

{{works with|jq|1.4}}

{"x": .[0], "y": .[1], "r": .[2]};

 

| [$m + ($n*$rs), $p + ($q*$rs), $rs]

| circle

'''The task''':

([0, 0, 1] | circle) as $c1

| ([4, 0, 1] | circle) as $c2

| ( ap($c1; $c2; $c3; true), # interior

ap($c1; $c2; $c3; false) ) # exterior

{{Out}}

{"x":2,"y":0.8333333333333333,"r":1.1666666666666667}

 

=={{header|Julia}}==

 

'''Module''':

 

module ApolloniusProblems

 

export Circle

 

d = (x[1] ^ 2 + y[1] ^ 2 - r[1] ^ 2) .- (x[2:3] .^ 2 .+ y[2:3] .^ 2 .- r[2:3] .^ 2)

end

s = (u - x[1]) ^ 2 + (v - y[1]) ^ 2 - w

r = filter(x -> iszero(imag(x)) && x > zero(x), roots(s))

length(r) == 1 || error("There is no solution.")

r = r[1]

end

 

 

'''Main''':

 

let test = [Circle(0.0, 0.0, 1.0), Circle(4.0, 0.0, 1.0), Circle(2.0, 4.0, 2.0)]

println("The internal circle is:\n\t", ApolloniusProblems.solve(test))

println("The external circle is:\n\t", ApolloniusProblems.solve(test, 1:3))

 

{{out}}

=={{header|Kotlin}}==

{{trans|Java}}

 

data class Circle(val x: Double, val y: Double, val r: Double)

println(solveApollonius(c1, c2, c3, 1, 1, 1))

println(solveApollonius(c1, c2, c3,-1,-1,-1))

 

{{out}}

=={{header|Lasso}}==

{{trans|Java}}

local(

x1 = decimal(#c1->get(1)),

solveApollonius((:0, 0, 1), (:4, 0, 1), (:2, 4, 2), 1,1,1)

solveApollonius((:0, 0, 1), (:4, 0, 1), (:2, 4, 2), -1,-1,-1)

{{out}}

<pre>staticarray(2.000000, 2.100000, 3.900000)

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

Uses the string Circle$ to hold "xPos, yPos, radius" as csv data. A GUI representation is very easily added.

circle1$ =" 0.000, 0.000, 1.000"

circle2$ =" 4.000, 0.000, 1.000"

ApolloniusSolver$ =using( "###.###", XPos) +"," +using( "###.###", YPos) +using( "###.###", Radius)

end function

x_pos y_pos radius

2.000, 2.100, 3.900

2.000, 0.833, 1.167

 

Module[{x1=a1,y1=b1,r1=c1,x2=a2,y2=b2,r2=c2,x3=a3,y3=b3,r3=c3,s1=S1,s2=S2,s3=S3},

v11 = 2*x2 - 2*x1; v12 = 2*y2 - 2*y1;

rs = (-b -Sqrt[d])/(2*a);

xs = m + n*rs; ys = p + q*rs;

 

<pre>Apolonius[0,0,1,2,4,2,4,0,1,1,1,1]

=={{header|MUMPS}}==

{{trans|Java}}

;Circles are passed in as strings with three parts with a "^" separator in the order x^y^r

;The three circles are CIR1, CIR2, and CIR3

SET $PIECE(CIRR,"^",3)=RS

KILL X1,X2,X3,Y1,Y2,Y3,R1,R2,R3,RS,V11,V12,V13,V14,V21,V22,V23,V24,W12,W13,W14,W22,W23,W24,P,M,N,Q,A,B,C,D

In use:<pre>

USER>WRITE C1

=={{header|Nim}}==

{{trans|Python}}

 

type Circle = tuple[x, y, r: float]

 

echo solveApollonius(c1, c2, c3, 1.0, 1.0, 1.0)

Output:

 

=={{header|OCaml}}==

{{trans|C}}

 

type circle = {

center: point;

let r2 = solve_apollonius c1 c2 c3 (-1.) (-1.) (-1.) in

print_circle r2;

 

=={{header|Perl}}==

Using the module <code>Math::Cartesian::Product</code> to generate the values to allow iteration through all solutions.

use Math::Cartesian::Product;

 

for (cartesian {@_} ([-1,1])x3) {

print Circle->show( solve_Apollonius $c1, $c2, $c3, @$_);

{{out}}

<pre>x = 2.000 y = 0.833 r = 1.167

 

=={{header|Phix}}==

{{out}}

<pre>

 

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

 

define structure

return (res);

end Solve_Apollonius;

Results:

<pre>

=={{header|PowerShell}}==

{{trans|C#}}

function Measure-Apollonius

{

}

}

for ($i = 1; $i -le 8; $i++)

{

Measure-Apollonius -Counter $i -x1 0 -y1 0 -r1 1 -x2 4 -y2 0 -r2 1 -x3 2 -y3 4 -r3 2

}

{{Out}}

<pre>

=={{header|PureBasic}}==

{{trans|Java}}

XPos.f

YPos.f

EndIf

Print("Press ENTER to exit"): Input()

<pre>Circle [x=2.00, y=2.10, r=3.90]

Circle [x=2.00, y=0.83, r=1.17]

=={{header|Python}}==

{{trans|Java}}. Although a Circle class is defined, the solveApollonius function is defined in such a way that any three valued tuple or list could be used instead of c1, c2, and c3. The function calls near the end use instances of the Circle class, whereas the docstring shows how the same can be achieved using simple tuples. (And also serves as a simple [[wp:Doctest|doctest]])

from collections import namedtuple

import math

c1, c2, c3 = Circle(0, 0, 1), Circle(4, 0, 1), Circle(2, 4, 2)

print(solveApollonius(c1, c2, c3, 1, 1, 1)) #Expects "Circle[x=2.00,y=2.10,r=3.90]" (green circle in image)

'''Sample Output'''

<pre>Circle(x=2.0, y=2.1, r=3.9)

=={{header|Racket}}==

{{trans|Java}}

#lang slideshow

 

"green" (apollonius c1 c2 c3 1.0 1.0 1.0)

"red" (apollonius c1 c2 c3 -1.0 -1.0 -1.0))

 

=={{header|REXX}}==

Programming note: &nbsp; REXX has no &nbsp; '''sqrt''' &nbsp; (square root) function, so a RYO version is included here.

/*────────────────────────────────────── Perga [Pergæus] (circa 262 BCE ──► 190 BCE). */

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

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

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

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

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

Programming note: &nbsp; in REXX, dividing by unity normalizes the number.

{{trans|Java}}

 

def initialize(x, y, r)

@x, @y, @r = [x, y, r].map(&:to_f)

 

puts Circle.apollonius(c1, c2, c3)

 

{{out}}

 

=={{header|Scala}}==

case class Circle(x: Double, y: Double, r: Double)

object Tangent extends Enumeration {

}

}

Output:

<pre>

 

=={{header|Sidef}}==

method to_s { "Circle(#{x}, #{y}, #{r})" }

}

var c = [Circle(0, 0, 1), Circle(4, 0, 1), Circle(2, 4, 2)];

say solve_apollonius(c, %n<1 1 1>);

{{out}}

<pre>

=={{header|Swift}}==

{{trans|Java}}

 

struct Circle {

 

println(solveApollonius(c1,c2,c3,1,1,1).toString())

{{out}}

<pre>Circle[x=2.0,y=2.1,r=3.9]

{{trans|Java}}

{{works with|Tcl|8.6}} or {{libheader|TclOO}}

 

oo::class create circle {

 

return [circle new $xs $ys $rs]

Demonstration code:

set c2 [circle new 4 0 1]

set c3 [circle new 2 4 2]

set sB [solveApollonius $c1 $c2 $c3 -1 -1 -1]

puts [$sA format]

Output:

<pre>

=={{header|VBA}}==

 

Option Explicit

Option Base 0

End Function

 

 

=={{header|zkl}}==

{{trans|D}}

fcn init(xpos,ypos,radius){

var [const] x=xpos.toFloat(), y=ypos.toFloat(),r=radius.toFloat();

Circle(M + N*rs, P + Q*rs, rs);

}

a.apollonius(b,c).println(" Outside");

{{out}}

<pre>