z' = \frac{1}{2}(z + \frac{1}{z})

a = (1, 0)
m = (-0.06397977695949696, 0.3943261353620319)
c = Circle(m, a)
r: abs(a)
b = CurveCartesian((1 / 2 * (m + (r * ℯ^((ί * t))) + 1 / (m + (r * ℯ^((ί * t)))))), t, (-π), π)

Tool: Conic4Pkte1TangInP1
5 Punkte markieren
Input: A1, A2, A3, A4, A5
Output: f, KS

B5: A5 + (0, 0, 1)
B3: A3 + (0, 0, 1)
C3: {x(B3), y(B3), z(B3)}
B1: A1 + (0, 0, 1)
g: B1 ⊗ B5
C1: {x(B1), y(B1), z(B1)}
B4: A4 + (0, 0, 1)
C4: {x(B4), y(B4), z(B4)}
B2: A2 + (0, 0, 1)
C2: {x(B2), y(B2), z(B2)}
f = Line(A1, A5)
g34: B3 ⊗ B4
g13: B1 ⊗ B3
g12: B1 ⊗ B2
g24: B2 ⊗ B4
μ: ((-((g * B2))) * Determinant[{C1, C3, C4}])
λ: ((g * B3) * Determinant[{C1, C2, C4}])
S(x, y) = ((((λ * g12) * (x, y, 1)) * g34) * (x, y, 1)) + ((((μ * g13) * (x, y, 1)) * g24) * (x, y, 1))
KS: S(x, y) = 0

Tool: Conic5Tang
5 Geraden auswählen
Input: f, g, h, i, j
Output: KS2

G5: (x(j), y(j), z(j))
H5: {x(G5), y(G5), z(G5)}
G1: (x(f), y(f), z(f))
H1: {x(G1), y(G1), z(G1)}
G3: (x(h), y(h), z(h))
g13: G1 ⊗ G3
H3: {x(G3), y(G3), z(G3)}
G2: (x(g), y(g), z(g))
g12: G1 ⊗ G2
H2: {x(G2), y(G2), z(G2)}
dkrit = Determinant({H1, H2, H3})
G4: (x(i), y(i), z(i))
H4: {x(G4), y(G4), z(G4)}
μ5N: ((-Determinant[{H1, H2, H5}]) * Determinant[{H3, H4, H5}] / dkrit)
λ5N: (Determinant[{H1, H3, H5}] * Determinant[{H2, H4, H5}] / dkrit)
g24: G2 ⊗ G4
g34: G3 ⊗ G4
BilinMatrix: Zip[Zip[(λ5N * ((((g12 * u) * g34) * v) + (((g12 * v) * g34) * u))) + (μ5N * ((((g13 * u) * g24) * v) + (((g13 * v) * g24) * u))), u, {(1, 0, 0), (0, 1, 0), (0, 0, 1)}], v, {(1, 0, 0), (0, 1, 0), (0, 0, 1)}] / ((dkrit * 1000))
BilinMatrixInvers = Invert(BilinMatrix)
Koeff: {BilinMatrixInvers(1, 1), BilinMatrixInvers(2, 2), BilinMatrixInvers(3, 3), (2 * BilinMatrixInvers(1, 2)), (2 * BilinMatrixInvers(1, 3)), (2 * BilinMatrixInvers(2, 3))}
KS2 = Conic(Koeff)

Tool: Conic5TangPlus
5 Geraden auswählen
Input: f, g, h, i, j
Output: KS2, BPktList

G5: (x(j), y(j), z(j))
H5: {x(G5), y(G5), z(G5)}
G1: (x(f), y(f), z(f))
H1: {x(G1), y(G1), z(G1)}
G3: (x(h), y(h), z(h))
g13: G1 ⊗ G3
H3: {x(G3), y(G3), z(G3)}
G2: (x(g), y(g), z(g))
g12: G1 ⊗ G2
H2: {x(G2), y(G2), z(G2)}
dkrit = Determinant({H1, H2, H3})
G4: (x(i), y(i), z(i))
H4: {x(G4), y(G4), z(G4)}
μ5N: ((-Determinant[{H1, H2, H5}]) * Determinant[{H3, H4, H5}] / dkrit)
λ5N: (Determinant[{H1, H3, H5}] * Determinant[{H2, H4, H5}] / dkrit)
g24: G2 ⊗ G4
g34: G3 ⊗ G4
BilinMatrix: Zip[Zip[(λ5N * ((((g12 * u) * g34) * v) + (((g12 * v) * g34) * u))) + (μ5N * ((((g13 * u) * g24) * v) + (((g13 * v) * g24) * u))), u, {(1, 0, 0), (0, 1, 0), (0, 0, 1)}], v, {(1, 0, 0), (0, 1, 0), (0, 0, 1)}] / ((dkrit * 1000))
BilinMatrixInvers = Invert(BilinMatrix)
Koeff: {BilinMatrixInvers(1, 1), BilinMatrixInvers(2, 2), BilinMatrixInvers(3, 3), (2 * BilinMatrixInvers(1, 2)), (2 * BilinMatrixInvers(1, 3)), (2 * BilinMatrixInvers(2, 3))}
KS2 = Conic(Koeff)
BPList: {(BilinMatrix * G1), (BilinMatrix * G2), (BilinMatrix * G3), (BilinMatrix * G4), (BilinMatrix * G5)}
BPktList = Zip((x(p) / z(p), y(p) / z(p)), p, BPList)

Tool: 2Conics4Pkte1Tang (command Conics4Pkte1Tang)
4Pkte1Gerademarkieren
Input: A4, A3, A2, A1, f
Output: KS1, KS2

