math-exercises 2.2.69 → 2.2.71

package/lib/math/geometry/rectangle.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Rectangle = exports.RectangleConstructor = void 0;
+const randfloat_1 = require("../utils/random/randfloat");
+const parallelogram_1 = require("./parallelogram");
+const point_1 = require("./point");
+class RectangleConstructor {
+    static random() {
+        const angle = (0, randfloat_1.randfloat)(0, Math.PI / 2);
+        const additionalAngle = (0, randfloat_1.randfloat)(Math.PI / 4, (3 * Math.PI) / 4);
+        const xRand = (0, randfloat_1.randfloat)(5, 8);
+        const origin = new point_1.Point("O", (0).toTree(), (0).toTree());
+        const A = new point_1.Point("A", (-xRand).toTree(), (0).toTree()).rotate(angle, origin);
+        const C = new point_1.Point("C", xRand.toTree(), (0).toTree()).rotate(angle, origin);
+        const yRand = (0, randfloat_1.randfloat)(3, 6);
+        const B = new point_1.Point("B", (-xRand).toTree(), (0).toTree()).rotate(angle + additionalAngle, origin);
+        const D = new point_1.Point("D", xRand.toTree(), (0).toTree()).rotate(angle + additionalAngle, origin);
+        return new Rectangle([A, B, C, D]);
+    }
+    static fromIdentifiers(identifiers) {
+        return new Rectangle(identifiers.points.map((point) => point_1.PointConstructor.fromIdentifiers(point)));
+    }
+}
+exports.RectangleConstructor = RectangleConstructor;
+class Rectangle extends parallelogram_1.Parallelogram {
+    constructor(points) {
+        super(points);
+    }
+    toIdentifiers() {
+        return {
+            points: this.points.map((point) => point.toIdentifiers()),
+        };
+    }
+    drawDiagonals({ drawCenter, drawDecorations, isRhombus, }) {
+        super.drawDiagonals({
+            drawCenter,
+            drawDecorations,
+            isRectangle: true,
+            isRhombus,
+        });
+    }
+    drawSidesDecoration({ drawAngles, drawSidesLengths, isRhombus, }) {
+        if (drawAngles) {
+            const angles = [
+                [1, 0, 3],
+                [2, 1, 0],
+                [3, 2, 1],
+                [0, 3, 2],
+            ];
+            angles.forEach((angle, index) => {
+                this.commands.push(`angle_${index} = Angle(${this.points[angle[0]].name}, ${this.points[angle[1]].name}, ${this.points[angle[2]].name}, xAxis)`);
+                //xAxis sert à obtenir l'angle aigu
+                this.commands.push(`ShowLabel(angle_${index}, false)`);
+            });
+        }
+        if (drawSidesLengths) {
+            super.drawSidesDecoration({ isRhombus });
+            this.commands.push(`angle_0 = Angle(${this.points[1].name}, ${this.points[0].name}, ${this.points[3].name}, xAxis)`);
+            //xAxis sert à obtenir l'angle aigu
+            this.commands.push(`ShowLabel(angle_0, false)`);
+        }
+    }
+}
+exports.Rectangle = Rectangle;

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

@@ -0,0 +1,19 @@
+import { Parallelogram } from "./parallelogram";
+import { Point, PointIdentifiers } from "./point";
+export declare abstract class RhombusConstructor {
+    static random(): Rhombus;
+    static fromIdentifiers(identifiers: RhombusIdentifiers): Rhombus;
+}
+export type RhombusIdentifiers = {
+    points: PointIdentifiers[];
+};
+export declare class Rhombus extends Parallelogram {
+    constructor(points: Point[]);
+    toIdentifiers(): RhombusIdentifiers;
+    drawDiagonals({ drawCenter, drawDecorations, }: {
+        drawCenter: boolean;
+        drawDecorations: boolean;
+    }): void;
+    drawSidesDecoration(): void;
+}
+//# sourceMappingURL=rhombus.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"rhombus.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/rhombus.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,KAAK,EAAoB,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAGpE,8BAAsB,kBAAkB;IACtC,MAAM,CAAC,MAAM;IAwBb,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,kBAAkB;CAOvD;AAED,MAAM,MAAM,kBAAkB,GAAG;IAC/B,MAAM,EAAE,gBAAgB,EAAE,CAAC;CAC5B,CAAC;AAEF,qBAAa,OAAQ,SAAQ,aAAa;gBAC5B,MAAM,EAAE,KAAK,EAAE;IAG3B,aAAa,IAAI,kBAAkB;IAKnC,aAAa,CAAC,EACZ,UAAU,EACV,eAAe,GAChB,EAAE;QACD,UAAU,EAAE,OAAO,CAAC;QACpB,eAAe,EAAE,OAAO,CAAC;KAC1B,GAAG,IAAI;IAUR,mBAAmB,IAAI,IAAI;CAK5B"}

