math-exercises 2.2.68 → 2.2.70

package/lib/math/geometry/triangle.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"triangle.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/triangle.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAoB,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAQpE,OAAO,EAAE,QAAQ,EAAE,MAAM,qCAAqC,CAAC;AAI/D,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAGpC,MAAM,MAAM,mBAAmB,GAAG;IAChC,OAAO,EAAE,gBAAgB,CAAC;IAC1B,OAAO,EAAE,gBAAgB,CAAC;IAC1B,OAAO,EAAE,gBAAgB,CAAC;CAC3B,CAAC;AACF,8BAAsB,mBAAmB;IACvC,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,mBAAmB,GAAG,QAAQ;IAOlE,MAAM,CAAC,yBAAyB,CAAC,EAC/B,UAAc,EACd,UAAc,EACd,KAAuB,GACxB;;;;KAAA,GAAG,QAAQ;IAkBZ,MAAM,CAAC,oBAAoB,CAAC,EAC1B,QAAe,EACf,QAAc,EACd,KAAuB,GACxB;;;;KAAA,GAAG,QAAQ;IAsCZ,MAAM,CAAC,UAAU;CAQlB;AAED,KAAK,qBAAqB,GAAG;IAC3B,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IACvB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB,CAAC;AAEF,qBAAa,QAAQ;IACnB,OAAO,EAAE,KAAK,CAAC;IACf,OAAO,EAAE,KAAK,CAAC;IACf,OAAO,EAAE,KAAK,CAAC;gBAEH,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK;IAK1D,WAAW;IAOX,eAAe;IAGf,eAAe;IAGf,eAAe;IAGf,aAAa,IAAI,mBAAmB;IAQpC,cAAc,IAAI,MAAM;IAOxB,cAAc,IAAI,MAAM;IAOxB,cAAc,IAAI,MAAM;IAIxB,eAAe,IAAI,MAAM;IAIzB,YAAY;IAeZ,YAAY;IAeZ,YAAY;IAeZ,SAAS,IAAI,MAAM;IASnB,SAAS,IAAI,MAAM;IASnB,SAAS,IAAI,MAAM;IASnB,YAAY,IAAI,MAAM;IAMtB,OAAO,IAAI,MAAM;IAUjB,OAAO,IAAI,OAAO;IAOlB,aAAa,IAAI,OAAO;IAOxB,WAAW,IAAI,OAAO;IAQtB,SAAS,IAAI,OAAO;IAQpB,aAAa,IAAI,MAAM;IAOvB,gBAAgB,CAAC,EACf,gBAAgB,EAAE,gBAAgB,EAClC,qBAAqB,EAAE,qBAAqB,EAC5C,UAAU,EAAE,UAAU,EACtB,WAAW,EAAE,WAAW,EACxB,eAAe,EAAE,eAAe,EAChC,oBAAoB,EAAE,oBAAoB,GAC3C,EAAE,qBAAqB,GAAG,MAAM,EAAE;IAoEnC,cAAc,IAAI,MAAM,EAAE;IAyB1B,YAAY,IAAI,MAAM;IAItB,YAAY,IAAI,MAAM;IAItB,YAAY,IAAI,MAAM;CAGvB"}
+{"version":3,"file":"triangle.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/triangle.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAoB,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAEpE,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAKhC,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAC/D,OAAO,EAEL,eAAe,EAEhB,MAAM,kCAAkC,CAAC;AAE1C,MAAM,MAAM,mBAAmB,GAAG;IAChC,MAAM,EAAE,gBAAgB,EAAE,CAAC;IAC3B,KAAK,CAAC,EAAE,wBAAwB,CAAC;CAClC,CAAC;AAEF,8BAAsB,mBAAmB;IACvC,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,mBAAmB,GAAG,QAAQ;IAgBlE,MAAM,CAAC,eAAe,CAAC,EACrB,KAAuB,EACvB,UAAkB,GACnB;;;KAAA,GAAG,QAAQ;IA8BZ,MAAM,CAAC,UAAU;CAQlB;AAED,MAAM,MAAM,wBAAwB,GAAG;IACrC,YAAY,CAAC,EAAE,CAAC,eAAe,GAAG,SAAS,CAAC,EAAE,CAAC;IAC/C,kBAAkB,CAAC,EAAE,eAAe,EAAE,CAAC;IACvC,kBAAkB,CAAC,EAAE,eAAe,EAAE,CAAC;CACxC,CAAC;AACF,MAAM,MAAM,aAAa,GAAG;IAC1B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,YAAY,CAAC,EAAE,CAAC,aAAa,GAAG,SAAS,CAAC,EAAE,CAAC;IAC7C,kBAAkB,CAAC,EAAE,aAAa,EAAE,CAAC;IACrC,kBAAkB,CAAC,EAAE,aAAa,EAAE,CAAC;CACtC,CAAC;AACF,qBAAa,QAAQ;IACnB,MAAM,EAAE,KAAK,EAAE,CAAC;IAChB,MAAM,EAAE,KAAK,EAAE,CAAC;IAChB,KAAK,EAAE,OAAO,EAAE,CAAC;IACjB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,aAAa,CAAC;gBACV,MAAM,EAAE,KAAK,EAAE,EAAE,KAAK,CAAC,EAAE,aAAa;IAyClD,aAAa,IAAI,mBAAmB;IAepC,mDAAmD;IACnD;;;OAGG;IACH,uDAAuD;IACvD,YAAY,IAAI,MAAM;IAItB,OAAO,IAAI,MAAM;IASjB,OAAO,IAAI,OAAO;IAIlB,aAAa,IAAI,OAAO;IAMxB,WAAW,IAAI,OAAO;IAUtB,SAAS,IAAI,OAAO;IASpB,aAAa,CACX,KAAK,EAAE,MAAM,EACb,IAAI,EAAE;QACJ,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,OAAO,CAAC,EAAE,MAAM,CAAC;KAClB;IAWH,cAAc,CACZ,KAAK,EAAE,MAAM,EACb,IAAI,CAAC,EAAE;QACL,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,SAAS,CAAC,EAAE,OAAO,CAAC;KACrB;IAKH,eAAe,CAAC,WAAW,CAAC,EAAE,MAAM,EAAE;IAQtC,SAAS,CACP,WAAW,EAAE,MAAM,EACnB,IAAI,CAAC,EAAE;QACL,QAAQ,CAAC,EAAE,MAAM,CAAC;KACnB;IAYH,UAAU,CACR,WAAW,EAAE,MAAM,EACnB,IAAI,CAAC,EAAE;QACL,QAAQ,CAAC,EAAE,MAAM,CAAC;KACnB;IA4BH,cAAc,IAAI,MAAM,EAAE;CAkB3B"}