g: (x(f), y(f), z(f))
B4: {x(A4), y(A4), 1}
C3: (x(A3), y(A3), 1)
B3: {x(A3), y(A3), 1}
C2: (x(A2), y(A2), 1)
B2: {x(A2), y(A2), 1}
C1: (x(A1), y(A1), 1)
g13: C1 ⊗ C3
P6: g ⊗ g13
b6: {x(P6), y(P6), z(P6)}
g12: C1 ⊗ C2
P5: g ⊗ g12
b5: {x(P5), y(P5), z(P5)}
b7: b5 - b6
B1: {x(A1), y(A1), 1}
C4: (x(A4), y(A4), 1)
g34: C3 ⊗ C4
g24: C2 ⊗ C4
Koefb: (Determinant[{B1, B3, b7}] * Determinant[{B2, B4, b7}])
Koefc: (Determinant[{B1, B2, b6}] * Determinant[{B3, B4, b7}]) + (Determinant[{B1, B2, b7}] * Determinant[{B3, B4, b6}])
Koefd: (Determinant[{B1, B3, b6}] * Determinant[{B2, B4, b7}]) + (Determinant[{B1, B3, b7}] * Determinant[{B2, B4, b6}])
Koefe: (Determinant[{B1, B2, b6}] * Determinant[{B3, B4, b6}])
Koeff: (Determinant[{B1, B3, b6}] * Determinant[{B2, B4, b6}])
Koefa: (Determinant[{B1, B2, b7}] * Determinant[{B3, B4, b7}])
qp: ((Koefc * Koefd) - ((2 * Koefe) * Koefb) - ((2 * Koefa) * Koeff)) / (Koefc^(2) - ((4 * Koefa) * Koefe))
qq: (Koefd^(2) - ((4 * Koeff) * Koefb)) / (Koefc^(2) - ((4 * Koefa) * Koefe))
λ1: (-qp) + sqrt(qp^(2) - qq)
λ2: (-qp) - sqrt(qp^(2) - qq)
quλ1(x, y) = ((((λ1 * g12) * (x, y, 1)) * g34) * (x, y, 1)) + (((g13 * (x, y, 1)) * g24) * (x, y, 1))
KS1: quλ1(x, y) = 0
quλ2(x, y) = ((((λ2 * g12) * (x, y, 1)) * g34) * (x, y, 1)) + (((g13 * (x, y, 1)) * g24) * (x, y, 1))
KS2: quλ2(x, y) = 0

Tool: Conics4Pkte1TangPlus
4Pkte1GeradeAuswählen
Input: A1, A2, A3, A4, f
Output: KS1, KS2, BPList

g: (x(f), y(f), z(f))
B4: {x(A4), y(A4), 1}
C3: (x(A3), y(A3), 1)
B3: {x(A3), y(A3), 1}
C2: (x(A2), y(A2), 1)
B2: {x(A2), y(A2), 1}
C1: (x(A1), y(A1), 1)
g13: C1 ⊗ C3
P6: g ⊗ g13
b6: {x(P6), y(P6), z(P6)}
g12: C1 ⊗ C2
P5: g ⊗ g12
b5: {x(P5), y(P5), z(P5)}
b7: b5 - b6
B1: {x(A1), y(A1), 1}
C4: (x(A4), y(A4), 1)
g34: C3 ⊗ C4
g24: C2 ⊗ C4
Koefb: (Determinant[{B1, B3, b7}] * Determinant[{B2, B4, b7}])
Koefc: (Determinant[{B1, B2, b6}] * Determinant[{B3, B4, b7}]) + (Determinant[{B1, B2, b7}] * Determinant[{B3, B4, b6}])
Koefd: (Determinant[{B1, B3, b6}] * Determinant[{B2, B4, b7}]) + (Determinant[{B1, B3, b7}] * Determinant[{B2, B4, b6}])
Koefe: (Determinant[{B1, B2, b6}] * Determinant[{B3, B4, b6}])
Koeff: (Determinant[{B1, B3, b6}] * Determinant[{B2, B4, b6}])
Koefa: (Determinant[{B1, B2, b7}] * Determinant[{B3, B4, b7}])
qp: ((Koefc * Koefd) - ((2 * Koefe) * Koefb) - ((2 * Koefa) * Koeff)) / (Koefc^(2) - ((4 * Koefa) * Koefe))
qq: (Koefd^(2) - ((4 * Koeff) * Koefb)) / (Koefc^(2) - ((4 * Koefa) * Koefe))
λ1: (-qp) + sqrt(qp^(2) - qq)
λ2: (-qp) - sqrt(qp^(2) - qq)
quλ1(x, y) = ((((λ1 * g12) * (x, y, 1)) * g34) * (x, y, 1)) + (((g13 * (x, y, 1)) * g24) * (x, y, 1))
KS1: quλ1(x, y) = 0
quλ2(x, y) = ((((λ2 * g12) * (x, y, 1)) * g34) * (x, y, 1)) + (((g13 * (x, y, 1)) * g24) * (x, y, 1))
KS2: quλ2(x, y) = 0
bp1: ((λ1 * Koefc) + Koefd) / ((λ1 * Koefa) + Koefb)
bp2: ((λ2 * Koefc) + Koefd) / ((λ2 * Koefa) + Koefb)
BPKT1: (((-bp1)) / 2 * P5) + ((1 + bp1 / 2) * P6)
BPKT2: (((-bp2)) / 2 * P5) + ((1 + bp2 / 2) * P6)
a5 = Point({x(BPKT1) / z(BPKT1), y(BPKT1) / z(BPKT1)})
a6 = Point({x(BPKT2) / z(BPKT2), y(BPKT2) / z(BPKT2)})
diskr: qp^(2) - qq
BPList = If(abs(diskr) < 1.0E-6, {a5}, {a5, a6})

Tool: Conics4Tang1Pkt
4Geraden1PktAuswählen
Input: f, g, h, i, P
Output: KSλ1, KSλ2

