math-exercises 2.0.11 → 2.0.13

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

@@ -1,54 +1,54 @@
-import { Point } from "./point";
-import { SqrtNode } from "../../tree/nodes/functions/sqrtNode";
-export declare abstract class TriangleConstructor {
-    static createRandomRightTriangle({ minRapport, maxRapport, names, }: {
-        minRapport?: number | undefined;
-        maxRapport?: number | undefined;
-        names?: string[] | undefined;
-    }): Triangle;
-    static createRandomTriangle({ minAngle, maxAngle, names, }: {
-        minAngle?: number | undefined;
-        maxAngle?: number | undefined;
-        names?: string[] | undefined;
-    }): Triangle;
-}
-type GenerateCommandsProps = {
-    highlightedAngle?: string;
-    colorHighlightedAngle?: string;
-    highlightedSide?: string;
-    colorHighlightedSide?: string;
-    showLabels?: string[];
-    setCaptions?: string[];
-    showAxes?: boolean;
-    showGrid?: boolean;
-};
-export declare class Triangle {
-    vertexA: Point;
-    vertexB: Point;
-    vertexC: Point;
-    constructor(vertexA: Point, vertexB: Point, vertexC: Point);
-    getSideAnumber(): number;
-    getSideBnumber(): number;
-    getSideCnumber(): number;
-    getTriangleName(): string;
-    getSideAnode(): SqrtNode;
-    getSideBnode(): SqrtNode;
-    getSideCnode(): SqrtNode;
-    getAngleA(): number;
-    getAngleB(): number;
-    getAngleC(): number;
-    getPerimeter(): number;
-    getArea(): number;
-    isRight(): Boolean;
-    isEquilateral(): Boolean;
-    isIsosceles(): Boolean;
-    isScalene(): boolean;
-    getRightAngle(): string;
-    generateCommands({ highlightedAngle: highlightedAngle, colorHighlightedAngle: colorHighlightedAngle, showLabels: showLabels, setCaptions: setCaptions, highlightedSide: highlightedSide, colorHighlightedSide: colorHighlightedSide, showAxes, showGrid, }: GenerateCommandsProps): string[];
-    generateCoords(): number[];
-    getSideAName(): string;
-    getSideBName(): string;
-    getSideCName(): string;
-}
-export {};
+import { Point } from "./point";
+import { SqrtNode } from "../../tree/nodes/functions/sqrtNode";
+export declare abstract class TriangleConstructor {
+    static createRandomRightTriangle({ minRapport, maxRapport, names, }: {
+        minRapport?: number | undefined;
+        maxRapport?: number | undefined;
+        names?: string[] | undefined;
+    }): Triangle;
+    static createRandomTriangle({ minAngle, maxAngle, names, }: {
+        minAngle?: number | undefined;
+        maxAngle?: number | undefined;
+        names?: string[] | undefined;
+    }): Triangle;
+}
+type GenerateCommandsProps = {
+    highlightedAngle?: string;
+    colorHighlightedAngle?: string;
+    highlightedSide?: string;
+    colorHighlightedSide?: string;
+    showLabels?: string[];
+    setCaptions?: string[];
+    showAxes?: boolean;
+    showGrid?: boolean;
+};
+export declare class Triangle {
+    vertexA: Point;
+    vertexB: Point;
+    vertexC: Point;
+    constructor(vertexA: Point, vertexB: Point, vertexC: Point);
+    getSideAnumber(): number;
+    getSideBnumber(): number;
+    getSideCnumber(): number;
+    getTriangleName(): string;
+    getSideAnode(): SqrtNode;
+    getSideBnode(): SqrtNode;
+    getSideCnode(): SqrtNode;
+    getAngleA(): number;
+    getAngleB(): number;
+    getAngleC(): number;
+    getPerimeter(): number;
+    getArea(): number;
+    isRight(): Boolean;
+    isEquilateral(): Boolean;
+    isIsosceles(): Boolean;
+    isScalene(): boolean;
+    getRightAngle(): string;
+    generateCommands({ highlightedAngle: highlightedAngle, colorHighlightedAngle: colorHighlightedAngle, showLabels: showLabels, setCaptions: setCaptions, highlightedSide: highlightedSide, colorHighlightedSide: colorHighlightedSide, showAxes, showGrid, }: GenerateCommandsProps): string[];
+    generateCoords(): number[];
+    getSideAName(): string;
+    getSideBName(): string;
+    getSideCName(): string;
+}
+export {};
 //# sourceMappingURL=triangles.d.ts.map