package/lib/math/geometry/rhombus.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Rhombus = exports.RhombusConstructor = void 0;
+const randfloat_1 = require("../utils/random/randfloat");
+const parallelogram_1 = require("./parallelogram");
+const point_1 = require("./point");
+class RhombusConstructor {
+    static random() {
+        const angle = (0, randfloat_1.randfloat)(0, Math.PI / 2);
+        const xRand = (0, randfloat_1.randfloat)(5, 8);
+        const origin = new point_1.Point("O", (0).toTree(), (0).toTree());
+        const A = new point_1.Point("A", (-xRand).toTree(), (0).toTree()).rotate(angle, origin);
+        const C = new point_1.Point("C", xRand.toTree(), (0).toTree()).rotate(angle, origin);
+        const yRand = (0, randfloat_1.randfloat)(3, 6);
+        const B = new point_1.Point("B", (0).toTree(), yRand.toTree()).rotate(angle, origin);
+        const D = new point_1.Point("D", (0).toTree(), (-yRand).toTree()).rotate(angle, origin);
+        return new Rhombus([A, B, C, D]);
+    }
+    static fromIdentifiers(identifiers) {
+        return new Rhombus(identifiers.points.map((point) => point_1.PointConstructor.fromIdentifiers(point)));
+    }
+}
+exports.RhombusConstructor = RhombusConstructor;
+class Rhombus extends parallelogram_1.Parallelogram {
+    constructor(points) {
+        super(points);
+    }
+    toIdentifiers() {
+        return {
+            points: this.points.map((point) => point.toIdentifiers()),
+        };
+    }
+    drawDiagonals({ drawCenter, drawDecorations, }) {
+        super.drawDiagonals({ drawCenter, drawDecorations, isRhombus: true });
+        if (drawDecorations) {
+            this.commands.push(`centerAngle = Angle(${this.points[1].name}, diagoCenter, ${this.points[0].name}, xAxis)`);
+            this.commands.push(`ShowLabel(centerAngle, false)`);
+        }
+    }
+    drawSidesDecoration() {
+        this.sides.forEach((side, index) => {
+            this.commands.push(`SetDecoration(${side.ggbName}, 2)`);
+        });
+    }
+}
+exports.Rhombus = Rhombus;

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

@@ -0,0 +1,31 @@
+import { Angle } from "./angle";
+import { Point } from "./point";
+import { Triangle, TriangleIdentifiers, TriangleProps } from "./triangle";
+export declare abstract class RightTriangleConstructor {
+    static randomNiceSides({ names, randomName, }: {
+        names?: string[] | undefined;
+        randomName?: boolean | undefined;
+    }): RightTriangle;
+    static randomNiceAngles({ names, randomName, niceSideIndex, }: {
+        names?: string[];
+        randomName?: boolean;
+        niceSideIndex?: number;
+    }): RightTriangle;
+    static fromIdentifiers(identifiers: TriangleIdentifiers): RightTriangle;
+}
+type RightTriangleProps = {} & TriangleProps;
+export declare class RightTriangle extends Triangle {
+    /**
+     *
+     * @param points points[0] is right angle
+     * sides[0] is the hypotenuse (side "A" = "BC")
+     * angles[0] is angle A (90°)
+     */
+    constructor(points: Point[], props?: RightTriangleProps);
+    getRightAngle(): Angle;
+    getPythagorianTex(): string;
+    getOppositeSide(summitIndex: number): import("./segment").Segment;
+    getAdjacentSide(summitIndex: number): import("./segment").Segment;
+}
+export {};
+//# sourceMappingURL=rightTriangle.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"rightTriangle.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/rightTriangle.ts"],"names":[],"mappings":"AAYA,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAChC,OAAO,EAAE,KAAK,EAAoB,MAAM,SAAS,CAAC;AAClD,OAAO,EACL,QAAQ,EAER,mBAAmB,EACnB,aAAa,EACd,MAAM,YAAY,CAAC;AAEpB,8BAAsB,wBAAwB;IAC5C,MAAM,CAAC,eAAe,CAAC,EACrB,KAAuB,EACvB,UAAkB,GACnB;;;KAAA,GAAG,aAAa;IAqCjB,MAAM,CAAC,gBAAgB,CAAC,EACtB,KAAuB,EACvB,UAAkB,EAClB,aAAyB,GAC1B,EAAE;QACD,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;QACjB,UAAU,CAAC,EAAE,OAAO,CAAC;QACrB,aAAa,CAAC,EAAE,MAAM,CAAC;KACxB;IA0CD,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,mBAAmB;CAaxD;AAED,KAAK,kBAAkB,GAAG,EAAE,GAAG,aAAa,CAAC;AAC7C,qBAAa,aAAc,SAAQ,QAAQ;IACzC;;;;;OAKG;gBACS,MAAM,EAAE,KAAK,EAAE,EAAE,KAAK,CAAC,EAAE,kBAAkB;IAKvD,aAAa,IAAI,KAAK;IAMtB,iBAAiB;IAIjB,eAAe,CAAC,WAAW,EAAE,MAAM;IAInC,eAAe,CAAC,WAAW,EAAE,MAAM;CAKpC"}