A2: (x(g), y(g), z(g))
A4: (x(i), y(i), z(i))
P24: A2 ⊗ A4
A1: (x(f), y(f), z(f))
A3: (x(h), y(h), z(h))
P13: A1 ⊗ A3
G5 = Line(P, P + (1, 0))
B1: {x(A1), y(A1), z(A1)}
B2: {x(A2), y(A2), z(A2)}
B3: {x(A3), y(A3), z(A3)}
P12: A1 ⊗ A2
P34: A3 ⊗ A4
A5: (x(G5), y(G5), z(G5))
dkrit = Determinant({B1, B2, B3})
G6 = Line(P, P + (0, 1))
A6: (x(G6), y(G6), z(G6))
A7: A5 - A6
Koefa: (((P12 * A7) * P34) * A7)
Koefb: (((P13 * A7) * P24) * A7)
Koefc: (((P12 * A6) * P34) * A7) + (((P12 * A7) * P34) * A6)
Koeff: ((P13 * A6) * (P24 * A6))
Koefd: (((P13 * A6) * P24) * A7) + ((P13 * A7) * (P24 * A6))
Koefe: (((P12 * A6) * P34) * A6)
qp: (((2 * Koefe) * Koefb) + ((2 * Koefa) * Koeff) - (Koefc * Koefd)) / (Koefc^(2) - ((4 * Koefa) * Koefe))
qq: (Koefd^(2) - ((4 * Koeff) * Koefb)) / (Koefc^(2) - ((4 * Koefa) * Koefe))
λ1: qp + sqrt(qp^(2) - qq)
λ2: qp - sqrt(qp^(2) - qq)
BilinMλ1: Zip[Zip[(λ1 * ((((P12 * u) * P34) * v) + (((P12 * v) * P34) * u))) + (((P13 * u) * P24) * v) + (((P13 * v) * P24) * u), u, {(1, 0, 0), (0, 1, 0), (0, 0, 1)}], v, {(1, 0, 0), (0, 1, 0), (0, 0, 1)}] / dkrit
BilinMλ2: Zip[Zip[(λ2 * ((((P12 * u) * P34) * v) + (((P12 * v) * P34) * u))) + (((P13 * u) * P24) * v) + (((P13 * v) * P24) * u), u, {(1, 0, 0), (0, 1, 0), (0, 0, 1)}], v, {(1, 0, 0), (0, 1, 0), (0, 0, 1)}] / dkrit
BilinMλ1Invers = Invert(BilinMλ1)
BilinMλ2Invers = Invert(BilinMλ2)
KSKoeffλ1: {BilinMλ1Invers(1, 1), BilinMλ1Invers(2, 2), BilinMλ1Invers(3, 3), (2 * BilinMλ1Invers(1, 2)), (2 * BilinMλ1Invers(1, 3)), (2 * BilinMλ1Invers(2, 3))}
KSλ1: (KSKoeffλ1(1) * x^(2)) + (KSKoeffλ1(2) * y^(2)) + KSKoeffλ1(3) + ((KSKoeffλ1(4) * x) * y) + (KSKoeffλ1(5) * x) + (KSKoeffλ1(6) * y) = 0
KSKoeffλ2: {BilinMλ2Invers(1, 1), BilinMλ2Invers(2, 2), BilinMλ2Invers(3, 3), (2 * BilinMλ2Invers(1, 2)), (2 * BilinMλ2Invers(1, 3)), (2 * BilinMλ2Invers(2, 3))}
KSλ2: (KSKoeffλ2(1) * x^(2)) + (KSKoeffλ2(2) * y^(2)) + KSKoeffλ2(3) + ((KSKoeffλ2(4) * x) * y) + (KSKoeffλ2(5) * x) + (KSKoeffλ2(6) * y) = 0

Tool: Conics4Tang1PktPlus
4Geraden1PktAuswählen
Input: f, g, h, i, P
Output: KSλ1, KSλ2, BPktList1, BPktList2

A2: (x(g), y(g), z(g))
A4: (x(i), y(i), z(i))
P24: A2 ⊗ A4
A1: (x(f), y(f), z(f))
A3: (x(h), y(h), z(h))
P13: A1 ⊗ A3
G5 = Line(P, P + (1, 0))
B1: {x(A1), y(A1), z(A1)}
B2: {x(A2), y(A2), z(A2)}
B3: {x(A3), y(A3), z(A3)}
P12: A1 ⊗ A2
P34: A3 ⊗ A4
A5: (x(G5), y(G5), z(G5))
dkrit = Determinant({B1, B2, B3})
G6 = Line(P, P + (0, 1))
A6: (x(G6), y(G6), z(G6))
A7: A5 - A6
Koefa: (((P12 * A7) * P34) * A7)
Koefb: (((P13 * A7) * P24) * A7)
Koefc: (((P12 * A6) * P34) * A7) + (((P12 * A7) * P34) * A6)
Koeff: ((P13 * A6) * (P24 * A6))
Koefd: (((P13 * A6) * P24) * A7) + ((P13 * A7) * (P24 * A6))
Koefe: (((P12 * A6) * P34) * A6)
qp: (((2 * Koefe) * Koefb) + ((2 * Koefa) * Koeff) - (Koefc * Koefd)) / (Koefc^(2) - ((4 * Koefa) * Koefe))
qq: (Koefd^(2) - ((4 * Koeff) * Koefb)) / (Koefc^(2) - ((4 * Koefa) * Koefe))
λ1: qp + sqrt(qp^(2) - qq)
λ2: qp - sqrt(qp^(2) - qq)
BilinMλ1: Zip[Zip[(λ1 * ((((P12 * u) * P34) * v) + (((P12 * v) * P34) * u))) + (((P13 * u) * P24) * v) + (((P13 * v) * P24) * u), u, {(1, 0, 0), (0, 1, 0), (0, 0, 1)}], v, {(1, 0, 0), (0, 1, 0), (0, 0, 1)}] / dkrit
BilinMλ2: Zip[Zip[(λ2 * ((((P12 * u) * P34) * v) + (((P12 * v) * P34) * u))) + (((P13 * u) * P24) * v) + (((P13 * v) * P24) * u), u, {(1, 0, 0), (0, 1, 0), (0, 0, 1)}], v, {(1, 0, 0), (0, 1, 0), (0, 0, 1)}] / dkrit
BilinMλ1Invers = Invert(BilinMλ1)
BilinMλ2Invers = Invert(BilinMλ2)
KSKoeffλ1: {BilinMλ1Invers(1, 1), BilinMλ1Invers(2, 2), BilinMλ1Invers(3, 3), (2 * BilinMλ1Invers(1, 2)), (2 * BilinMλ1Invers(1, 3)), (2 * BilinMλ1Invers(2, 3))}
KSλ1: (KSKoeffλ1(1) * x^(2)) + (KSKoeffλ1(2) * y^(2)) + KSKoeffλ1(3) + ((KSKoeffλ1(4) * x) * y) + (KSKoeffλ1(5) * x) + (KSKoeffλ1(6) * y) = 0
KSKoeffλ2: {BilinMλ2Invers(1, 1), BilinMλ2Invers(2, 2), BilinMλ2Invers(3, 3), (2 * BilinMλ2Invers(1, 2)), (2 * BilinMλ2Invers(1, 3)), (2 * BilinMλ2Invers(2, 3))}
KSλ2: (KSKoeffλ2(1) * x^(2)) + (KSKoeffλ2(2) * y^(2)) + KSKoeffλ2(3) + ((KSKoeffλ2(4) * x) * y) + (KSKoeffλ2(5) * x) + (KSKoeffλ2(6) * y) = 0
BPList1: {(BilinMλ1 * A1), (BilinMλ1 * A2), (BilinMλ1 * A3), (BilinMλ1 * A4)}
BPList2: {(BilinMλ2 * A1), (BilinMλ2 * A2), (BilinMλ2 * A3), (BilinMλ2 * A4)}
BPktList1 = Zip((x(p) / z(p), y(p) / z(p)), p, BPList1)
BPktList2 = Zip((x(p) / z(p), y(p) / z(p)), p, BPList2)

