Add tasks for all the new languages

Task/Problem-of-Apollonius/Lasso/problem-of-apollonius.lasso

@@ -0,0 +1,59 @@
+define solveApollonius(c1, c2, c3, s1, s2, s3) => {
+	local(
+		x1 = decimal(#c1->get(1)),
+		y1 = decimal(#c1->get(2)),
+		r1 = decimal(#c1->get(3))
+	)
+	local(
+		x2 = decimal(#c2->get(1)),
+		y2 = decimal(#c2->get(2)),
+		r2 = decimal(#c2->get(3))
+	)
+	local(
+		x3 = decimal(#c3->get(1)),
+		y3 = decimal(#c3->get(2)),
+		r3 = decimal(#c3->get(3))
+	)
+    local(
+    	v11 = 2*#x2 - 2*#x1,
+    	v12 = 2*#y2 - 2*#y1,
+    	v13 = #x1*#x1 - #x2*#x2 + #y1*#y1 - #y2*#y2 - #r1*#r1 + #r2*#r2,
+    	v14 = 2*#s2*#r2 - 2*#s1*#r1,
+    	
+		v21 = 2*#x3 - 2*#x2,
+		v22 = 2*#y3 - 2*#y2,
+		v23 = #x2*#x2 - #x3*#x3 + #y2*#y2 - #y3*#y3 - #r2*#r2 + #r3*#r3,
+		v24 = 2*#s3*#r3 - 2*#s2*#r2,
+		
+		w12 = #v12/#v11,
+		w13 = #v13/#v11,
+		w14 = #v14/#v11,
+		
+		w22 = #v22/#v21-#w12,
+		w23 = #v23/#v21-#w13,
+		w24 = #v24/#v21-#w14,
+		
+		P = -#w23/#w22,
+		Q = #w24/#w22,
+		M = -#w12*#P-#w13,
+		N = #w14 - #w12*#Q,
+		
+		a = #N*#N + #Q*#Q - 1,
+		b = 2*#M*#N - 2*#N*#x1 + 2*#P*#Q - 2*#Q*#y1 + 2*#s1*#r1,
+		c = #x1*#x1 + #M*#M - 2*#M*#x1 + #P*#P + #y1*#y1 - 2*#P*#y1 - #r1*#r1
+
+	)
+	
+	// Find a root of a quadratic equation. This requires the circle centers not to be e.g. colinear
+	local(
+		D = #b*#b-4*#a*#c,
+		rs = (-#b - #D->sqrt)/(2*#a),
+		
+		xs = #M+#N*#rs,
+		ys = #P+#Q*#rs
+	)
+	return (:#xs, #ys, #rs)
+}
+// Tests:
+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)

Task/Problem-of-Apollonius/Nim/problem-of-apollonius.nim

@@ -0,0 +1,48 @@
+import math
+
+type Circle = tuple[x, y, r: float]
+
+proc solveApollonius(c1, c2, c3: Circle; s1, s2, s3: float): Circle =
+  let
+    v11 = 2*c2.x - 2*c1.x
+    v12 = 2*c2.y - 2*c1.y
+    v13 = c1.x*c1.x - c2.x*c2.x + c1.y*c1.y - c2.y*c2.y - c1.r*c1.r + c2.r*c2.r
+    v14 = 2*s2*c2.r - 2*s1*c1.r
+
+    v21 = 2*c3.x - 2*c2.x
+    v22 = 2*c3.y - 2*c2.y
+    v23 = c2.x*c2.x - c3.x*c3.x + c2.y*c2.y - c3.y*c3.y - c2.r*c2.r + c3.r*c3.r
+    v24 = 2*s3*c3.r - 2*s2*c2.r
+
+    w12 = v12/v11
+    w13 = v13/v11
+    w14 = v14/v11
+
+    w22 = v22/v21-w12
+    w23 = v23/v21-w13
+    w24 = v24/v21-w14
+
+    p = -w23/w22
+    q = w24/w22
+    m = -w12*p-w13
+    n = w14 - w12*q
+
+    a = n*n + q*q - 1
+    b = 2*m*n - 2*n*c1.x + 2*p*q - 2*q*c1.y + 2*s1*c1.r
+    c = c1.x*c1.x + m*m - 2*m*c1.x + p*p + c1.y*c1.y - 2*p*c1.y - c1.r*c1.r
+
+    d = b*b-4*a*c
+    rs = (-b-sqrt(d))/(2*a)
+
+    xs = m+n*rs
+    ys = p+q*rs
+
+  return (xs, ys, rs)
+
+let
+  c1: Circle = (0.0, 0.0, 1.0)
+  c2: Circle = (4.0, 0.0, 1.0)
+  c3: Circle = (2.0, 4.0, 2.0)
+
+echo solveApollonius(c1, c2, c3, 1.0, 1.0, 1.0)
+echo solveApollonius(c1, c2, c3, -1.0, -1.0, -1.0)

Task/Problem-of-Apollonius/Sidef/problem-of-apollonius.sidef

@@ -0,0 +1,48 @@
+class Circle(x,y,r) {
+    method to_s { "Circle(#{x}, #{y}, #{r})" }
+}
+
+func solve_apollonius(c, s) {
+
+    var(c1, c2, c3) = c...;
+    var(s1, s2, s3) = s...;
+
+    var 𝑣11 = (2*c2.x - 2*c1.x);
+    var 𝑣12 = (2*c2.y - 2*c1.y);
+    var 𝑣13 = (c1.x**2 - c2.x**2 + c1.y**2 - c2.y**2 - c1.r**2 + c2.r**2);
+    var 𝑣14 = (2*s2*c2.r - 2*s1*c1.r);
+
+    var 𝑣21 = (2*c3.x - 2*c2.x);
+    var 𝑣22 = (2*c3.y - 2*c2.y);
+    var 𝑣23 = (c2.x**2 - c3.x**2 + c2.y**2 - c3.y**2 - c2.r**2 + c3.r**2);
+    var 𝑣24 = (2*s3*c3.r - 2*s2*c2.r);
+
+    var 𝑤12 = (𝑣12 / 𝑣11);
+    var 𝑤13 = (𝑣13 / 𝑣11);
+    var 𝑤14 = (𝑣14 / 𝑣11);
+
+    var 𝑤22 = (𝑣22/𝑣21 - 𝑤12);
+    var 𝑤23 = (𝑣23/𝑣21 - 𝑤13);
+    var 𝑤24 = (𝑣24/𝑣21 - 𝑤14);
+
+    var 𝑃 = (-𝑤23 / 𝑤22);
+    var 𝑄 = (𝑤24 / 𝑤22);
+    var 𝑀 = (-𝑤12*𝑃 - 𝑤13);
+    var 𝑁 = (𝑤14 - 𝑤12*𝑄);
+
+    var 𝑎 = (𝑁**2 + 𝑄**2 - 1);
+    var 𝑏 = (2*𝑀*𝑁 - 2*𝑁*c1.x + 2*𝑃*𝑄 - 2*𝑄*c1.y + 2*s1*c1.r);
+    var 𝑐 = (c1.x**2 + 𝑀**2 - 2*𝑀*c1.x + 𝑃**2 + c1.y**2 - 2*𝑃*c1.y - c1.r**2);
+
+    var 𝐷 = (𝑏**2 - 4*𝑎*𝑐);
+    var rs = ((-𝑏 - 𝐷.sqrt) / 2*𝑎);
+
+    var xs = (𝑀 + 𝑁*rs);
+    var ys = (𝑃 + 𝑄*rs);
+
+    Circle(xs, ys, rs);
+}
+
+var c = [Circle(0, 0, 1), Circle(4, 0, 1), Circle(2, 4, 2)];
+say solve_apollonius(c, %n<1 1 1>);
+say solve_apollonius(c, %n<-1 -1 -1>);

Task/Problem-of-Apollonius/Swift/problem-of-apollonius.swift

@@ -0,0 +1,72 @@
+import Foundation
+
+struct Circle {
+    let center:[Double]!
+    let radius:Double!
+
+    init(center:[Double], radius:Double) {
+        self.center = center
+        self.radius = radius
+    }
+
+    func toString() -> String {
+        return "Circle[x=\(center[0]),y=\(center[1]),r=\(radius)]"
+    }
+}
+
+func solveApollonius(c1:Circle, c2:Circle, c3:Circle,
+    s1:Double, s2:Double, s3:Double) -> Circle {
+
+        let x1 = c1.center[0]
+        let y1 = c1.center[1]
+        let r1 = c1.radius
+        let x2 = c2.center[0]
+        let y2 = c2.center[1]
+        let r2 = c2.radius
+        let x3 = c3.center[0]
+        let y3 = c3.center[1]
+        let r3 = c3.radius
+
+        let v11 = 2*x2 - 2*x1
+        let v12 = 2*y2 - 2*y1
+        let v13 = x1*x1 - x2*x2 + y1*y1 - y2*y2 - r1*r1 + r2*r2
+        let v14 = 2*s2*r2 - 2*s1*r1
+
+        let v21 = 2*x3 - 2*x2
+        let v22 = 2*y3 - 2*y2
+        let v23 = x2*x2 - x3*x3 + y2*y2 - y3*y3 - r2*r2 + r3*r3
+        let v24 = 2*s3*r3 - 2*s2*r2
+
+        let w12 = v12/v11
+        let w13 = v13/v11
+        let w14 = v14/v11
+
+        let w22 = v22/v21-w12
+        let w23 = v23/v21-w13
+        let w24 = v24/v21-w14
+
+        let P = -w23/w22
+        let Q = w24/w22
+        let M = -w12*P-w13
+        let N = w14 - w12*Q
+
+        let a = N*N + Q*Q - 1
+        let b = 2*M*N - 2*N*x1 + 2*P*Q - 2*Q*y1 + 2*s1*r1
+        let c = x1*x1 + M*M - 2*M*x1 + P*P + y1*y1 - 2*P*y1 - r1*r1
+
+        let D = b*b-4*a*c
+
+        let rs = (-b - sqrt(D)) / (2*a)
+        let xs = M + N * rs
+        let ys = P + Q * rs
+
+        return  Circle(center: [xs,ys], radius: rs)
+
+}
+
+let c1 = Circle(center: [0,0], radius: 1)
+let c2 = Circle(center: [4,0], radius: 1)
+let c3 = Circle(center: [2,4], radius: 2)
+
+println(solveApollonius(c1,c2,c3,1,1,1).toString())
+println(solveApollonius(c1,c2,c3,-1,-1,-1).toString())

Task/Problem-of-Apollonius/jq/problem-of-apollonius-1.jq

@@ -0,0 +1,51 @@
+def circle:
+  {"x": .[0], "y": .[1], "r": .[2]};
+
+# Find the interior or exterior Apollonius circle of three circles:
+# ap(circle, circle, circle, boolean)
+# Specify s as true for interior; false for exterior
+def ap(c1; c2; c3; s):
+  def sign: if s then -. else . end;
+    (c1.x * c1.x) as $x1sq
+  | (c1.y * c1.y) as $y1sq
+  | (c1.r * c1.r) as $r1sq
+  | (c2.x * c2.x) as $x2sq
+  | (c2.y * c2.y) as $y2sq
+  | (c2.r * c2.r) as $r2sq
+  | (c3.x * c3.x) as $x3sq
+  | (c3.y * c3.y) as $y3sq
+  | (c3.r * c3.r) as $r3sq
+
+  | (2 * (c2.x - c1.x)) as $v11
+  | (2 * (c2.y - c1.y)) as $v12
+  | ($x1sq - $x2sq + $y1sq - $y2sq - $r1sq + $r2sq) as $v13
+
+  | (2 * (c2.r - c1.r) | sign) as $v14
+  | (2 * (c3.x - c2.x)) as $v21
+  | (2 * (c3.y - c2.y)) as $v22
+
+  | ($x2sq - $x3sq + $y2sq - $y3sq - $r2sq + $r3sq) as $v23
+  | ( 2 * c3.r - c2.r | sign) as $v24
+  | ($v12 / $v11) as $w12
+  | ($v13 / $v11) as $w13
+  | ($v14 / $v11) as $w14
+
+  | (($v22 / $v21) - $w12) as $w22
+  | (($v23 / $v21) - $w13) as $w23
+  | (($v24 / $v21) - $w14) as $w24
+
+  | (-$w23 / $w22) as $p
+  | ( $w24 / $w22) as $q
+  | ((-$w12*$p) - $w13) as $m
+  | ( $w14 - ($w12*$q)) as $n
+
+  | ( $n*$n + $q*$q - 1 ) as $a
+  | (2 * (($m*$n - $n*c1.x + $p*$q - $q*c1.y) + (c1.r|sign))) as $b
+  | ($x1sq + $m*$m - 2*$m*c1.x + $p*$p + $y1sq - 2*$p*c1.y - $r1sq) as $c
+
+  | ( $b*$b - 4*$a*$c ) as $d                   # discriminant
+  | (( -$b - (($d|sqrt))) / (2 * $a)) as $rs    # root
+
+  | [$m + ($n*$rs),  $p + ($q*$rs),  $rs]
+  | circle
+;

Task/Problem-of-Apollonius/jq/problem-of-apollonius-2.jq

@@ -0,0 +1,7 @@
+def task:
+     ([0, 0, 1] | circle) as $c1
+  |  ([4, 0, 1] | circle) as $c2
+  |  ([2, 4, 2] | circle) as $c3
+  | ( ap($c1; $c2; $c3; true),      # interior
+      ap($c1; $c2; $c3; false) )    # exterior
+;

Task/Problem-of-Apollonius/jq/problem-of-apollonius-3.jq

@@ -0,0 +1,3 @@
+$ jq -n -c -f apollonius.jq
+{"x":2,"y":0.8333333333333333,"r":1.1666666666666667}
+{"x":2,"y":2.1,"r":3.9}