package/lib/math/geometry/rightTriangle.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RightTriangle = exports.RightTriangleConstructor = void 0;
+const nodeConstructor_1 = require("../../tree/nodes/nodeConstructor");
+const random_1 = require("../../utils/alea/random");
+const pythagoricianTriplets_1 = require("../utils/geometry/pythagoricianTriplets");
+const randfloat_1 = require("../utils/random/randfloat");
+const randint_1 = require("../utils/random/randint");
+const round_1 = require("../utils/round");
+const point_1 = require("./point");
+const triangle_1 = require("./triangle");
+class RightTriangleConstructor {
+    static randomNiceSides({ names = ["A", "B", "C"], randomName = false, }) {
+        let vertices = [];
+        if (randomName)
+            vertices = triangle_1.TriangleConstructor.randomName();
+        else
+            vertices = names;
+        const triplet = (0, random_1.random)(pythagoricianTriplets_1.pythagoricianTripletsNiceAngles);
+        // const triplet = pythagoricianTriplets[0];
+        const coeff = (0, random_1.random)([1, 2, 0.1, 0.2, 0.25, 0.4, 0.5, 0.75, 0.8]);
+        let [ac, ab, bc] = triplet.map((e) => (0, round_1.round)(e * coeff, 4));
+        // const angles = [
+        //   frac(PiNode, 2),
+        //   frac(multiply(round(Math.asin(ac / bc), 2), PiNode), 180),
+        //   frac(multiply(round(Math.asin(ab / bc), 2), PiNode), 180),
+        // ];
+        const angle = (0, randfloat_1.randfloat)(0, 2 * Math.PI);
+        //on construit [AC] sur (Ox) de milieu O et de taille 2*xRand
+        //puis [AB] perpendiculaire à (AB) de taille yRand
+        //puis on rotate
+        const midAc = ac / 2;
+        const origin = new point_1.Point("O", (0).toTree(), (0).toTree());
+        const A = new point_1.Point(vertices[0], (-midAc).toTree(), (0).toTree()).rotate(angle, origin);
+        const C = new point_1.Point(vertices[2], midAc.toTree(), (0).toTree()).rotate(angle, origin);
+        const B = new point_1.Point(vertices[1], (-midAc).toTree(), ab.toTree()).rotate(angle, origin);
+        return new RightTriangle([A, B, C], {
+            sidesLengths: [bc.toTree(), ac.toTree(), ab.toTree()],
+            // anglesRadianValues: angles,
+        });
+    }
+    static randomNiceAngles({ names = ["A", "B", "C"], randomName = false, niceSideIndex = undefined, }) {
+        let vertices = [];
+        if (randomName)
+            vertices = triangle_1.TriangleConstructor.randomName();
+        else
+            vertices = names;
+        const angleB = (0, randfloat_1.randfloat)(20, 60, 1);
+        const angleC = (0, round_1.round)(90 - angleB, 1);
+        const angles = [90, angleB, angleC];
+        //a / sin(A) = b/sin(B) = c/sin(C)
+        const niceSide = niceSideIndex !== undefined ? niceSideIndex : (0, randint_1.randint)(0, 3);
+        const sideLenght = (0, randfloat_1.randfloat)(1, 20, 1);
+        const sidesLenghts = angles.map((angle, index) => index === niceSideIndex
+            ? sideLenght
+            : (Math.sin((angle * Math.PI) / 180) * sideLenght) /
+                Math.sin((angles[niceSide] * Math.PI) / 180));
+        const angle = (0, randfloat_1.randfloat)(0, 2 * Math.PI);
+        //on construit [AC] sur (Ox) de milieu O et de taille 2*xRand
+        //puis [AB] perpendiculaire à (AB) de taille yRand
+        //puis on rotate
+        const midAc = sidesLenghts[1] / 2;
+        const origin = new point_1.Point("O", (0).toTree(), (0).toTree());
+        const A = new point_1.Point(vertices[0], (-midAc).toTree(), (0).toTree()).rotate(angle, origin);
+        const C = new point_1.Point(vertices[2], midAc.toTree(), (0).toTree()).rotate(angle, origin);
+        const B = new point_1.Point(vertices[1], (-midAc).toTree(), sidesLenghts[2].toTree()).rotate(angle, origin);
+        return new RightTriangle([A, B, C], {
+            sidesLengths: sidesLenghts.map((s) => s.toTree()),
+            anglesDegreeValues: angles.map((a) => a.toTree()),
+        });
+    }
+    static fromIdentifiers(identifiers) {
+        return new RightTriangle(identifiers.points.map((p) => point_1.PointConstructor.fromIdentifiers(p)), {
+            anglesRadianValues: identifiers.props?.anglesRadianValues?.map((n) => (0, nodeConstructor_1.reifyAlgebraic)(n)),
+            sidesLengths: identifiers.props?.sidesLengths?.map((n) => n ? (0, nodeConstructor_1.reifyAlgebraic)(n) : undefined),
+        });
+    }
+}
+exports.RightTriangleConstructor = RightTriangleConstructor;
+class RightTriangle extends triangle_1.Triangle {
+    /**
+     *
+     * @param points points[0] is right angle
+     * sides[0] is the hypotenuse (side "A" = "BC")
+     * angles[0] is angle A (90°)
+     */
+    constructor(points, props) {
+        super(points, props);
+        if (!this.isRight())
+            throw new Error("Not a right triangle");
+        this.commands.push(...this.angles[0].toCommands());
+    }
+    getRightAngle() {
+        const angle = this.angles.find((a) => a.isRight());
+        if (!angle)
+            throw new Error("Not a right triangle");
+        return angle;
+    }
+    getPythagorianTex() {
+        return `${this.sides[0].toInsideName()}^2=${this.sides[1].toInsideName()}^2+${this.sides[2].toInsideName()}^2`;
+    }
+    getOppositeSide(summitIndex) {
+        if (summitIndex === 0)
+            throw Error("Right angle has no opposite side");
+        return this.sides[summitIndex];
+    }
+    getAdjacentSide(summitIndex) {
+        if (summitIndex === 0)
+            throw Error("Right angle has no adjacent side");
+        return this.sides[3 - summitIndex];
+    }
+}
+exports.RightTriangle = RightTriangle;

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