Tool: PktzuPolare
Punkt_Kegelschschnitt_auswählen
Input: D, c
Output: d_D

L_1 = Coefficients(c)
SAdj: {{Element[L_1, 1], (1 / 2 * Element[L_1, 4]), (1 / 2 * Element[L_1, 5])}, {(1 / 2 * Element[L_1, 4]), Element[L_1, 2], (1 / 2 * Element[L_1, 6])}, {(1 / 2 * Element[L_1, 5]), (1 / 2 * Element[L_1, 6]), Element[L_1, 3]}}
d_D: (ApplyMatrix[SAdj, (x(D), y(D), 1)] * (x, y, 1)) = 0

Tool: GeradeZuPol
Gerade_Kegelschnitt_auswählen
Input: f, c
Output: Pol_F

L_1 = Coefficients(c)
SAdj: {{Element[L_1, 1], (1 / 2 * Element[L_1, 4]), (1 / 2 * Element[L_1, 5])}, {(1 / 2 * Element[L_1, 4]), Element[L_1, 2], (1 / 2 * Element[L_1, 6])}, {(1 / 2 * Element[L_1, 5]), (1 / 2 * Element[L_1, 6]), Element[L_1, 3]}}
SAdjInvers = Invert(SAdj)
F_f = ApplyMatrix(SAdjInvers, (x(f), y(f), z(f)))
Pol_F: (x(F_f) / z(F_f), y(F_f) / z(F_f))

Tool: MittelLotKreis
Punkte A,B und Punkt C markieren
Input: A, B, C
Output: ML

MAB = Midpoint(A, B)
c = Circle(MAB, B)
f = Line(A, B)
C' = Mirror(C, c)
C'_1 = Mirror(C, f)
g = LineBisector(A, B)
C'_2 = Mirror(C, g)
ML = If(C ≟ C'_2, LineBisector[A, B], If[C ≟ C', Circle[Intersect[Tangent[C, c], f], C], If[C ≟ C'_1, Circle[Midpoint[C, C'], C], Circle[C, C', C'_1]]])

Tool: ParabolicKreisDurchPkt
Punkt auf Gerade und Punkt markieren
Input: A, f, C
Output: Pk