package/lib/math/geometry/triangles.js

@@ -1,193 +1,193 @@
-"use strict";
-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");
-class TriangleConstructor {
-    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() ||
-            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);
-    }
-}
-exports.TriangleConstructor = TriangleConstructor;
-class Triangle {
-    constructor(vertexA, vertexB, vertexC) {
-        this.vertexA = vertexA;
-        this.vertexB = vertexB;
-        this.vertexC = vertexC;
-    }
-    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()));
-    }
-    getPerimeter() {
-        return (this.getSideAnumber() + this.getSideBnumber() + this.getSideCnumber());
-    }
-    getArea() {
-        const s = this.getPerimeter() / 2;
-        return Math.sqrt(s *
-            (s - this.getSideAnumber()) *
-            (s - this.getSideBnumber()) *
-            (s - this.getSideCnumber()));
-    }
-    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;
-    }
-    isEquilateral() {
-        return (this.getSideAnumber() === this.getSideBnumber() &&
-            this.getSideAnumber() === this.getSideCnumber());
-    }
-    isIsosceles() {
-        return (this.getSideAnumber() === this.getSideBnumber() ||
-            this.getSideAnumber() === this.getSideCnumber() ||
-            this.getSideBnumber() === this.getSideCnumber());
-    }
-    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, showAxes, showGrid, }) {
-        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)`,
-            `ShowAxes(${showAxes ?? false})`,
-            `ShowGrid(${showGrid ?? 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}")`);
-        }
-        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,
-        ];
-    }
-    getSideAName() {
-        return this.vertexB.name + this.vertexC.name;
-    }
-    getSideBName() {
-        return this.vertexC.name + this.vertexA.name;
-    }
-    getSideCName() {
-        return this.vertexA.name + this.vertexB.name;
-    }
-}
-exports.Triangle = Triangle;
+"use strict";
+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");
+class TriangleConstructor {
+    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() ||
+            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);
+    }
+}
+exports.TriangleConstructor = TriangleConstructor;
+class Triangle {
+    constructor(vertexA, vertexB, vertexC) {
+        this.vertexA = vertexA;
+        this.vertexB = vertexB;
+        this.vertexC = vertexC;
+    }
+    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()));
+    }
+    getPerimeter() {
+        return (this.getSideAnumber() + this.getSideBnumber() + this.getSideCnumber());
+    }
+    getArea() {
+        const s = this.getPerimeter() / 2;
+        return Math.sqrt(s *
+            (s - this.getSideAnumber()) *
+            (s - this.getSideBnumber()) *
+            (s - this.getSideCnumber()));
+    }
+    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;
+    }
+    isEquilateral() {
+        return (this.getSideAnumber() === this.getSideBnumber() &&
+            this.getSideAnumber() === this.getSideCnumber());
+    }
+    isIsosceles() {
+        return (this.getSideAnumber() === this.getSideBnumber() ||
+            this.getSideAnumber() === this.getSideCnumber() ||
+            this.getSideBnumber() === this.getSideCnumber());
+    }
+    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, showAxes, showGrid, }) {
+        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)`,
+            `ShowAxes(${showAxes ?? false})`,
+            `ShowGrid(${showGrid ?? 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}")`);
+        }
+        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,
+        ];
+    }
+    getSideAName() {
+        return this.vertexB.name + this.vertexC.name;
+    }
+    getSideBName() {
+        return this.vertexC.name + this.vertexA.name;
+    }
+    getSideCName() {
+        return this.vertexA.name + this.vertexB.name;
+    }
+}
+exports.Triangle = Triangle;

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

@@ -1,18 +1,18 @@
-import { Node } from "../../tree/nodes/node";
-import { Point } from "./point";
-export declare abstract class VectorConstructor {
-    static fromPoints(origin: Point, end: Point): Vector;
-    static random(name: string): Vector;
-}
-export declare class Vector {
-    name: string;
-    tex: string;
-    x: Node;
-    y: Node;
-    constructor(name: string, x: Node, y: Node);
-    toTex(): string;
-    toTexWithCoords(): string;
-    determinant(v: Vector): Node;
-    scalarProduct(v: Vector): Node;
-}
+import { Node } from "../../tree/nodes/node";
+import { Point } from "./point";
+export declare abstract class VectorConstructor {
+    static fromPoints(origin: Point, end: Point): Vector;
+    static random(name: string): Vector;
+}
+export declare class Vector {
+    name: string;
+    tex: string;
+    x: Node;
+    y: Node;
+    constructor(name: string, x: Node, y: Node);
+    toTex(): string;
+    toTexWithCoords(): string;
+    determinant(v: Vector): Node;
+    scalarProduct(v: Vector): Node;
+}
 //# sourceMappingURL=vector.d.ts.map