package/lib/math/geometry/triangle.js

@@ -2,56 +2,46 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Triangle = exports.TriangleConstructor = void 0;
 const point_1 = require("./point");
-const substractNode_1 = require("../../tree/nodes/operators/substractNode");
-const powerNode_1 = require("../../tree/nodes/operators/powerNode");
-const addNode_1 = require("../../tree/nodes/operators/addNode");
-const numberNode_1 = require("../../tree/nodes/numbers/numberNode");
-const sqrtNode_1 = require("../../tree/nodes/functions/sqrtNode");
-const randint_1 = require("../utils/random/randint");
 const randomLetter_1 = require("../../utils/strings/randomLetter");
 const segment_1 = require("./segment");
-const multiplyNode_1 = require("../../tree/nodes/operators/multiplyNode");
+const angle_1 = require("./angle");
+const rotation_1 = require("../../utils/arrays/rotation");
+const round_1 = require("../utils/round");
+const randfloat_1 = require("../utils/random/randfloat");
+const line_1 = require("./line");
+const nodeConstructor_1 = require("../../tree/nodes/nodeConstructor");
 class TriangleConstructor {
     static fromIdentifiers(identifiers) {
-        return new Triangle(point_1.PointConstructor.fromIdentifiers(identifiers.vertexA), point_1.PointConstructor.fromIdentifiers(identifiers.vertexB), point_1.PointConstructor.fromIdentifiers(identifiers.vertexC));
-    }
-    static createRandomRightTriangle({ minRapport = 0, maxRapport = 5, names = ["A", "B", "C"], }) {
-        let pointA, pointB, pointC, d1, d2;
-        do {
-            const xA = (0, randint_1.randint)(-10, 11);
-            const yA = (0, randint_1.randint)(-10, 11);
-            const xB = (0, randint_1.randint)(-10, 11);
-            const yB = (0, randint_1.randint)(-10, 11);
-            pointA = new point_1.Point(names[0], new numberNode_1.NumberNode(xA), new numberNode_1.NumberNode(yA));
-            pointB = new point_1.Point(names[1], new numberNode_1.NumberNode(xB), new numberNode_1.NumberNode(yB));
-            d1 = pointA.distanceTo(pointB);
-            const xC = (0, randint_1.randint)(-11, 10);
-            const yC = yA - ((xB - xA) * (xC - xA)) / (yB - yA);
-            pointC = new point_1.Point(names[2], new numberNode_1.NumberNode(xC), new numberNode_1.NumberNode(yC));
-            d2 = pointA.distanceTo(pointC);
-        } while (!d1 || !d2 || d1 / d2 < minRapport || d1 / d2 > maxRapport);
-        return new Triangle(pointA, pointB, pointC);
-    }
-    static createRandomTriangle({ minAngle = 0.69, maxAngle = 1.5, names = ["A", "B", "C"], }) {
-        let pointA, pointB, pointC, triangle;
-        do {
-            pointA = new point_1.Point(names[0], new numberNode_1.NumberNode((0, randint_1.randint)(-10, 11)), new numberNode_1.NumberNode((0, randint_1.randint)(-10, 11)));
-            pointB = new point_1.Point(names[1], new numberNode_1.NumberNode((0, randint_1.randint)(-10, 11)), new numberNode_1.NumberNode((0, randint_1.randint)(-10, 11)));
-            pointC = new point_1.Point(names[2], new numberNode_1.NumberNode((0, randint_1.randint)(-10, 11)), new numberNode_1.NumberNode((0, randint_1.randint)(-10, 11)));
-            triangle = new Triangle(pointA, pointB, pointC);
-        } while (triangle.isRight() ||
-            //to prevent aligned
-            //shouldnt be done this way
-            (0, substractNode_1.substract)((0, multiplyNode_1.multiply)((0, substractNode_1.substract)(pointB.x, pointA.x), (0, substractNode_1.substract)(pointC.y, pointA.y)), (0, multiplyNode_1.multiply)((0, substractNode_1.substract)(pointC.x, pointA.x), (0, substractNode_1.substract)(pointB.y, pointA.y))).evaluate() === 0 ||
-            //xb-xa * yc-ya = xc-xa * yb-ya
-            pointA.distanceTo(pointB) === 0 ||
-            pointB.distanceTo(pointC) === 0 ||
-            pointC.distanceTo(pointA) === 0 ||
-            triangle.getAngleA() < minAngle ||
-            triangle.getAngleA() > maxAngle ||
-            triangle.getAngleB() < minAngle ||
-            triangle.getAngleB() > maxAngle);
-        return new Triangle(pointA, pointB, pointC);
+        return new Triangle(identifiers.points.map((p) => point_1.PointConstructor.fromIdentifiers(p)), {
+            anglesRadianValues: identifiers.props?.anglesRadianValues?.map((n) => (0, nodeConstructor_1.reifyAlgebraic)(n)),
+            anglesDegreeValues: identifiers.props?.anglesDegreeValues?.map((n) => (0, nodeConstructor_1.reifyAlgebraic)(n)),
+            sidesLengths: identifiers.props?.sidesLengths?.map((n) => n ? (0, nodeConstructor_1.reifyAlgebraic)(n) : undefined),
+        });
+    }
+    static randomNiceSides({ names = ["A", "B", "C"], randomName = false, }) {
+        let vertices = [];
+        if (randomName)
+            vertices = TriangleConstructor.randomName();
+        else
+            vertices = names;
+        const angle = (0, randfloat_1.randfloat)(0, 2 * Math.PI);
+        const addAngle = (0, randfloat_1.randfloat)(Math.PI / 4, (3 * Math.PI) / 4);
+        //on construit [AC] sur (Ox) de milieu O et de taille 2*xRand
+        //puis [AB] sur (Ox) qu'on rotate
+        const xRand = (0, randfloat_1.randfloat)(5, 8, 1);
+        const xRand2 = (0, randfloat_1.randfloat)(-5, 5, 1);
+        const origin = new point_1.Point("O", (0).toTree(), (0).toTree());
+        const startA = new point_1.Point(vertices[0], (-xRand).toTree(), (0).toTree());
+        const A = startA.rotate(angle, origin);
+        const C = new point_1.Point(vertices[2], xRand.toTree(), (0).toTree()).rotate(angle, origin);
+        const B = new point_1.Point(vertices[1], (-xRand + xRand2).toTree(), (0).toTree()).rotate(angle + addAngle, startA);
+        return new Triangle([A, B, C], {
+            sidesLengths: [
+                (0, round_1.round)(B.distanceTo(C), 1).toTree(),
+                (0, round_1.round)(A.distanceTo(C), 1).toTree(),
+                (0, round_1.round)(A.distanceTo(B), 1).toTree(),
+            ],
+        });
     }
     static randomName() {
         const startVertix = (0, randomLetter_1.randomLetter)(true, ["Y", "Z"]);
@@ -64,169 +54,152 @@ class TriangleConstructor {
 }
 exports.TriangleConstructor = TriangleConstructor;
 class Triangle {
-    constructor(vertexA, vertexB, vertexC) {
-        this.vertexA = vertexA;
-        this.vertexB = vertexB;
-        this.vertexC = vertexC;
-    }
-    getSegments() {
-        return [
-            this.getSideASegment(),
-            this.getSideBSegment(),
-            this.getSideCSegment(),
+    constructor(points, props) {
+        if (points.length !== 3)
+            throw new Error("Triangle must have 3 points");
+        this.props = props;
+        this.name = points.map((p) => p.name).join("");
+        this.points = points;
+        this.angles = [
+            new angle_1.Angle((0, rotation_1.arrayRotation)(points, 2), {
+                radianValueNode: props?.anglesRadianValues?.[0],
+                degreeValueNode: props?.anglesDegreeValues?.[0],
+            }),
+            new angle_1.Angle(points, {
+                radianValueNode: props?.anglesRadianValues?.[1],
+                degreeValueNode: props?.anglesDegreeValues?.[1],
+            }),
+            new angle_1.Angle((0, rotation_1.arrayRotation)(points, 1), {
+                radianValueNode: props?.anglesRadianValues?.[2],
+                degreeValueNode: props?.anglesDegreeValues?.[2],
+            }),
+        ];
+        this.sides = [
+            new segment_1.Segment(points[1], points[2], {
+                lengthNode: props?.sidesLengths?.[0],
+            }),
+            new segment_1.Segment(points[0], points[2], {
+                lengthNode: props?.sidesLengths?.[1],
+            }),
+            new segment_1.Segment(points[0], points[1], {
+                lengthNode: props?.sidesLengths?.[2],
+            }),
+        ];
+        this.commands = [
+            ...points.flatMap((p) => p.toGGBCommand({
+                isFixed: true,
+                showLabel: true,
+            })),
+            ...this.sides.flatMap((s) => s.toGGBCommands(false)),
         ];
-    }
-    getSideASegment() {
-        return new segment_1.Segment(this.vertexB, this.vertexC);
-    }
-    getSideBSegment() {
-        return new segment_1.Segment(this.vertexA, this.vertexC);
-    }
-    getSideCSegment() {
-        return new segment_1.Segment(this.vertexA, this.vertexB);
     }
     toIdentifiers() {
         return {
-            vertexA: this.vertexA.toIdentifiers(),
-            vertexB: this.vertexB.toIdentifiers(),
-            vertexC: this.vertexC.toIdentifiers(),
+            points: this.points.map((point) => point.toIdentifiers()),
+            props: {
+                anglesRadianValues: this.props?.anglesRadianValues?.map((n) => n.toIdentifiers()),
+                anglesDegreeValues: this.props?.anglesDegreeValues?.map((n) => n.toIdentifiers()),
+                sidesLengths: this.props?.sidesLengths?.map((n) => n?.toIdentifiers()),
+            },
         };
     }
-    getSideAnumber() {
-        return Math.hypot(this.vertexC.getXnumber() - this.vertexB.getXnumber(), this.vertexC.getYnumber() - this.vertexB.getYnumber());
-    }
-    getSideBnumber() {
-        return Math.hypot(this.vertexA.getXnumber() - this.vertexC.getXnumber(), this.vertexA.getYnumber() - this.vertexC.getYnumber());
-    }
-    getSideCnumber() {
-        return this.vertexA.distanceTo(this.vertexB);
-    }
-    getTriangleName() {
-        return this.vertexA.name + this.vertexB.name + this.vertexC.name;
-    }
-    getSideAnode() {
-        return new sqrtNode_1.SqrtNode(new addNode_1.AddNode(new powerNode_1.PowerNode(new substractNode_1.SubstractNode(this.vertexC.x, this.vertexB.x), new numberNode_1.NumberNode(2)), new powerNode_1.PowerNode(new substractNode_1.SubstractNode(this.vertexC.y, this.vertexB.y), new numberNode_1.NumberNode(2))));
-    }
-    getSideBnode() {
-        return new sqrtNode_1.SqrtNode(new addNode_1.AddNode(new powerNode_1.PowerNode(new substractNode_1.SubstractNode(this.vertexC.x, this.vertexA.x), new numberNode_1.NumberNode(2)), new powerNode_1.PowerNode(new substractNode_1.SubstractNode(this.vertexC.y, this.vertexA.y), new numberNode_1.NumberNode(2))));
-    }
-    getSideCnode() {
-        return new sqrtNode_1.SqrtNode(new addNode_1.AddNode(new powerNode_1.PowerNode(new substractNode_1.SubstractNode(this.vertexA.x, this.vertexB.x), new numberNode_1.NumberNode(2)), new powerNode_1.PowerNode(new substractNode_1.SubstractNode(this.vertexC.y, this.vertexB.y), new numberNode_1.NumberNode(2))));
-    }
-    getAngleA() {
-        return Math.acos((this.getSideBnumber() ** 2 +
-            this.getSideCnumber() ** 2 -
-            this.getSideAnumber() ** 2) /
-            (2 * this.getSideBnumber() * this.getSideCnumber()));
-    }
-    getAngleB() {
-        return Math.acos((this.getSideAnumber() ** 2 +
-            this.getSideCnumber() ** 2 -
-            this.getSideBnumber() ** 2) /
-            (2 * this.getSideAnumber() * this.getSideCnumber()));
-    }
-    getAngleC() {
-        return Math.acos((this.getSideAnumber() ** 2 +
-            this.getSideBnumber() ** 2 -
-            this.getSideCnumber() ** 2) /
-            (2 * this.getSideAnumber() * this.getSideBnumber()));
-    }
+    /*************  ✨ Codeium Command ⭐  *************/
+    /**
+     * Returns the perimeter of the triangle.
+     * @returns {number} the perimeter of the triangle.
+     */
+    /******  fbb7c5d7-3919-4ef2-b5ba-db0d6770666d  *******/
     getPerimeter() {
-        return (this.getSideAnumber() + this.getSideBnumber() + this.getSideCnumber());
+        return this.sides.reduce((acc, curr) => acc + curr.getLength(), 0);
     }
     getArea() {
         const s = this.getPerimeter() / 2;
-        return Math.sqrt(s *
-            (s - this.getSideAnumber()) *
-            (s - this.getSideBnumber()) *
-            (s - this.getSideCnumber()));
+        const lengths = this.sides.map((s) => s.getLength());
+        return (0, round_1.round)(Math.sqrt(s * (s - lengths[0]) * (s - lengths[1]) * (s - lengths[2])), 6);
     }
     isRight() {
-        if (Math.abs(Math.cos(this.getAngleA())) < 0.001)
-            return true;
-        if (Math.abs(Math.cos(this.getAngleB())) < 0.001)
-            return true;
-        if (Math.abs(Math.cos(this.getAngleC())) < 0.001)
-            return true;
-        return false;
+        return this.angles.some((a) => a.isRight());
     }
     isEquilateral() {
-        return (this.getSideAnumber() === this.getSideBnumber() &&
-            this.getSideAnumber() === this.getSideCnumber());
+        const lengths = this.sides.map((s) => s.getLength());
+        return lengths[0] === lengths[1] && lengths[1] === lengths[2];
     }
     isIsosceles() {
-        return (this.getSideAnumber() === this.getSideBnumber() ||
-            this.getSideAnumber() === this.getSideCnumber() ||
-            this.getSideBnumber() === this.getSideCnumber());
+        const lengths = this.sides.map((s) => s.getLength());
+        return (lengths[0] === lengths[1] ||
+            lengths[1] === lengths[2] ||
+            lengths[0] === lengths[2]);
     }
     isScalene() {
-        return (this.getSideAnumber() !== this.getSideBnumber() &&
-            this.getSideBnumber() !== this.getSideCnumber() &&
-            this.getSideCnumber() !== this.getSideAnumber());
-    }
-    getRightAngle() {
-        if (Math.abs(Math.cos(this.getAngleA())) < 0.001)
-            return this.vertexA.name;
-        if (Math.abs(Math.cos(this.getAngleB())) < 0.001)
-            return this.vertexB.name;
-        if (Math.abs(Math.cos(this.getAngleC())) < 0.001)
-            return this.vertexC.name;
-        return "";
-    }
-    generateCommands({ highlightedAngle: highlightedAngle, colorHighlightedAngle: colorHighlightedAngle, showLabels: showLabels, setCaptions: setCaptions, highlightedSide: highlightedSide, colorHighlightedSide: colorHighlightedSide, }) {
-        let commands = [
-            `${this.vertexA.name} = Point({${this.vertexA.getXnumber()}, ${this.vertexA.getYnumber()}})`,
-            `${this.vertexB.name} = Point({${this.vertexB.getXnumber()}, ${this.vertexB.getYnumber()}})`,
-            `${this.vertexC.name} = Point({${this.vertexC.getXnumber()}, ${this.vertexC.getYnumber()}})`,
-            `ShowLabel(${this.vertexA.name}, true)`,
-            `ShowLabel(${this.vertexB.name}, true)`,
-            `ShowLabel(${this.vertexC.name}, true)`,
-            `${this.getSideCName()} = Segment(${this.vertexA.name}, ${this.vertexB.name})`,
-            `${this.getSideBName()} = Segment(${this.vertexA.name}, ${this.vertexC.name})`,
-            `${this.getSideAName()} = Segment(${this.vertexC.name}, ${this.vertexB.name})`,
-            `ShowLabel(${this.getSideCName()}, false)`,
-            `ShowLabel(${this.getSideBName()}, false)`,
-            `ShowLabel(${this.getSideBName()}, false)`,
-        ];
-        if (this.isRight())
-            commands.push(`alpha = Angle(${this.vertexB.name},${this.vertexA.name},${this.vertexC.name}, Line(${this.vertexB.name},${this.vertexA.name}))`, `ShowLabel(alpha, false)`);
-        const defautColor = "Red";
-        if (highlightedAngle) {
-            let temp = [""];
-            if (highlightedAngle === this.vertexB.name)
-                temp = [this.vertexA.name, this.vertexB.name, this.vertexC.name];
-            if (highlightedAngle === this.vertexC.name)
-                temp = [this.vertexB.name, this.vertexC.name, this.vertexA.name];
-            if (highlightedAngle === this.vertexA.name)
-                temp = [this.vertexC.name, this.vertexA.name, this.vertexB.name];
-            commands.push(`be = Angle(${temp[0]}, ${temp[1]}, ${temp[2]}, Line(${temp[0]}, ${temp[1]}))`, `ShowLabel(be, false)`, `SetColor(be, "${colorHighlightedAngle ?? defautColor}")`);
+        const lengths = this.sides.map((s) => s.getLength());
+        return (lengths[0] !== lengths[1] &&
+            lengths[1] !== lengths[2] &&
+            lengths[0] !== lengths[2]);
+    }
+    highlightSide(index, opts) {
+        const side = this.sides[index];
+        if (opts.color)
+            this.commands.push(`SetColor(${side.ggbName}, "${opts.color}")`);
+        if (opts.caption) {
+            this.commands.push(...side.getFitCaptionCommands(opts.caption, opts.color));
         }
-        if (showLabels)
-            for (let i = 0; i < showLabels.length; i++) {
-                commands.push(`ShowLabel(${showLabels[i]}, true)`);
-                if (setCaptions)
-                    commands.push(`SetCaption(${showLabels[i]}, "${setCaptions[i]}")`);
-            }
-        if (highlightedSide)
-            commands.push(`SetColor(${highlightedSide}, "${colorHighlightedSide ?? defautColor}")`);
-        return commands;
     }
-    generateCoords() {
-        return [
-            Math.min(this.vertexA.getXnumber(), this.vertexB.getXnumber(), this.vertexC.getXnumber()) - 1,
-            Math.max(this.vertexA.getXnumber(), this.vertexB.getXnumber(), this.vertexC.getXnumber()) + 1,
-            Math.min(this.vertexA.getYnumber(), this.vertexB.getYnumber(), this.vertexC.getYnumber()) - 1,
-            Math.max(this.vertexA.getYnumber(), this.vertexB.getYnumber(), this.vertexC.getYnumber()) + 1,
-        ];
+    highlightAngle(index, opts) {
+        this.commands.push(...this.angles[index].toCommands(opts));
     }
-    getSideAName() {
-        return this.vertexB.name + this.vertexC.name;
+    showSidesLength(hiddenSides) {
+        this.commands.push(...this.sides
+            .filter((s, i) => !hiddenSides?.includes(i))
+            .flatMap((s) => s.getFitCaptionCommands()));
     }
-    getSideBName() {
-        return this.vertexC.name + this.vertexA.name;
+    getHeight(summitIndex, opts) {
+        const base = line_1.LineConstructor.fromSegment(this.sides[summitIndex]);
+        const perp = base.getPerpendicular(this.points[summitIndex]);
+        const foot = perp.intersect(base, opts?.footName);
+        while (this.name.includes(foot.name)) {
+            foot.name = (0, randomLetter_1.randomLetter)(true);
+        }
+        const segmentHeight = new segment_1.Segment(this.points[summitIndex], foot);
+        return segmentHeight;
+    }
+    drawHeight(summitIndex, opts) {
+        const height = this.getHeight(summitIndex, opts);
+        const foot = height.pointB;
+        const angle = new angle_1.Angle([
+            this.points[summitIndex],
+            foot,
+            this.points[(summitIndex + 1) % 3],
+        ]);
+        this.commands.push(...foot.toGGBCommand(), ...height.toGGBCommands(false, { style: 2 }), ...angle.toCommands());
+        if (!this.sides[summitIndex].includes(foot)) {
+            const distancesToSideSummits = [
+                this.sides[summitIndex].pointA,
+                this.sides[summitIndex].pointB,
+            ].map((p) => p.distanceTo(foot));
+            const closestPoint = distancesToSideSummits[0] < distancesToSideSummits[1]
+                ? this.sides[summitIndex].pointA
+                : this.sides[summitIndex].pointB;
+            const prolongement = new segment_1.Segment(closestPoint, foot);
+            this.commands.push(...prolongement.toGGBCommands(false, { style: 2 }));
+        }
     }
-    getSideCName() {
-        return this.vertexA.name + this.vertexB.name;
+    generateCoords() {
+        const coords = this.points.map((p) => [p.x.evaluate(), p.y.evaluate()]);
+        const [x1, y1, x2, y2, x3, y3] = coords.flatMap((p) => p);
+        const [xMin, xMax, yMin, yMax] = [
+            Math.min(x1, x2, x3),
+            Math.max(x1, x2, x3),
+            Math.min(y1, y2, y3),
+            Math.max(y1, y2, y3),
+        ];
+        const xDelta = Math.abs(xMax - xMin);
+        const yDelta = Math.abs(yMax - yMin);
+        return [
+            xMin - 0.1 * xDelta,
+            xMax + 0.1 * xDelta,
+            yMin - 0.1 * yDelta,
+            yMax + 0.1 * yDelta,
+        ];
     }
 }
 exports.Triangle = Triangle;

package/lib/math/geometry/vector.d.ts

@@ -1,5 +1,4 @@
 import { AlgebraicNode } from "../../tree/nodes/algebraicNode";
-import { Node } from "../../tree/nodes/node";
 import { Point } from "./point";
 export declare abstract class VectorConstructor {
     static fromPoints(origin: Point, end: Point): Vector;
@@ -17,12 +16,13 @@ export declare class Vector {
     isColinear(v: Vector): boolean;
     determinant(v: Vector): AlgebraicNode;
     times(k: AlgebraicNode, name?: string): Vector;
-    scalarProduct(v: Vector): Node;
+    scalarProduct(v: Vector): AlgebraicNode;
     add(v: Vector): Vector;
     getNorm(): AlgebraicNode;
     getEndPoint(startPoint: Point, name?: string): Point;
     equals(v: Vector): boolean;
     getXAsNumber(): number;
     getYAsNumber(): number;
+    getOrthogonal(): Vector;
 }
 //# sourceMappingURL=vector.d.ts.map

package/lib/math/geometry/vector.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vector.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/vector.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAE/D,OAAO,EAAE,IAAI,EAAY,MAAM,uBAAuB,CAAC;AAavD,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAEhC,8BAAsB,iBAAiB;IACrC,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,GAAG,MAAM;IAOpD,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,UAAO,GAAG,MAAM;CAOtD;AAED,qBAAa,MAAM;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;gBACL,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE,aAAa;IAO5D,KAAK,IAAI,MAAM;IAIf,eAAe,IAAI,MAAM;IAMzB,iBAAiB,IAAI,MAAM;IAM3B,UAAU,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO;IAI9B,WAAW,CAAC,CAAC,EAAE,MAAM,GAAG,aAAa;IAIrC,KAAK,CAAC,CAAC,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,MAAM;IAOrC,aAAa,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI;IAc9B,GAAG,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM;IAYtB,OAAO,IAAI,aAAa;IAUxB,WAAW,CAAC,UAAU,EAAE,KAAK,EAAE,IAAI,CAAC,EAAE,MAAM;IAO5C,MAAM,CAAC,CAAC,EAAE,MAAM;IAIhB,YAAY;IAMZ,YAAY;CAMb"}
+{"version":3,"file":"vector.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/vector.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAgB/D,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAEhC,8BAAsB,iBAAiB;IACrC,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,GAAG,MAAM;IAOpD,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,UAAO,GAAG,MAAM;CAOtD;AAED,qBAAa,MAAM;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;gBACL,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE,aAAa;IAO5D,KAAK,IAAI,MAAM;IAIf,eAAe,IAAI,MAAM;IAMzB,iBAAiB,IAAI,MAAM;IAM3B,UAAU,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO;IAK9B,WAAW,CAAC,CAAC,EAAE,MAAM,GAAG,aAAa;IAIrC,KAAK,CAAC,CAAC,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,MAAM;IAOrC,aAAa,CAAC,CAAC,EAAE,MAAM;IAgBvB,GAAG,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM;IAYtB,OAAO,IAAI,aAAa;IAUxB,WAAW,CAAC,UAAU,EAAE,KAAK,EAAE,IAAI,CAAC,EAAE,MAAM;IAO5C,MAAM,CAAC,CAAC,EAAE,MAAM;IAIhB,YAAY;IAMZ,YAAY;IAOZ,aAAa;CAGd"}

package/lib/math/geometry/vector.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Vector = exports.VectorConstructor = void 0;
+const oppositeNode_1 = require("../../tree/nodes/functions/oppositeNode");
 const sqrtNode_1 = require("../../tree/nodes/functions/sqrtNode");
-const node_1 = require("../../tree/nodes/node");
 const numberNode_1 = require("../../tree/nodes/numbers/numberNode");
 const addNode_1 = require("../../tree/nodes/operators/addNode");
 const multiplyNode_1 = require("../../tree/nodes/operators/multiplyNode");
@@ -41,7 +41,8 @@ class Vector {
     }
     isColinear(v) {
         const det = this.determinant(v);
-        return det.evaluate({}) === 0;
+        const ev = det.evaluate();
+        return Math.abs(ev) < 0.000001;
     }
     determinant(v) {
         return (0, substractNode_1.substract)((0, multiplyNode_1.multiply)(this.x, v.y), (0, multiplyNode_1.multiply)(this.y, v.x)).simplify();
@@ -50,13 +51,18 @@ class Vector {
         return new Vector(name ?? "v", new multiplyNode_1.MultiplyNode(this.x, k).simplify(), new multiplyNode_1.MultiplyNode(this.y, k).simplify());
     }
     scalarProduct(v) {
-        if ([this.x.type, this.y.type, v.x.type, v.y.type].some((el) => el !== node_1.NodeType.number))
-            throw Error("general determinant not implemented");
-        const xValue = this.x.value;
-        const yValue = this.y.value;
-        const vxValue = v.x.value;
-        const vyValue = v.y.value;
-        return new numberNode_1.NumberNode(xValue * vxValue + yValue * vyValue);
+        // if (
+        //   [this.x.type, this.y.type, v.x.type, v.y.type].some(
+        //     (el) => el !== NodeType.number,
+        //   )
+        // )
+        //   throw Error("general determinant not implemented");
+        // const xValue = (this.x as NumberNode).value;
+        // const yValue = (this.y as NumberNode).value;
+        // const vxValue = (v.x as NumberNode).value;
+        // const vyValue = (v.y as NumberNode).value;
+        // return new NumberNode(xValue * vxValue + yValue * vyValue);
+        return (0, addNode_1.add)((0, multiplyNode_1.multiply)(this.x, v.x), (0, multiplyNode_1.multiply)(this.y, v.y)).simplify();
     }
     add(v) {
         const x = v.x;
@@ -88,5 +94,8 @@ class Vector {
         }
         return this.y.value;
     }
+    getOrthogonal() {
+        return new Vector(this.name, this.y, (0, oppositeNode_1.opposite)(this.x).simplify());
+    }
 }
 exports.Vector = Vector;

package/lib/math/numbers/nombre.d.ts

@@ -18,5 +18,10 @@ export declare abstract class NombreConstructor {
         types?: NumberType[];
         excludes?: Nombre[];
     }): Nombre;
+    static manyRandom(n: number, { types, excludes, allDifferent, }?: {
+        types?: NumberType[];
+        excludes?: Nombre[];
+        allDifferent?: boolean;
+    }): Nombre[];
 }
 //# sourceMappingURL=nombre.d.ts.map

package/lib/math/numbers/nombre.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"nombre.d.ts","sourceRoot":"","sources":["../../../src/math/numbers/nombre.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAC/D,OAAO,EAAQ,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAQ1D,oBAAY,UAAU;IACpB,OAAO,IAAA;IACP,OAAO,IAAA;IACP,QAAQ,IAAA;IACR,IAAI,IAAA;CACL;AAED,MAAM,WAAW,MAAM;IACrB,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,UAAU,CAAC;IACjB,MAAM,EAAE,CAAC,IAAI,CAAC,EAAE,WAAW,KAAK,aAAa,CAAC;IAC9C,MAAM,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC;CAChC;AAED,8BAAsB,iBAAiB;IACrC,MAAM,CAAC,MAAM,CAAC,EACZ,KAAK,EACL,QAAQ,GACT,GAAE;QACD,KAAK,CAAC,EAAE,UAAU,EAAE,CAAC;QACrB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;KAChB;CAiCP"}
+{"version":3,"file":"nombre.d.ts","sourceRoot":"","sources":["../../../src/math/numbers/nombre.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAC/D,OAAO,EAAQ,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAQ1D,oBAAY,UAAU;IACpB,OAAO,IAAA;IACP,OAAO,IAAA;IACP,QAAQ,IAAA;IACR,IAAI,IAAA;CACL;AAED,MAAM,WAAW,MAAM;IACrB,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,UAAU,CAAC;IACjB,MAAM,EAAE,CAAC,IAAI,CAAC,EAAE,WAAW,KAAK,aAAa,CAAC;IAC9C,MAAM,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC;CAChC;AAED,8BAAsB,iBAAiB;IACrC,MAAM,CAAC,MAAM,CAAC,EACZ,KAAK,EACL,QAAQ,GACT,GAAE;QACD,KAAK,CAAC,EAAE,UAAU,EAAE,CAAC;QACrB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;KAChB;IAiCN,MAAM,CAAC,UAAU,CACf,CAAC,EAAE,MAAM,EACT,EACE,KAAK,EACL,QAAQ,EACR,YAAoB,GACrB,GAAE;QACD,KAAK,CAAC,EAAE,UAAU,EAAE,CAAC;QACrB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;QACpB,YAAY,CAAC,EAAE,OAAO,CAAC;KACnB;CAaT"}

package/lib/math/numbers/nombre.js

@@ -48,5 +48,17 @@ class NombreConstructor {
         }
         return res;
     }
+    static manyRandom(n, { types, excludes, allDifferent = false, } = {}) {
+        const res = [];
+        res.push(NombreConstructor.random({ types, excludes }));
+        for (let i = 0; i < n - 1; i++) {
+            let b;
+            do {
+                b = NombreConstructor.random({ types, excludes });
+            } while (allDifferent && res.some((el) => el.equals(b)));
+            res.push(b);
+        }
+        return res;
+    }
 }
 exports.NombreConstructor = NombreConstructor;

package/lib/math/numbers/rationals/rational.d.ts

@@ -28,7 +28,7 @@ export declare class Rational implements Nombre {
     reverse(shouldSimplify: boolean): Nombre;
     divide(nb: Nombre): Nombre;
     opposite(): Rational;
-    toTree(opts?: NodeOptions): OppositeNode | FractionNode;
+    toTree(opts?: NodeOptions): FractionNode | OppositeNode<FractionNode>;
     isIrreductible(): boolean;
     simplify(): Integer | Rational;
 }

package/lib/math/numbers/reals/extendedRingElement.d.ts

@@ -13,6 +13,6 @@ export declare class ExtendedRingElement {
     b: number;
     algebraicElement: Nombre;
     constructor(a: number, b: number, algebraicElement: Nombre);
-    toTree(): import("../../../tree/nodes/algebraicNode").AlgebraicNode | NumberNode | SubstractNode | AddNode | OppositeNode | MultiplyNode;
+    toTree(): import("../../../tree/nodes/algebraicNode").AlgebraicNode | NumberNode | SubstractNode | AddNode | MultiplyNode | OppositeNode<import("../../../tree/nodes/algebraicNode").AlgebraicNode>;
 }
 //# sourceMappingURL=extendedRingElement.d.ts.map

package/lib/math/numbers/reals/real.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"real.d.ts","sourceRoot":"","sources":["../../../../src/math/numbers/reals/real.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAC/D,OAAO,EAAE,QAAQ,EAAE,MAAM,qCAAqC,CAAC;AAS/D,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAC/C,8BAAsB,eAAe;IACnC,MAAM,CAAC,MAAM;CAUd;AACD,qBAAa,IAAK,YAAW,MAAM;IACjC,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,UAAU,CAAC;gBACL,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM;IAKtC,MAAM,CAAC,CAAC,EAAE,MAAM;IAGhB,MAAM,IAAI,aAAa;CAIxB;AAED,8BAAsB,qBAAqB;IACzC;;OAEG;IACH,MAAM,CAAC,kBAAkB,CAAC,EACxB,kBAA0B,EAC1B,SAAc,GACf;;;KAAA,GAAG,UAAU;IASd,MAAM,CAAC,kBAAkB,CAAC,GAAG,GAAE,MAAW,GAAG,UAAU;CAIxD;AAED,qBAAa,UAAW,SAAQ,IAAI;IAClC,OAAO,EAAE,MAAM,CAAC;gBACJ,OAAO,EAAE,MAAM;IAK3B,cAAc;IAMd,mBAAmB,IAAI,CAAC,MAAM,EAAE,MAAM,CAAC;IAkBvC,sDAAsD;IACtD,aAAa,IAAI,MAAM;IAMvB,QAAQ,IAAI,MAAM;IAyBlB,KAAK,IAAI,MAAM;IAIf,MAAM;CAGP"}
+{"version":3,"file":"real.d.ts","sourceRoot":"","sources":["../../../../src/math/numbers/reals/real.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAC/D,OAAO,EAAE,QAAQ,EAAE,MAAM,qCAAqC,CAAC;AAU/D,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAC/C,8BAAsB,eAAe;IACnC,MAAM,CAAC,MAAM;CAUd;AACD,qBAAa,IAAK,YAAW,MAAM;IACjC,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,UAAU,CAAC;gBACL,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM;IAKtC,MAAM,CAAC,CAAC,EAAE,MAAM;IAGhB,MAAM,IAAI,aAAa;CAIxB;AAED,8BAAsB,qBAAqB;IACzC;;OAEG;IACH,MAAM,CAAC,kBAAkB,CAAC,EACxB,kBAA0B,EAC1B,SAAc,GACf;;;KAAA,GAAG,UAAU;IASd,MAAM,CAAC,kBAAkB,CAAC,GAAG,GAAE,MAAW,GAAG,UAAU;CAIxD;AAED,qBAAa,UAAW,SAAQ,IAAI;IAClC,OAAO,EAAE,MAAM,CAAC;gBACJ,OAAO,EAAE,MAAM;IAK3B,cAAc;IAMd,mBAAmB,IAAI,CAAC,MAAM,EAAE,MAAM,CAAC;IAkBvC,sDAAsD;IACtD,aAAa,IAAI,MAAM;IAMvB,QAAQ,IAAI,MAAM;IA4BlB,KAAK,IAAI,MAAM;IAIf,MAAM;CAGP"}

package/lib/math/numbers/reals/real.js

@@ -10,6 +10,7 @@ const piNode_1 = require("../../../tree/nodes/numbers/piNode");
 const multiplyNode_1 = require("../../../tree/nodes/operators/multiplyNode");
 const diceFlip_1 = require("../../../utils/alea/diceFlip");
 const random_1 = require("../../../utils/alea/random");
+const decimal_1 = require("../decimals/decimal");
 const integer_1 = require("../integer/integer");
 const primes_1 = require("../integer/primes");
 const nombre_1 = require("../nombre");
@@ -101,6 +102,8 @@ class SquareRoot extends Real {
             return new integer_1.Integer(0);
         if (this.operand === 1)
             return new integer_1.Integer(1);
+        if (Math.floor(this.operand) !== this.operand)
+            return new decimal_1.Decimal(Math.sqrt(this.operand));
         const [outsideSqrt, insideSqrt] = this.getSimplifiedCoeffs();
         const simplified = insideSqrt !== 1
             ? new Real(outsideSqrt * Math.sqrt(insideSqrt), `${outsideSqrt === 1 ? "" : `${outsideSqrt}`}\\sqrt{${insideSqrt}}`)

package/lib/math/polynomials/generalAffine.d.ts

@@ -1,10 +1,23 @@
 import { AlgebraicNode } from "../../tree/nodes/algebraicNode";
+import { NodeIdentifiers } from "../../tree/nodes/nodeConstructor";
+export declare abstract class GeneralAffineConstructor {
+    static fromIdentifiers(identifiers: GeneralAffineIdentifiers): GeneralAffine;
+}
+export type GeneralAffineIdentifiers = {
+    id: "affine";
+    a: NodeIdentifiers;
+    b: NodeIdentifiers;
+    variable?: string;
+};
 export declare class GeneralAffine {
     a: AlgebraicNode;
     b: AlgebraicNode;
     variable: string;
     constructor(a: number | AlgebraicNode, b: number | AlgebraicNode, variable?: string);
+    toIdentifiers(): GeneralAffineIdentifiers;
     getRoot(): AlgebraicNode;
     toTree(): import("../../tree/nodes/operators/addNode").AddNode | import("../../tree/nodes/operators/multiplyNode").MultiplyNode;
+    xIntersect(aff: GeneralAffine): AlgebraicNode | undefined;
+    opposite(): GeneralAffine;
 }
 //# sourceMappingURL=generalAffine.d.ts.map

package/lib/math/polynomials/generalAffine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"generalAffine.d.ts","sourceRoot":"","sources":["../../../src/math/polynomials/generalAffine.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAO/D,qBAAa,aAAa;IACxB,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;gBAGf,CAAC,EAAE,MAAM,GAAG,aAAa,EACzB,CAAC,EAAE,MAAM,GAAG,aAAa,EACzB,QAAQ,GAAE,MAAY;IAWxB,OAAO,IAAI,aAAa;IAIxB,MAAM;CAKP"}
+{"version":3,"file":"generalAffine.d.ts","sourceRoot":"","sources":["../../../src/math/polynomials/generalAffine.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAG/D,OAAO,EAEL,eAAe,EAEhB,MAAM,kCAAkC,CAAC;AAQ1C,8BAAsB,wBAAwB;IAC5C,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,wBAAwB;CAM7D;AACD,MAAM,MAAM,wBAAwB,GAAG;IACrC,EAAE,EAAE,QAAQ,CAAC;IACb,CAAC,EAAE,eAAe,CAAC;IACnB,CAAC,EAAE,eAAe,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AACF,qBAAa,aAAa;IACxB,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;gBAGf,CAAC,EAAE,MAAM,GAAG,aAAa,EACzB,CAAC,EAAE,MAAM,GAAG,aAAa,EACzB,QAAQ,GAAE,MAAY;IAUxB,aAAa,IAAI,wBAAwB;IAQzC,OAAO,IAAI,aAAa;IAIxB,MAAM;IAMN,UAAU,CAAC,GAAG,EAAE,aAAa;IAI7B,QAAQ;CAMT"}