g = OrthogonalLine(A, f)
C' = Mirror(C, f)
C'_1 = Mirror(C, g)
Pk = If(C ≟ C', f, If[C ≟ C'_1, Circle[Midpoint[C, A], C], Circle[A, C, C'_1]])

Tool: LotParabolischAufKreis
Punkt auf Gerade und Kreis markieren
Input: A, f, c
Output: Lk

g = OrthogonalLine(A, f)
A' = Mirror(A, c)
A'' = Mirror(A', f)
A''_1 = Mirror(A', g)
Lk = If(A ≠ A', If[A'' ≟ A', f, If[A' ≟ A''_1, Circle[Midpoint[A, A'], A], Circle[A, A', A''_1]]])

Tool: LotHyperbolischAufKreis
2 Punkte und einen Kreis markieren
Input: A, B, c
Output: Lk

A' = Mirror(A, c)
B' = Mirror(B, c)
Lk = If(A ≠ B', If[A ≟ A', If[B ≟ B', Circle[Intersect[Tangent[A, c], Tangent[B, c]], A], Circle[A, B, B']], Circle[A, A', B]])

Tool: LotElliptischAufKreis
2 Punkte und 1 Kreis markieren
Input: A, B, c
Output: Lk

f = Line(B, A)
A' = Mirror(A, c)
B' = Mirror(B, c)
g = Line(A', B')
F = Intersect(f, g)
h = Polar(F, c)
G = Intersect(c, h, 2)
e = Circle(F, G)
Lk = If(A ≠ A' ∨ B ≠ B', If[A' ≠ B, If[A' ≟ A, Circle[A, A], If[B' ≟ B, Circle[B, B], e]]])

Tool: SymmetrieZu2ParabolischenKreisen
2 sich berührende Kreise markieren
Input: c, d
Output: SymmK, Bk, A_p

Anzahl = Length(RemoveUndefined[Unique[{Intersect[c, d]}]])
A_p = If(Anzahl ≟ 1, Intersect[c, d])
C_p = Mirror(A_p, Center[c])
D_p = Mirror(A_p, Center[d])
Bk = Circle(Midpoint[D_p, C_p], C_p)
A'_p = Mirror(A_p, Bk)
SymmK = Circle(Midpoint[A_p, A'_p], A_p)

Tool: SymmetrieZu2ElliptischenKreisen
2 sich nicht schneidende Kreise markieren
Input: d, c
Output: Orthk, Symk2, EllPkte1, EllPkte2, e, g, h, k

M_c = Center(c)
M_d = Center(d)
f = If(M_c ≟ M_d, y = y(M_c), Line[M_c, M_d])
G, H = Intersect(c, f)
I, J = Intersect(d, f)
K = Midpoint(G, I)
L = Midpoint(H, J)
M = Midpoint(G, J)
e = Circle(M, J)
g = Circle(L, J)
h = Circle(K, G)
N = Midpoint(H, I)
k = Circle(N, I)
O, P = Intersect(k, e)
i, a = Tangent(P, k)
j, b = Tangent(P, e)
l, m = AngularBisector(i, j)
Q = Intersect(m, f)
R = Intersect(l, f)
p = Circle(Q, P)
q = Circle(R, P)
U, V = Intersect(g, h)
n = Tangent(V, g)
r = Tangent(V, h)
s, t = AngularBisector(n, r)
W = Intersect(t, f)
c_1 = Circle(W, V)
Z = Intersect(f, s)
d_1 = Circle(Z, V)
Orthk = If(M_c ≟ M_d, x = x(M_c), If[Defined[c_1], If[Length[{Intersect[c_1, c]}] < 2, d_1, c_1], If[Length[{Intersect[p, c]}] < 2, q, p]])
Symk2 = If(Radius[c] ≟ Radius[d], LineBisector[M_c, M_d], If[Defined[c_1], If[Length[{Intersect[c_1, c]}] < 2, c_1, d_1], If[Length[{Intersect[p, c]}] < 2, p, q]])
EllPkte1 = If(M_c ≠ M_d, Intersect[Orthk, f, 1])
EllPkte2 = If(M_c ≠ M_d, Intersect[Orthk, f, 2])

Tool: SymmetrieZu2HyperbolischenKreisen
2 sich schneidende Kreise markieren
Input: d, c
Output: k, e, E, F

E, F = Intersect(c, d)
f = Line(Center[c], Center[d])
g = Tangent(E, c)
h = Tangent(E, d)
i, j = AngularBisector(h, g)
G = If(Defined[Intersect[((-(x(i) / y(i))) * x) - z(i) / y(i), f]], Intersect[((-(x(i) / y(i))) * x) - z(i) / y(i), f])
H = If(Defined[Intersect[f, j]], Intersect[f, j])
e = If(¬Defined[H], Line[E, F], Circle[H, E])
k = If(¬Defined[G], Line[E, F], Circle[G, E])

Tool: tangentCirclesTo1Pt2ParabolicCircles
Pkt und 2 sich beruehrende Kreise markieren
Input: D, d, c
Output: p, k, H, G, G', H', E, e

e, g, E = SymmetrieZu2ParabolischenKreisen(d, c)
D' = Mirror(D, e)
D'_1 = Mirror(D, d)
D'' = Mirror(D', d)
h = Line(D', D)
i = Line(D'', D'_1)
F = Intersect(h, i)
j = Polar(F, d)
G, H = Intersect(d, j)
H' = Mirror(H, e)
G' = Mirror(G, e)
k = Circle(D, G, D')
p = Circle(D, D', H)

Tool: tangentCirclesTo1Pt2HyperbolicCircles
1 pt 2 hyperbolic circles
Input: E, d, c
Output: f, e, G, F, Bk2, Bk1, BP1, BP1', BP2, BP2'

E'_3 = Mirror(E, d)
E'_1 = Mirror(E, d)
e, f, F, G = SymmetrieZu2HyperbolischenKreisen(c, d)
E'_2 = Mirror(E, f)
l = Line(E'_2, E)
K = Mirror(E'_2, d)
j = Line(K, E'_3)
L = Intersect(j, l)
m = Polar(L, d)
M, N = Intersect(d, m)
E' = Mirror(E, e)
g = Line(E', E)
E'' = Mirror(E', d)
h = Line(E'', E'_1)
H = Intersect(h, g)
i = Polar(H, d)
I, J = Intersect(d, i)
BP1 = If(Defined[I], I, N)
BP2 = If(Defined[J], J, M)
BP1' = If(Defined[I], Mirror[BP1, e], Mirror[BP1, f])
BP2' = If(Defined[J], Mirror[BP2, e], Mirror[BP2, f])
Bk1 = Circle(BP1, BP1', E)
Bk2 = Circle(BP2, BP2', E)

Tool: crossratioC
Input: A, B, C, D
Output: TextCR, CR

z_A: x(A) + (ί * y(A))
z_C: x(C) + (ί * y(C))
z_B: x(B) + (ί * y(B))
z_D: x(D) + (ί * y(D))
CR: ((z_A - z_C) / (z_B - z_C) * (z_B - z_D) / (z_A - z_D))
TextCR: "CR(" + (Name[A]) + "," + (Name[B]) + "," + (Name[C]) + "," + (Name[D]) + ") = " + (LaTeX[CR]) + ""

Tool: TangentCirclesTo1Pt2EllipticCircles
1 point 2 elliptic circles
Input: P, c, d
Output: c_1, d_1, f, q, r, s, t, F, G, J, J', K, K', M, M'', N, P', H

e, f, F, G, g, h, k, p = SymmetrieZu2ElliptischenKreisen(c, d)
q = Circle(G, F, P)
i = Tangent(G, q)
j = Tangent(F, q)
E = Intersect(i, j)
r = Circle(E, F)
P' = Mirror(P, f)
P'_1 = Mirror(P, r)
H = Mirror(P'_1, f)
P'' = Mirror(P', d)
P'_2 = Mirror(P, d)
l = Line(P', P)
m = Line(P'', P'_2)
I = Intersect(l, m)
n = Polar(I, d)
J, K = Intersect(d, n)
J' = Mirror(J, f)
K' = Mirror(K, f)
s = Circle(P, J, P')
t = Circle(P, K, P')
H' = Mirror(H, d)
a = Line(P, H)
b = Line(H', P'_2)
L = Intersect(a, b)
f_1 = Polar(L, d)
M, N = Intersect(d, f_1)
c_1 = Circle(P, H, M)
d_1 = Circle(P, H, N)
M' = Mirror(M, f)
M'' = Mirror(M', r)

Tool: SymmetricCircleTo2EllipticCircles
Input: 2 elliptic circles
Input: d, c
Output: EllPkte1, EllPkte2, Symk2

M_c = Center(c)
M_d = Center(d)
f = If(M_c ≟ M_d, y = y(M_c), Line[M_c, M_d])
G, H = Intersect(c, f)
I, J = Intersect(d, f)
K = Midpoint(G, I)
L = Midpoint(H, J)
M = Midpoint(G, J)
e = Circle(M, J)
g = Circle(L, J)
h = Circle(K, G)
N = Midpoint(H, I)
k = Circle(N, I)
O, P = Intersect(k, e)
i, a = Tangent(P, k)
j, b = Tangent(P, e)
l, m = AngularBisector(i, j)
Q = Intersect(m, f)
R = Intersect(l, f)
p = Circle(Q, P)
q = Circle(R, P)
U, V = Intersect(g, h)
n = Tangent(V, g)
r = Tangent(V, h)
s, t = AngularBisector(n, r)
W = Intersect(t, f)
c_1 = Circle(W, V)
Z = Intersect(f, s)
d_1 = Circle(Z, V)
Orthk = If(M_c ≟ M_d, x = x(M_c), If[Defined[c_1], If[Length[{Intersect[c_1, c]}] < 2, d_1, c_1], If[Length[{Intersect[p, c]}] < 2, q, p]])
Symk2 = If(Radius[c] ≟ Radius[d], LineBisector[M_c, M_d], If[Defined[c_1], If[Length[{Intersect[c_1, c]}] < 2, c_1, d_1], If[Length[{Intersect[p, c]}] < 2, p, q]])
EllPkte1 = If(M_c ≠ M_d, Intersect[Orthk, f, 1])
EllPkte2 = If(M_c ≠ M_d, Intersect[Orthk, f, 2])

Tool: conic4PtsAnd1PtOnTangentInP1
4Pts plus 1Pt On Tangent in P1
Input: A1, A2, A3, A4, A5
Output: KS

B5: A5 + (0, 0, 1)
B3: A3 + (0, 0, 1)
C3: {x(B3), y(B3), z(B3)}
B1: A1 + (0, 0, 1)
g: B1 ⊗ B5
C1: {x(B1), y(B1), z(B1)}
B4: A4 + (0, 0, 1)
C4: {x(B4), y(B4), z(B4)}
B2: A2 + (0, 0, 1)
C2: {x(B2), y(B2), z(B2)}
g34: B3 ⊗ B4
g13: B1 ⊗ B3
g12: B1 ⊗ B2
g24: B2 ⊗ B4
μ: ((-((g * B2))) * Determinant[{C1, C3, C4}])
λ: ((g * B3) * Determinant[{C1, C2, C4}])
S(x, y) = ((((λ * g12) * (x, y, 1)) * g34) * (x, y, 1)) + ((((μ * g13) * (x, y, 1)) * g24) * (x, y, 1))
KS: S(x, y) = 0

Tool: conic4Tang1PtOn_g1
4 Geraden und 1 Pkt auf g1 markieren
Input: g_1, g_2, g_3, g_4, Q
Output: e41

vg_1: (x(g_1), y(g_1), z(g_1))
vg_2: (x(g_2), y(g_2), z(g_2))
vg_3: (x(g_3), y(g_3), z(g_3))
vg_4: (x(g_4), y(g_4), z(g_4))
vQ: (x(Q), y(Q), 1)
P12: vg_1 ⊗ vg_2
P13: vg_1 ⊗ vg_3
P24: vg_2 ⊗ vg_4
P34: vg_3 ⊗ vg_4
P23: vg_2 ⊗ vg_3
vgQ: vQ ⊗ P23
λ: ((P13 * vgQ) * (P24 * vg_1))
μ: ((-((P12 * vgQ))) * (P34 * vg_1))
m41 = Zip(Zip[(λ * ((((P12 * u) * P34) * v) + (((P12 * v) * P34) * u))) + (μ * ((((P13 * u) * P24) * v) + (((P13 * v) * P24) * u))), u, {(1, 0, 0), (0, 1, 0), (0, 0, 1)}], v, {(1, 0, 0), (0, 1, 0), (0, 0, 1)})
M41 = Invert(m41 / 1000)
e41: (M41(1, 1) * x^(2)) + (((2 * M41(1, 2)) * x) * y) + (M41(2, 2) * y^(2)) + ((2 * M41(1, 3)) * x) + ((2 * M41(2, 3)) * y) + M41(3, 3) = 0

Tool: conic4PtsAnd1PtOnTangentInP1 (command conic4PtsAnd1PtOnTangentInP11)
4Pts plus 1Pt On Tangent in P1
Input: A1, A2, A3, A4, A5
Output: KS

B5: A5 + (0, 0, 1)
B3: A3 + (0, 0, 1)
C3: {x(B3), y(B3), z(B3)}
B1: A1 + (0, 0, 1)
g: B1 ⊗ B5
C1: {x(B1), y(B1), z(B1)}
B4: A4 + (0, 0, 1)
C4: {x(B4), y(B4), z(B4)}
B2: A2 + (0, 0, 1)
C2: {x(B2), y(B2), z(B2)}
g34: B3 ⊗ B4
g13: B1 ⊗ B3
g12: B1 ⊗ B2
g24: B2 ⊗ B4
μ: ((-((g * B2))) * Determinant[{C1, C3, C4}])
λ: ((g * B3) * Determinant[{C1, C2, C4}])
S(x, y) = ((((λ * g12) * (x, y, 1)) * g34) * (x, y, 1)) + ((((μ * g13) * (x, y, 1)) * g24) * (x, y, 1))
KS: S(x, y) = 0

Tool: conic3Pts2TangentsInPt1Pt2
conic3Pts2TangentsInPt1Pt2[ <Punkt>, <Punkt>, <Punkt>, <Gerade>, <Gerade> ]
Input: A, B, C, g, f
Output: c

P = Intersect(f, g)
h = Line(A, C)
i = Line(B, C)
M = Point(i)
j = Line(P, M)
N = Intersect(h, j)
k = Line(B, N)
l = Line(A, M)
E = Intersect(k, l)
c = conic4PtsAnd1PtOnTangentInP1(B, E, C, A, P)

Tool: conic4Tang1PtOn_g1 (command conic4Tang1PtOn_g11)
4 Geraden und 1 Pkt auf g1 markieren
Input: g_1, g_2, g_3, g_4, Q
Output: e41

vg_1: (x(g_1), y(g_1), z(g_1))
vg_2: (x(g_2), y(g_2), z(g_2))
vg_3: (x(g_3), y(g_3), z(g_3))
vg_4: (x(g_4), y(g_4), z(g_4))
vQ: (x(Q), y(Q), 1)
P12: vg_1 ⊗ vg_2
P13: vg_1 ⊗ vg_3
P24: vg_2 ⊗ vg_4
P34: vg_3 ⊗ vg_4
P23: vg_2 ⊗ vg_3
vgQ: vQ ⊗ P23
λ: ((P13 * vgQ) * (P24 * vg_1))
μ: ((-((P12 * vgQ))) * (P34 * vg_1))
m41 = Zip(Zip[(λ * ((((P12 * u) * P34) * v) + (((P12 * v) * P34) * u))) + (μ * ((((P13 * u) * P24) * v) + (((P13 * v) * P24) * u))), u, {(1, 0, 0), (0, 1, 0), (0, 0, 1)}], v, {(1, 0, 0), (0, 1, 0), (0, 0, 1)})
M41 = Invert(m41 / 1000)
e41: (M41(1, 1) * x^(2)) + (((2 * M41(1, 2)) * x) * y) + (M41(2, 2) * y^(2)) + ((2 * M41(1, 3)) * x) + ((2 * M41(2, 3)) * y) + M41(3, 3) = 0

Tool: conic3Tang2PtsTangentOnT1T2
3 Geraden 2Pkte auf g1,g2
Input: g_1, g_2, g_3, Q_1, Q_2
Output: c

M: (1 / 2 * (Q_1 + Q_2))
P23 = Intersect(g_2, g_3)
P13 = Intersect(g_1, g_3)
g = Line(P23, M)
S = Intersect(g_1, g)
h = Line(P13, M)
P = Intersect(g_2, h)
g_4 = Line(P, S)
c = conic4Tang1PtOn_g1(g_1, g_4, g_2, g_3, Q_1)

Tool: SymmetryCircleLineHyp
Circle + Line Hyperbolisch
Input: c, f
Output: d, e, E, D

D, E = Intersect(c, f)
g = Diameter(f, c)
C, F = Intersect(c, g)
d = Circle(F, D)
e = Circle(C, D)

Tool: SymmetryCircleLineNoCut
Circle + Line
Input: c, g
Output: e, I, H

c = Kreis(A,B)

g = Gerade(C,D)

f = KonjugierterDurchmesser(g, c)

h = Polare(E, c)

d = Kreis(E, F)

H =Schneide(d, f)

I = Schneide(d, f)

f = Diameter(g, c)
E = Intersect(g, f)
h = Polar(E, c)
F, G = Intersect(c, h)
d = Circle(E, F)
H, I = Intersect(d, f)
J, K = Intersect(c, f)
P = If(abs(J - E) > abs(K - E), J, K)
i = Polar(P, d)
L, M = Intersect(d, i)
e = Circle(P, M)

Tool: SymmetrieZu2HyperbolischenKreisen (command SymmetrieZu2HyperbolischenKreisen1)
2 sich schneidende Kreise markieren
Input: d, c
Output: k, e, E, F

E, F = Intersect(c, d)
f = Line(Center[c], Center[d])
g = Tangent(E, c)
h = Tangent(E, d)
i, j = AngularBisector(h, g)
G = If(Defined[Intersect[((-(x(i) / y(i))) * x) - z(i) / y(i), f]], Intersect[((-(x(i) / y(i))) * x) - z(i) / y(i), f])
H = If(Defined[Intersect[f, j]], Intersect[f, j])
e = If(¬Defined[H], Line[E, F], Circle[H, E])
k = If(¬Defined[G], Line[E, F], Circle[G, E])

Tool: SymmetricCircleTo2EllipticCircles (command SymmetricCircleTo2EllipticCircles1)
Input: 2 elliptic circles
Input: d, c
Output: EllPkte1, EllPkte2, Symk2

M_c = Center(c)
M_d = Center(d)
f = If(M_c ≟ M_d, y = y(M_c), Line[M_c, M_d])
G, H = Intersect(c, f)
I, J = Intersect(d, f)
K = Midpoint(G, I)
L = Midpoint(H, J)
M = Midpoint(G, J)
e = Circle(M, J)
g = Circle(L, J)
h = Circle(K, G)
N = Midpoint(H, I)
k = Circle(N, I)
O, P = Intersect(k, e)
i, a = Tangent(P, k)
j, b = Tangent(P, e)
l, m = AngularBisector(i, j)
Q = Intersect(m, f)
R = Intersect(l, f)
p = Circle(Q, P)
q = Circle(R, P)
U, V = Intersect(g, h)
n = Tangent(V, g)
r = Tangent(V, h)
s, t = AngularBisector(n, r)
W = Intersect(t, f)
c_1 = Circle(W, V)
Z = Intersect(f, s)
d_1 = Circle(Z, V)
Orthk = If(M_c ≟ M_d, x = x(M_c), If[Defined[c_1], If[Length[{Intersect[c_1, c]}] < 2, d_1, c_1], If[Length[{Intersect[p, c]}] < 2, q, p]])
Symk2 = If(Radius[c] ≟ Radius[d], LineBisector[M_c, M_d], If[Defined[c_1], If[Length[{Intersect[c_1, c]}] < 2, c_1, d_1], If[Length[{Intersect[p, c]}] < 2, p, q]])
EllPkte1 = If(M_c ≠ M_d, Intersect[Orthk, f, 1])
EllPkte2 = If(M_c ≠ M_d, Intersect[Orthk, f, 2])

Tool: FourPtsToSymmetryCircles2
FourPtsToSymmetryCircles2[ <Punkt>, <Punkt>, <Punkt>, <Punkt> ]
Input: C, B, A, D
Output: kEll, kHyp_1, kHyp_2, ON_0, ON_1, ON_i, ON_{-1}, ON_{-i}, ON_∞

c = Circle(C, B, A)
h = LineBisector(A, B)
k_{ABC} = Circle(B, A, C)
f = Tangent(A, k_{ABC})
wKonzyklisch: Circle[A, B, C] ≟ Circle[A, B, D]
k_{ABD} = Circle(B, A, D)
g = Tangent(A, k_{ABD})
i, j = AngularBisector(g, f)
M_{ABS1} = Intersect(j, h)
k_{ABS2} = Circle(M_{ABS1}, A)
M_{ABS2} = Intersect(i, h)
k_{ABS1} = Circle(M_{ABS2}, A)
k_{CDA} = Circle(C, D, A)
l = Tangent(D, k_{CDA})
AltkHypACBD_1, AltkHypACBD_2, AltkHypACBD_3, AltkHypACBD_4 = SymmetrieZu2HyperbolischenKreisen(Circle[Intersect[Tangent[A, Circle[A, B, C]], Tangent[C, Circle[A, B, C]]], A], Circle[Intersect[Tangent[B, Circle[A, B, C]], Tangent[D, Circle[A, B, D]]], B])
wAltHypACBD: wKonzyklisch ∧ Defined[AltkHypACBD_1]
AltkHypADBC_1, AltkHypADBC_2, AltkHypADBC_3, AltkHypADBC_4 = SymmetrieZu2HyperbolischenKreisen(Circle[Intersect[Tangent[A, Circle[A, B, C]], Tangent[D, Circle[A, B, D]]], A], Circle[Intersect[Tangent[B, Circle[A, B, C]], Tangent[C, Circle[A, B, C]]], B])
AltkHypABCD_1, AltkHypABCD_2, AltkHypABCD_3, AltkHypABCD_4 = SymmetrieZu2HyperbolischenKreisen(Circle[Intersect[Tangent[A, Circle[A, B, C]], Tangent[B, Circle[A, B, C]]], A], Circle[Intersect[Tangent[C, Circle[A, B, C]], Tangent[D, Circle[A, B, D]]], C])
wAltHypABCD: wKonzyklisch ∧ Defined[AltkHypABCD_1]
AltkHyp_2 = If(wKonzyklisch, If[wAltHypABCD, AltkHypABCD_2, If[wAltHypACBD, AltkHypACBD_2, AltkHypADBC_2]])
k_{CDB} = Circle(C, D, B)
k = Tangent(D, k_{CDB})
m, n = AngularBisector(l, k)
p = LineBisector(C, D)
M_{CDS2} = Intersect(m, p)
k_{CDS2} = Circle(M_{CDS2}, D)
SPkt22_1 = Intersect(k_{CDS2}, k_{ABS2}, 1)
wAB2CD2: ¬Defined[SPkt22_1]
kHypAB1CD1_1, kHypAB1CD1_2, O, P = SymmetrieZu2HyperbolischenKreisen(k_{CDS2}, k_{ABS2})
SPkt12_1, SPkt12_2 = Intersect(k_{CDS2}, k_{ABS1})
wAB1CD2: ¬Defined[SPkt12_1]
kHypAB2CD1_1, kHypAB2CD1_2, I, J = SymmetrieZu2HyperbolischenKreisen(k_{CDS2}, k_{ABS1})
M_{CDS1} = Intersect(n, p)
k_{CDS1} = Circle(M_{CDS1}, D)
SPkt21_1, SPkt21_2 = Intersect(k_{CDS1}, k_{ABS2})
wAB2CD1: ¬Defined[SPkt21_1]
kHypAB1CD2_2, kHypAB1CD2_1, G, H = SymmetrieZu2HyperbolischenKreisen(k_{ABS2}, k_{CDS1})
SPkt11_1 = Intersect(k_{ABS1}, k_{CDS1}, 1)
wAB1CD1: ¬Defined[SPkt11_1]
kHypAB2CD2_1, kHypAB2CD2_2, I_1, J_1 = SymmetrieZu2HyperbolischenKreisen(k_{ABS1}, k_{CDS1})
AltkHyp_1 = If(wKonzyklisch, If[wAltHypABCD, AltkHypABCD_1, If[wAltHypACBD, AltkHypACBD_1, AltkHypADBC_1]])
G_1, H_1, kEll22 = SymmetricCircleTo2EllipticCircles(k_{ABS2}, k_{CDS2})
E, F, kEll12 = SymmetricCircleTo2EllipticCircles(k_{CDS2}, k_{ABS1})
W, Z, kEll21 = SymmetricCircleTo2EllipticCircles(k_{ABS2}, k_{CDS1})
M, N, kEll11 = SymmetricCircleTo2EllipticCircles(k_{CDS1}, k_{ABS1})
kEll = If(wKonzyklisch, Circle[A, B, C], If[wAB1CD1, kEll11, If[wAB1CD2, kEll12, If[wAB2CD1, kEll21, If[wAB2CD2, kEll22]]]])
kHyp_1 = If(wKonzyklisch, AltkHyp_1, If[wAB1CD1, kHypAB1CD1_1, If[wAB1CD2, kHypAB1CD2_1, If[wAB2CD1, kHypAB2CD1_1, If[wAB2CD2, kHypAB2CD2_1]]]])
kHyp_2 = If(wKonzyklisch, AltkHyp_2, If[wAB1CD1, kHypAB1CD1_2, If[wAB1CD2, kHypAB1CD2_2, If[wAB2CD1, kHypAB2CD1_2, If[wAB2CD2, kHypAB2CD2_2]]]])
ON_i, ON_{-i} = Intersect(kHyp_2, kHyp_1)
ON_1, ON_{-1} = Intersect(kEll, kHyp_2)
ON_∞, ON_0 = Intersect(kHyp_1, kEll)

Tool: MittelLotKreis (command MittelLotKreis1)
Punkte A,B und Punkt C markieren
Input: A, B, C
Output: ML

MAB = Midpoint(A, B)
c = Circle(MAB, B)
f = Line(A, B)
C' = Mirror(C, c)
C'_1 = Mirror(C, f)
g = LineBisector(A, B)
C'_2 = Mirror(C, g)
ML = If(C ≟ C'_2, LineBisector[A, B], If[C ≟ C', Circle[Intersect[Tangent[C, c], f], C], If[C ≟ C'_1, Circle[Midpoint[C, C'], C], Circle[C, C', C'_1]]])

Tool: ApolloniosTetraeder
3Points
Input: A, B, C
Output: c, d, e, D, E

c = MittelLotKreis(A, B, C)
d = MittelLotKreis(B, C, A)
e = MittelLotKreis(C, A, B)
D, E = Intersect(e, c)

Tool: SymmetrieZu2ParabolischenKreisenNeu
2 sich berührende Kreise markieren
Input: d, c
Output: SymmK, A_p

Anzahl = Length(RemoveUndefined[Unique[{Intersect[c, d]}]])
A_p = If(Anzahl ≟ 1, Intersect[c, d])
C_p = Mirror(A_p, Center[c])
D_p = Mirror(A_p, Center[d])
Bk = Circle(Midpoint[D_p, C_p], C_p)
A'_p = Mirror(A_p, Bk)
SymmK = Circle(Midpoint[A_p, A'_p], A_p)

Tool: SymmetrieLineTangentCircle
line TangentCircle
Input: g, d
Output: kSym, SP

E = Intersect(g, g_1)
FP = Intersect(OrthogonalLine[Center[d], g], g)
BP_1 = Intersect(d, OrthogonalLine[Center[d], g], 1)
BP_2 = Intersect(d, OrthogonalLine[Center[d], g], 2)
M_s = If(BP_1 ≟ FP, BP_2, If[BP_2 ≟ FP, BP_1])
kSym = Circle(M_s, FP)
SP = If(Defined[kSym], FP)