package/lib/math/geometry/vector.js

@@ -1,49 +1,49 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Vector = exports.VectorConstructor = void 0;
-const node_1 = require("../../tree/nodes/node");
-const numberNode_1 = require("../../tree/nodes/numbers/numberNode");
-const substractNode_1 = require("../../tree/nodes/operators/substractNode");
-const randint_1 = require("../utils/random/randint");
-class VectorConstructor {
-    static fromPoints(origin, end) {
-        return new Vector(`${origin.name}${end.name}`, new substractNode_1.SubstractNode(end.x, origin.x), new substractNode_1.SubstractNode(end.y, origin.y));
-    }
-    static random(name) {
-        return new Vector(name, new numberNode_1.NumberNode((0, randint_1.randint)(-10, 11)), new numberNode_1.NumberNode((0, randint_1.randint)(-10, 11)));
-    }
-}
-exports.VectorConstructor = VectorConstructor;
-class Vector {
-    constructor(name, x, y) {
-        this.name = name;
-        this.tex = `\\overrightarrow{${name}}`;
-        this.x = x;
-        this.y = y;
-    }
-    toTex() {
-        return `\\overrightarrow{${this.name}}`;
-    }
-    toTexWithCoords() {
-        return `\\overrightarrow{${this.name}}\\begin{pmatrix}${this.x.toTex()} \\\\ ${this.y.toTex()} \\end{pmatrix}`;
-    }
-    determinant(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 * vyValue - yValue * vxValue);
-    }
-    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);
-    }
-}
-exports.Vector = Vector;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Vector = exports.VectorConstructor = void 0;
+const node_1 = require("../../tree/nodes/node");
+const numberNode_1 = require("../../tree/nodes/numbers/numberNode");
+const substractNode_1 = require("../../tree/nodes/operators/substractNode");
+const randint_1 = require("../utils/random/randint");
+class VectorConstructor {
+    static fromPoints(origin, end) {
+        return new Vector(`${origin.name}${end.name}`, new substractNode_1.SubstractNode(end.x, origin.x), new substractNode_1.SubstractNode(end.y, origin.y));
+    }
+    static random(name) {
+        return new Vector(name, new numberNode_1.NumberNode((0, randint_1.randint)(-10, 11)), new numberNode_1.NumberNode((0, randint_1.randint)(-10, 11)));
+    }
+}
+exports.VectorConstructor = VectorConstructor;
+class Vector {
+    constructor(name, x, y) {
+        this.name = name;
+        this.tex = `\\overrightarrow{${name}}`;
+        this.x = x;
+        this.y = y;
+    }
+    toTex() {
+        return `\\overrightarrow{${this.name}}`;
+    }
+    toTexWithCoords() {
+        return `\\overrightarrow{${this.name}}\\begin{pmatrix}${this.x.toTex()} \\\\ ${this.y.toTex()} \\end{pmatrix}`;
+    }
+    determinant(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 * vyValue - yValue * vxValue);
+    }
+    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);
+    }
+}
+exports.Vector = Vector;

package/lib/math/inequations/inequation.d.ts

@@ -0,0 +1,15 @@
+export type InegalitySymbols = "<" | ">" | "\\le" | "\\ge";
+export declare abstract class InequationSymbolConstructor {
+    static random(): InequationSymbol;
+}
+export declare class InequationSymbol {
+    isStrict: boolean;
+    isSup: boolean;
+    symbol: InegalitySymbols;
+    constructor(symbol: InegalitySymbols);
+    reversed: () => InegalitySymbols;
+    toReversed: () => InequationSymbol;
+    toStrictnessToggled: () => InequationSymbol;
+    strictnessToggled: () => "<" | ">" | "\\le" | "\\ge";
+}
+//# sourceMappingURL=inequation.d.ts.map