@@ -1,26 +1,44 @@
 import { ToGGBCommandsProps } from "../../exercises/utils/geogebra/toGGBCommandsProps";
+import { AlgebraicNode } from "../../tree/nodes/algebraicNode";
+import { NodeIdentifiers } from "../../tree/nodes/nodeConstructor";
 import { Point, PointIdentifiers } from "./point";
+import { Vector } from "./vector";
 export type SegmentIdentifiers = {
     pointA: PointIdentifiers;
     pointB: PointIdentifiers;
+    props?: SegmentPropsIdentifiers;
 };
 export declare abstract class SegmentConstructor {
     static random(): Segment;
     static fromIdentifiers(identifiers: SegmentIdentifiers): Segment;
 }
+type SegmentPropsIdentifiers = {
+    lengthNode?: NodeIdentifiers;
+    roundLenghtTo?: number;
+};
+type SegmentProps = {
+    lengthNode?: AlgebraicNode;
+    roundLenghtTo?: number;
+};
 export declare class Segment {
     pointA: Point;
     pointB: Point;
     name: string;
     ggbName: string;
-    constructor(pointA: Point, pointB: Point);
-    toIdentifiers(): {
-        pointA: PointIdentifiers;
-        pointB: PointIdentifiers;
-    };
+    lengthNode?: AlgebraicNode;
+    props?: SegmentProps;
+    constructor(pointA: Point, pointB: Point, props?: SegmentProps);
+    toIdentifiers(): SegmentIdentifiers;
+    getMidpoint(): Point;
     getLength(): number;
+    getLengthNode(): AlgebraicNode;
     toTex(): string;
     toInsideName(): string;
-    toGGBCommands(shouldBuildPoints: boolean, { isFixed, showLabel, showUnderlyingPointsLabel, }?: ToGGBCommandsProps): string[];
+    toLengthTex(): string;
+    getFitCaptionCommands(text?: string, color?: string): string[];
+    toGGBCommands(shouldBuildPoints: boolean, { isFixed, showLabel, showUnderlyingPointsLabel, showLength, style, }?: ToGGBCommandsProps): string[];
+    includes(point: Point): boolean;
+    toVector(): Vector;
 }
+export {};
 //# sourceMappingURL=segment.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"segment.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/segment.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,mDAAmD,CAAC;AAEvF,OAAO,EAAE,KAAK,EAAoB,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAEpE,MAAM,MAAM,kBAAkB,GAAG;IAC/B,MAAM,EAAE,gBAAgB,CAAC;IACzB,MAAM,EAAE,gBAAgB,CAAC;CAC1B,CAAC;AACF,8BAAsB,kBAAkB;IACtC,MAAM,CAAC,MAAM;IAKb,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,kBAAkB;CAMvD;AACD,qBAAa,OAAO;IAClB,MAAM,EAAE,KAAK,CAAC;IACd,MAAM,EAAE,KAAK,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;gBACJ,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK;IAOxC,aAAa;;;;IAMb,SAAS;IAGT,KAAK;IAGL,YAAY;IAGZ,aAAa,CACX,iBAAiB,EAAE,OAAO,EAC1B,EACE,OAAc,EACd,SAAiB,EACjB,yBAAgC,GACjC,GAAE,kBAAuB;CAoB7B"}
+{"version":3,"file":"segment.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/segment.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,mDAAmD,CAAC;AAEvF,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAE/D,OAAO,EAEL,eAAe,EAEhB,MAAM,kCAAkC,CAAC;AAK1C,OAAO,EAAE,KAAK,EAAoB,gBAAgB,EAAE,MAAM,SAAS,CAAC;AACpE,OAAO,EAAE,MAAM,EAAqB,MAAM,UAAU,CAAC;AAErD,MAAM,MAAM,kBAAkB,GAAG;IAC/B,MAAM,EAAE,gBAAgB,CAAC;IACzB,MAAM,EAAE,gBAAgB,CAAC;IACzB,KAAK,CAAC,EAAE,uBAAuB,CAAC;CACjC,CAAC;AACF,8BAAsB,kBAAkB;IACtC,MAAM,CAAC,MAAM;IAKb,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,kBAAkB;CAYvD;AAED,KAAK,uBAAuB,GAAG;IAC7B,UAAU,CAAC,EAAE,eAAe,CAAC;IAC7B,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB,CAAC;AACF,KAAK,YAAY,GAAG;IAAE,UAAU,CAAC,EAAE,aAAa,CAAC;IAAC,aAAa,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAC3E,qBAAa,OAAO;IAClB,MAAM,EAAE,KAAK,CAAC;IACd,MAAM,EAAE,KAAK,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,aAAa,CAAC;IAC3B,KAAK,CAAC,EAAE,YAAY,CAAC;gBACT,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,CAAC,EAAE,YAAY;IAS9D,aAAa,IAAI,kBAAkB;IAUnC,WAAW;IAGX,SAAS;IAST,aAAa;IAYb,KAAK;IAGL,YAAY;IAGZ,WAAW;IAGX,qBAAqB,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM;IAanD,aAAa,CACX,iBAAiB,EAAE,OAAO,EAC1B,EACE,OAAc,EACd,SAAiB,EACjB,yBAAgC,EAChC,UAAkB,EAClB,KAAK,GACN,GAAE,kBAAuB;IA8B5B,QAAQ,CAAC,KAAK,EAAE,KAAK;IAOrB,QAAQ;CAGT"}

package/lib/math/geometry/segment.js

@@ -2,7 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Segment = exports.SegmentConstructor = void 0;
 const randomSegmentName_1 = require("../../exercises/utils/geometry/randomSegmentName");
+const sqrtNode_1 = require("../../tree/nodes/functions/sqrtNode");
+const nodeConstructor_1 = require("../../tree/nodes/nodeConstructor");
+const addNode_1 = require("../../tree/nodes/operators/addNode");
+const powerNode_1 = require("../../tree/nodes/operators/powerNode");
+const substractNode_1 = require("../../tree/nodes/operators/substractNode");
+const round_1 = require("../utils/round");
 const point_1 = require("./point");
+const vector_1 = require("./vector");
 class SegmentConstructor {
     static random() {
         const name = (0, randomSegmentName_1.randomSegmentName)();
@@ -10,14 +17,21 @@ class SegmentConstructor {
         return new Segment(points[0], points[1]);
     }
     static fromIdentifiers(identifiers) {
-        return new Segment(point_1.PointConstructor.fromIdentifiers(identifiers.pointA), point_1.PointConstructor.fromIdentifiers(identifiers.pointB));
+        return new Segment(point_1.PointConstructor.fromIdentifiers(identifiers.pointA), point_1.PointConstructor.fromIdentifiers(identifiers.pointB), {
+            lengthNode: identifiers.props?.lengthNode
+                ? (0, nodeConstructor_1.reifyAlgebraic)(identifiers.props.lengthNode)
+                : undefined,
+            roundLenghtTo: identifiers.props?.roundLenghtTo,
+        });
     }
 }
 exports.SegmentConstructor = SegmentConstructor;
 class Segment {
-    constructor(pointA, pointB) {
+    constructor(pointA, pointB, props) {
         this.pointA = pointA;
         this.pointB = pointB;
+        this.props = props;
+        this.lengthNode = props?.lengthNode;
         this.name = `[${pointA.name}${pointB.name}]`;
         this.ggbName = `segment_{${pointA.name}${pointB.name}}`;
     }
@@ -25,10 +39,27 @@ class Segment {
         return {
             pointA: this.pointA.toIdentifiers(),
             pointB: this.pointB.toIdentifiers(),
+            props: {
+                lengthNode: this.lengthNode?.toIdentifiers(),
+                roundLenghtTo: this.props?.roundLenghtTo,
+            },
         };
     }
+    getMidpoint() {
+        return this.pointA.midpoint(this.pointB);
+    }
     getLength() {
-        return this.pointA.distanceTo(this.pointB);
+        if (this.lengthNode) {
+            return this.lengthNode.evaluate();
+        }
+        return (0, round_1.round)(this.pointA.distanceTo(this.pointB), this.props?.roundLenghtTo ?? 6);
+    }
+    getLengthNode() {
+        if (this.lengthNode) {
+            return this.lengthNode;
+        }
+        // return this.getLength().toTree();
+        return (0, sqrtNode_1.sqrt)((0, addNode_1.add)((0, powerNode_1.square)((0, substractNode_1.substract)(this.pointB.x, this.pointA.x)), (0, powerNode_1.square)((0, substractNode_1.substract)(this.pointB.y, this.pointA.y)))).simplify();
     }
     toTex() {
         return this.name;
@@ -36,12 +67,36 @@ class Segment {
     toInsideName() {
         return `${this.pointA.name}${this.pointB.name}`;
     }
-    toGGBCommands(shouldBuildPoints, { isFixed = true, showLabel = false, showUnderlyingPointsLabel = true, } = {}) {
+    toLengthTex() {
+        return `${this.toInsideName()} = ${this.getLengthNode().toTex()}`;
+    }
+    getFitCaptionCommands(text, color) {
+        const txt = text ?? this.getLength().frenchify();
+        const midPoint = this.getMidpoint().toMathString();
+        const cmds = [
+            `angle_{${this.name}} = Angle(Vector(${this.pointA.name}, ${this.pointB.name}))`,
+            `SetVisibleInView(angle_{${this.name}}, 1, false)`,
+            `text_{${this.name}} = Text(RotateText("${txt}", If(angle_{${this.name}} > 90° ∧ angle_{${this.name}} < 270°, angle_{${this.name}} + 180°, angle_{${this.name}})), ${midPoint}, true, true, 0, 0)`,
+        ];
+        if (color) {
+            cmds.push(`SetColor(text_{${this.name}}, "${color}")`);
+        }
+        return cmds;
+    }
+    toGGBCommands(shouldBuildPoints, { isFixed = true, showLabel = false, showUnderlyingPointsLabel = true, showLength = false, style, } = {}) {
         const commands = [
             `${this.ggbName}=Segment(${this.pointA.name},${this.pointB.name})`,
             `SetFixed(${this.ggbName},${isFixed ? "true" : "false"})`,
             `ShowLabel(${this.ggbName},${showLabel ? "true" : "false"})`,
         ];
+        if (style !== undefined) {
+            commands.push(`SetLineStyle(${this.ggbName}, ${style})`);
+        }
+        if (showLength) {
+            const length = this.getLengthNode().toTex();
+            commands.push(`SetCaption(${this.ggbName}, ${length})`);
+            commands.push(`ShowLabel(${this.ggbName}, true)`);
+        }
         if (shouldBuildPoints) {
             const ACommands = this.pointA.toGGBCommand({
                 isFixed,
@@ -55,5 +110,16 @@ class Segment {
         }
         return commands;
     }
+    includes(point) {
+        const vec = this.toVector();
+        const pointVec = vector_1.VectorConstructor.fromPoints(this.pointA, point);
+        if (!vec.isColinear(pointVec))
+            return false;
+        const product = vec.scalarProduct(pointVec).evaluate();
+        return product >= 0 && product <= this.getLength() ** 2;
+    }
+    toVector() {
+        return vector_1.VectorConstructor.fromPoints(this.pointA, this.pointB);
+    }
 }
 exports.Segment = Segment;

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

@@ -0,0 +1,22 @@
+import { Point, PointIdentifiers } from "./point";
+import { Rectangle } from "./rectangle";
+export declare abstract class SquareConstructor {
+    static random(): Square;
+    static fromIdentifiers(identifiers: SquareIdentifiers): Square;
+}
+export type SquareIdentifiers = {
+    points: PointIdentifiers[];
+};
+export declare class Square extends Rectangle {
+    constructor(points: Point[]);
+    toIdentifiers(): SquareIdentifiers;
+    drawDiagonals({ drawCenter, drawDecorations, }: {
+        drawCenter: boolean;
+        drawDecorations: boolean;
+    }): void;
+    drawSidesDecoration({ drawAngles, drawSidesLengths, }: {
+        drawAngles: boolean;
+        drawSidesLengths: boolean;
+    }): void;
+}
+//# sourceMappingURL=square.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"square.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/square.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAoB,gBAAgB,EAAE,MAAM,SAAS,CAAC;AACpE,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAGxC,8BAAsB,iBAAiB;IACrC,MAAM,CAAC,MAAM;IAwBb,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,iBAAiB;CAOtD;AACD,MAAM,MAAM,iBAAiB,GAAG;IAC9B,MAAM,EAAE,gBAAgB,EAAE,CAAC;CAC5B,CAAC;AACF,qBAAa,MAAO,SAAQ,SAAS;gBACvB,MAAM,EAAE,KAAK,EAAE;IAG3B,aAAa,IAAI,iBAAiB;IAKlC,aAAa,CAAC,EACZ,UAAU,EACV,eAAe,GAChB,EAAE;QACD,UAAU,EAAE,OAAO,CAAC;QACpB,eAAe,EAAE,OAAO,CAAC;KAC1B,GAAG,IAAI;IAGR,mBAAmB,CAAC,EAClB,UAAU,EACV,gBAAgB,GACjB,EAAE;QACD,UAAU,EAAE,OAAO,CAAC;QACpB,gBAAgB,EAAE,OAAO,CAAC;KAC3B,GAAG,IAAI;CAOT"}

package/lib/math/geometry/square.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Square = exports.SquareConstructor = void 0;
+const randfloat_1 = require("../utils/random/randfloat");
+const point_1 = require("./point");
+const rectangle_1 = require("./rectangle");
+class SquareConstructor {
+    static random() {
+        const angle = (0, randfloat_1.randfloat)(0, Math.PI / 2);
+        const xRand = (0, randfloat_1.randfloat)(5, 8);
+        const origin = new point_1.Point("O", (0).toTree(), (0).toTree());
+        const A = new point_1.Point("A", (-xRand).toTree(), (0).toTree()).rotate(angle, origin);
+        const C = new point_1.Point("C", xRand.toTree(), (0).toTree()).rotate(angle, origin);
+        const B = new point_1.Point("B", (0).toTree(), xRand.toTree()).rotate(angle, origin);
+        const D = new point_1.Point("D", (0).toTree(), (-xRand).toTree()).rotate(angle, origin);
+        return new Square([A, B, C, D]);
+    }
+    static fromIdentifiers(identifiers) {
+        return new Square(identifiers.points.map((point) => point_1.PointConstructor.fromIdentifiers(point)));
+    }
+}
+exports.SquareConstructor = SquareConstructor;
+class Square extends rectangle_1.Rectangle {
+    constructor(points) {
+        super(points);
+    }
+    toIdentifiers() {
+        return {
+            points: this.points.map((point) => point.toIdentifiers()),
+        };
+    }
+    drawDiagonals({ drawCenter, drawDecorations, }) {
+        super.drawDiagonals({ drawCenter, drawDecorations, isRhombus: true });
+    }
+    drawSidesDecoration({ drawAngles, drawSidesLengths, }) {
+        super.drawSidesDecoration({
+            drawAngles: true,
+            drawSidesLengths: true,
+            isRhombus: true,
+        });
+    }
+}
+exports.Square = Square;

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

@@ -1,67 +1,67 @@
 import { Point, PointIdentifiers } from "./point";
-import { SqrtNode } from "../../tree/nodes/functions/sqrtNode";
 import { Segment } from "./segment";
+import { Angle } from "./angle";
+import { AlgebraicNode } from "../../tree/nodes/algebraicNode";
+import { NodeIdentifiers } from "../../tree/nodes/nodeConstructor";
 export type TriangleIdentifiers = {
-    vertexA: PointIdentifiers;
-    vertexB: PointIdentifiers;
-    vertexC: PointIdentifiers;
+    points: PointIdentifiers[];
+    props?: TrianglePropsIdentifiers;
 };
 export declare abstract class TriangleConstructor {
     static fromIdentifiers(identifiers: TriangleIdentifiers): Triangle;
-    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;
+    static randomNiceSides({ names, randomName, }: {
         names?: string[] | undefined;
+        randomName?: boolean | undefined;
     }): Triangle;
     static randomName(): string[];
 }
-type GenerateCommandsProps = {
-    highlightedAngle?: string;
-    colorHighlightedAngle?: string;
-    highlightedSide?: string;
-    colorHighlightedSide?: string;
-    showLabels?: string[];
-    setCaptions?: string[];
-    showAxes?: boolean;
-    showGrid?: boolean;
+export type TrianglePropsIdentifiers = {
+    sidesLengths?: (NodeIdentifiers | undefined)[];
+    anglesRadianValues?: NodeIdentifiers[];
+    anglesDegreeValues?: NodeIdentifiers[];
+};
+export type TriangleProps = {
+    roundSidesTo?: number;
+    sidesLengths?: (AlgebraicNode | undefined)[];
+    anglesRadianValues?: AlgebraicNode[];
+    anglesDegreeValues?: AlgebraicNode[];
 };
 export declare class Triangle {
-    vertexA: Point;
-    vertexB: Point;
-    vertexC: Point;
-    constructor(vertexA: Point, vertexB: Point, vertexC: Point);
-    getSegments(): Segment[];
-    getSideASegment(): Segment;
-    getSideBSegment(): Segment;
-    getSideCSegment(): Segment;
+    angles: Angle[];
+    points: Point[];
+    sides: Segment[];
+    commands: string[];
+    name: string;
+    props?: TriangleProps;
+    constructor(points: Point[], props?: TriangleProps);
     toIdentifiers(): TriangleIdentifiers;
-    getSideAnumber(): number;
-    getSideBnumber(): number;
-    getSideCnumber(): number;
-    getTriangleName(): string;
-    getSideAnode(): SqrtNode;
-    getSideBnode(): SqrtNode;
-    getSideCnode(): SqrtNode;
-    getAngleA(): number;
-    getAngleB(): number;
-    getAngleC(): number;
+    /*************  ✨ Codeium Command ⭐  *************/
+    /**
+     * Returns the perimeter of the triangle.
+     * @returns {number} the perimeter of the triangle.
+     */
+    /******  fbb7c5d7-3919-4ef2-b5ba-db0d6770666d  *******/
     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, }: GenerateCommandsProps): string[];
+    highlightSide(index: number, opts: {
+        color?: string;
+        caption?: string;
+    }): void;
+    highlightAngle(index: number, opts?: {
+        color?: string;
+        showValue?: boolean;
+    }): void;
+    showSidesLength(hiddenSides?: number[]): void;
+    getHeight(summitIndex: number, opts?: {
+        footName?: string;
+    }): Segment;
+    drawHeight(summitIndex: number, opts?: {
+        footName?: string;
+    }): void;
     generateCoords(): number[];
-    getSideAName(): string;
-    getSideBName(): string;
-    getSideCName(): string;
 }
-export {};
 //# sourceMappingURL=triangle.d.ts.map