math-exercises 3.0.30 → 3.0.32

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

@@ -1 +1 @@
-{"version":3,"file":"angle.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/angle.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAMlE,OAAO,EAAE,KAAK,EAAoB,gBAAgB,EAAE,MAAM,YAAY,CAAC;AACvE,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAK7C,8BAAsB,gBAAgB;IACpC,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,gBAAgB;CAUrD;AACD,KAAK,UAAU,GAAG;IAChB,eAAe,CAAC,EAAE,aAAa,CAAC;IAChC,eAAe,CAAC,EAAE,aAAa,CAAC;CACjC,CAAC;AAEF,KAAK,qBAAqB,GAAG;IAC3B,eAAe,CAAC,EAAE,eAAe,CAAC;IAClC,eAAe,CAAC,EAAE,eAAe,CAAC;CACnC,CAAC;AACF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,MAAM,EAAE,gBAAgB,EAAE,CAAC;IAC3B,KAAK,CAAC,EAAE,qBAAqB,CAAC;CAC/B,CAAC;AACF,qBAAa,KAAK;IAChB,MAAM,EAAE,KAAK,EAAE,CAAC;IAChB,eAAe,CAAC,EAAE,aAAa,CAAC;IAChC,eAAe,CAAC,EAAE,aAAa,CAAC;IAChC,KAAK,CAAC,EAAE,UAAU,CAAC;IACnB;;;OAGG;gBACS,MAAM,EAAE,KAAK,EAAE,EAAE,KAAK,CAAC,EAAE,UAAU;IAkB/C,aAAa,IAAI,gBAAgB;IASjC,WAAW,CAAC,CAAC,EAAE,KAAK;IAIpB,MAAM,CAAC,CAAC,EAAE,KAAK;IAqBf,SAAS,CAAC,CAAC,EAAE,KAAK;IASlB,gBAAgB,CAAC,CAAC,EAAE,KAAK;IAwCzB,MAAM;IAMN,eAAe,CAAC,CAAC,EAAE,KAAK;IAsCxB,gBAAgB,CAAC,CAAC,EAAE,KAAK;IAoBzB,QAAQ,CAAC,QAAQ,UAAQ;IAiBzB,YAAY,CAAC,QAAQ,UAAQ;IAW7B,OAAO;IAIP,KAAK;IAGL,UAAU,CAAC,IAAI,CAAC,EAAE;QAChB,iBAAiB,CAAC,EAAE,OAAO,CAAC;QAC5B,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,SAAS,CAAC,EAAE,OAAO,CAAC;QACpB,SAAS,CAAC,EAAE,MAAM,CAAC;KACpB;CA0BF"}
+{"version":3,"file":"angle.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/angle.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAMlE,OAAO,EAAE,KAAK,EAAoB,gBAAgB,EAAE,MAAM,YAAY,CAAC;AACvE,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAK7C,8BAAsB,gBAAgB;IACpC,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,gBAAgB;CAUrD;AACD,KAAK,UAAU,GAAG;IAChB,eAAe,CAAC,EAAE,aAAa,CAAC;IAChC,eAAe,CAAC,EAAE,aAAa,CAAC;CACjC,CAAC;AAEF,KAAK,qBAAqB,GAAG;IAC3B,eAAe,CAAC,EAAE,eAAe,CAAC;IAClC,eAAe,CAAC,EAAE,eAAe,CAAC;CACnC,CAAC;AACF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,MAAM,EAAE,gBAAgB,EAAE,CAAC;IAC3B,KAAK,CAAC,EAAE,qBAAqB,CAAC;CAC/B,CAAC;AACF,qBAAa,KAAK;IAChB,MAAM,EAAE,KAAK,EAAE,CAAC;IAChB,eAAe,CAAC,EAAE,aAAa,CAAC;IAChC,eAAe,CAAC,EAAE,aAAa,CAAC;IAChC,KAAK,CAAC,EAAE,UAAU,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb;;;OAGG;gBACS,MAAM,EAAE,KAAK,EAAE,EAAE,KAAK,CAAC,EAAE,UAAU;IAmB/C,aAAa,IAAI,gBAAgB;IASjC,WAAW,CAAC,CAAC,EAAE,KAAK;IAIpB,MAAM,CAAC,CAAC,EAAE,KAAK;IAqBf,SAAS,CAAC,CAAC,EAAE,KAAK;IASlB,gBAAgB,CAAC,CAAC,EAAE,KAAK;IAwCzB,MAAM;IAMN,eAAe,CAAC,CAAC,EAAE,KAAK;IAsCxB,gBAAgB,CAAC,CAAC,EAAE,KAAK;IAoBzB,QAAQ,CAAC,QAAQ,UAAQ;IAiBzB,YAAY,CAAC,QAAQ,UAAQ;IAW7B,OAAO;IAIP,KAAK;IAIL,qBAAqB,CAAC,EACpB,IAAI,EACJ,KAAK,EACL,IAAI,GACL,GAAE;QACD,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,IAAI,CAAC,EAAE,YAAY,GAAG,MAAM,GAAG,OAAO,GAAG,OAAO,CAAC;KAC7C;IAgBN,UAAU,CAAC,IAAI,CAAC,EAAE;QAChB,iBAAiB,CAAC,EAAE,OAAO,CAAC;QAC5B,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,SAAS,CAAC,EAAE,OAAO,CAAC;QACpB,SAAS,CAAC,EAAE,MAAM,CAAC;KACpB;CA2BF"}

package/lib/math/geometry/angle.js

@@ -23,6 +23,7 @@ export class Angle {
     radianValueNode;
     degreeValueNode;
     props;
+    name;
     /**
      *
      * @param points [pointA, pointB, pointC] with apex = B
@@ -38,6 +39,7 @@ export class Angle {
         if (props?.degreeValueNode && !props.radianValueNode) {
             this.radianValueNode = frac(multiply(props.degreeValueNode, PiNode), (180).toTree());
         }
+        this.name = `angle${this.points[0].name}${this.points[1].name}${this.points[2].name}`;
     }
     toIdentifiers() {
         return {
@@ -194,22 +196,33 @@ export class Angle {
     toTex() {
         return `\\widehat{${this.points[0].name}${this.points[1].name}${this.points[2].name}}`;
     }
+    getFitCaptionCommands({ text, color, size, } = {}) {
+        const txt = text ?? this.getValueNode(true).toTex();
+        // const point = this.getMidpoint().toMathString();
+        const cmds = [
+            `text_{${this.name}} = Text("${size ? `\\${size}` : ""} ${txt}°", ${this.points[1].name}+2*UnitVector(AngleBisector(${this.points[2].name},${this.points[1].name},${this.points[0].name})), true, true, 0, 0)`,
+            // `SetBackgroundColor(text_{${this.name}}, "white")`,
+        ];
+        if (color) {
+            cmds.push(`SetColor(text_{${this.name}}, "${color}")`);
+        }
+        return cmds;
+    }
     toCommands(opts) {
-        const name = `angle_{${this.points[0].name}${this.points[1].name}${this.points[2].name}}`;
         const cmds = [];
         if (opts?.pointsAreNotBuilt) {
-            cmds.push(`${name} = Angle(${this.points[0].toMathString()},${this.points[1].toMathString()},${this.points[2].toMathString()}, xAxis)`);
+            cmds.push(`${this.name} = Angle(${this.points[0].toMathString()},${this.points[1].toMathString()},${this.points[2].toMathString()}, xAxis)`);
         }
         else {
-            cmds.push(`${name} = Angle(${this.points[0].name},${this.points[1].name},${this.points[2].name}, xAxis)`);
+            cmds.push(`${this.name} = Angle(${this.points[0].name},${this.points[1].name},${this.points[2].name}, xAxis)`);
         }
-        cmds.push(`ShowLabel(${name}, ${opts?.showValue ? "true" : "false"})`);
-        cmds.push(`SetCaption(${name}, "$\\footnotesize ${round(this.evaluate(), 1).frenchify() + "°"}$")`);
+        cmds.push(`ShowLabel(${this.name}, ${opts?.showValue ? "true" : "false"})`);
+        cmds.push(`SetCaption(${this.name}, "$\\footnotesize ${round(this.evaluate(), 1).frenchify() + "°"}$")`);
         if (opts?.color) {
-            cmds.push(`SetColor(${name}, "${opts.color}")`);
+            cmds.push(`SetColor(${this.name}, "${opts.color}")`);
         }
         if (opts?.thickness !== undefined) {
-            cmds.push(`SetLineThickness(${name}, ${opts?.thickness})`);
+            cmds.push(`SetLineThickness(${this.name}, ${opts?.thickness})`);
         }
         return cmds;
     }

package/lib/math/geometry/quadrilaterals/parallelogram.d.ts

@@ -0,0 +1,23 @@
+import { Point, PointIdentifiers } from "../point.js";
+import { Quadrilateral } from "./quadrilateral.js";
+export declare abstract class ParallelogramConstructor {
+    static random(): Parallelogram;
+    static fromIdentifiers(identifiers: ParallelogramIdentifiers): Parallelogram;
+}
+export type ParallelogramIdentifiers = {
+    points: PointIdentifiers[];
+};
+export declare class Parallelogram extends Quadrilateral {
+    constructor(points: Point[]);
+    toIdentifiers(): ParallelogramIdentifiers;
+    drawDiagonals({ drawCenter, drawDecorations, isRectangle, isRhombus, }: {
+        drawCenter: boolean;
+        drawDecorations: boolean;
+        isRectangle?: boolean;
+        isRhombus?: boolean;
+    }): void;
+    drawSidesDecoration({ isRhombus }: {
+        isRhombus?: boolean;
+    }): void;
+}
+//# sourceMappingURL=parallelogram.d.ts.map

package/lib/math/geometry/quadrilaterals/parallelogram.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parallelogram.d.ts","sourceRoot":"","sources":["../../../../src/math/geometry/quadrilaterals/parallelogram.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAoB,gBAAgB,EAAE,MAAM,aAAa,CAAC;AACxE,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAEnD,8BAAsB,wBAAwB;IAC5C,MAAM,CAAC,MAAM;IA2Bb,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,wBAAwB;CAO7D;AAED,MAAM,MAAM,wBAAwB,GAAG;IACrC,MAAM,EAAE,gBAAgB,EAAE,CAAC;CAC5B,CAAC;AAEF,qBAAa,aAAc,SAAQ,aAAa;gBAClC,MAAM,EAAE,KAAK,EAAE;IAG3B,aAAa,IAAI,wBAAwB;IAKzC,aAAa,CAAC,EACZ,UAAU,EACV,eAAe,EACf,WAAW,EACX,SAAS,GACV,EAAE;QACD,UAAU,EAAE,OAAO,CAAC;QACpB,eAAe,EAAE,OAAO,CAAC;QACzB,WAAW,CAAC,EAAE,OAAO,CAAC;QACtB,SAAS,CAAC,EAAE,OAAO,CAAC;KACrB,GAAG,IAAI;IA6BR,mBAAmB,CAAC,EAAE,SAAS,EAAE,EAAE;QAAE,SAAS,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,IAAI;CAclE"}

package/lib/math/geometry/quadrilaterals/parallelogram.js

@@ -0,0 +1,65 @@
+import { randfloat } from "../../../math/utils/random/randfloat.js";
+import { Point, PointConstructor } from "../point.js";
+import { Quadrilateral } from "./quadrilateral.js";
+export class ParallelogramConstructor {
+    static random() {
+        const angle = randfloat(0, Math.PI / 2);
+        const additionalAngle = randfloat(Math.PI / 4, (3 * Math.PI) / 4);
+        const xRand = randfloat(5, 8);
+        const xRand2 = randfloat(3, 8);
+        const origin = new Point("O", (0).toTree(), (0).toTree());
+        const A = new Point("A", (-xRand).toTree(), (0).toTree()).rotate(angle, origin);
+        const C = new Point("C", xRand.toTree(), (0).toTree()).rotate(angle, origin);
+        const yRand = randfloat(3, 6);
+        const B = new Point("B", (-xRand2).toTree(), (0).toTree()).rotate(angle + additionalAngle, origin);
+        const D = new Point("D", xRand2.toTree(), (0).toTree()).rotate(angle + additionalAngle, origin);
+        return new Parallelogram([A, B, C, D]);
+    }
+    static fromIdentifiers(identifiers) {
+        return new Parallelogram(identifiers.points.map((point) => PointConstructor.fromIdentifiers(point)));
+    }
+}
+export class Parallelogram extends Quadrilateral {
+    constructor(points) {
+        super(points);
+    }
+    toIdentifiers() {
+        return {
+            points: this.points.map((point) => point.toIdentifiers()),
+        };
+    }
+    drawDiagonals({ drawCenter, drawDecorations, isRectangle, isRhombus, }) {
+        super.drawDiagonals({ drawCenter, drawDecorations });
+        if (drawDecorations) {
+            this.commands.push(`midDiago1 = Segment(${this.points[0].name}, diagoCenter)`);
+            this.commands.push(`midDiago2 = Segment(${this.points[2].name}, diagoCenter)`);
+            this.commands.push(`midDiago3 = Segment(${this.points[1].name}, diagoCenter)`);
+            this.commands.push(`midDiago4 = Segment(${this.points[3].name}, diagoCenter)`);
+            const secondDeco = isRectangle ? 2 : 3;
+            this.commands.push(`SetDecoration(midDiago1, 2)`);
+            this.commands.push(`SetDecoration(midDiago2, 2)`);
+            this.commands.push(`SetDecoration(midDiago3, ${secondDeco})`);
+            this.commands.push(`SetDecoration(midDiago4, ${secondDeco})`);
+        }
+        isRhombus &&
+            this.commands.push(...[
+                `centerAngle = Angle(${this.points[0].name}, diagoCenter, ${this.points[1].name}, xAxis)`,
+                `ShowLabel(centerAngle, false)`,
+            ]);
+    }
+    drawSidesDecoration({ isRhombus }) {
+        if (isRhombus) {
+            this.sides.forEach((side, index) => {
+                this.commands.push(`SetDecoration(${side.ggbName}, 2)`);
+            });
+        }
+        else {
+            this.sides.forEach((side, index) => {
+                if (index % 2 === 0)
+                    this.commands.push(`SetDecoration(${side.ggbName}, 2)`);
+                if (index % 2 !== 0)
+                    this.commands.push(`SetDecoration(${side.ggbName}, 3)`);
+            });
+        }
+    }
+}

package/lib/math/geometry/quadrilaterals/quadrilateral.d.ts

@@ -0,0 +1,15 @@
+import { Point } from "../point.js";
+import { Segment } from "../segment.js";
+export declare class Quadrilateral {
+    commands: string[];
+    points: Point[];
+    sides: Segment[];
+    name: string;
+    constructor(points: Point[]);
+    drawDiagonals({ drawCenter, drawDecorations, }: {
+        drawCenter: boolean;
+        drawDecorations: boolean;
+    }): void;
+    toGGBCommands(): string[];
+}
+//# sourceMappingURL=quadrilateral.d.ts.map

package/lib/math/geometry/quadrilaterals/quadrilateral.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quadrilateral.d.ts","sourceRoot":"","sources":["../../../../src/math/geometry/quadrilaterals/quadrilateral.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACpC,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAExC,qBAAa,aAAa;IACxB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,MAAM,EAAE,KAAK,EAAE,CAAC;IAChB,KAAK,EAAE,OAAO,EAAE,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;gBACD,MAAM,EAAE,KAAK,EAAE;IAuB3B,aAAa,CAAC,EACZ,UAAkB,EAClB,eAAuB,GACxB,EAAE;QACD,UAAU,EAAE,OAAO,CAAC;QACpB,eAAe,EAAE,OAAO,CAAC;KAC1B;IAcD,aAAa;CAGd"}

package/lib/math/geometry/quadrilaterals/quadrilateral.js

@@ -0,0 +1,38 @@
+import { Segment } from "../segment.js";
+export class Quadrilateral {
+    commands;
+    points;
+    sides;
+    name;
+    constructor(points) {
+        if (points.length !== 4)
+            throw new Error("Quadrilateral must have 4 points");
+        this.name = points.map((p) => p.name).join("");
+        this.points = points;
+        this.sides = [
+            new Segment(points[0], points[1]),
+            new Segment(points[1], points[2]),
+            new Segment(points[2], points[3]),
+            new Segment(points[3], points[0]),
+        ];
+        this.commands = [
+            ...points.flatMap((p) => p.toGGBCommand({
+                isFixed: true,
+                showLabel: true,
+            })),
+            ...this.sides.flatMap((s) => s.toGGBCommands(false)),
+        ];
+    }
+    drawDiagonals({ drawCenter = false, drawDecorations = false, }) {
+        const res = [];
+        res.push(`diago1 = Segment(${this.points[0].name}, ${this.points[2].name})`);
+        res.push(`diago2 = Segment(${this.points[1].name}, ${this.points[3].name})`);
+        if (drawCenter) {
+            res.push(`diagoCenter = Intersect(diago1, diago2)`);
+        }
+        this.commands.push(...res);
+    }
+    toGGBCommands() {
+        return this.commands;
+    }
+}

package/lib/math/geometry/quadrilaterals/rectangle.d.ts

@@ -0,0 +1,24 @@
+import { Point, PointIdentifiers } from "../point.js";
+import { Parallelogram } from "./parallelogram.js";
+export declare abstract class RectangleConstructor {
+    static random(): Rectangle;
+    static fromIdentifiers(identifiers: RectangleIdentifiers): Rectangle;
+}
+export type RectangleIdentifiers = {
+    points: PointIdentifiers[];
+};
+export declare class Rectangle extends Parallelogram {
+    constructor(points: Point[]);
+    toIdentifiers(): RectangleIdentifiers;
+    drawDiagonals({ drawCenter, drawDecorations, isRhombus, }: {
+        drawCenter: boolean;
+        drawDecorations: boolean;
+        isRhombus?: boolean;
+    }): void;
+    drawSidesDecoration({ drawAngles, drawSidesLengths, isRhombus, }: {
+        drawAngles: boolean;
+        drawSidesLengths: boolean;
+        isRhombus?: boolean;
+    }): void;
+}
+//# sourceMappingURL=rectangle.d.ts.map

package/lib/math/geometry/quadrilaterals/rectangle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rectangle.d.ts","sourceRoot":"","sources":["../../../../src/math/geometry/quadrilaterals/rectangle.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAoB,gBAAgB,EAAE,MAAM,aAAa,CAAC;AACxE,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,8BAAsB,oBAAoB;IACxC,MAAM,CAAC,MAAM;IAyBb,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,oBAAoB;CAOzD;AAED,MAAM,MAAM,oBAAoB,GAAG;IACjC,MAAM,EAAE,gBAAgB,EAAE,CAAC;CAC5B,CAAC;AACF,qBAAa,SAAU,SAAQ,aAAa;gBAC9B,MAAM,EAAE,KAAK,EAAE;IAG3B,aAAa,IAAI,oBAAoB;IAKrC,aAAa,CAAC,EACZ,UAAU,EACV,eAAe,EACf,SAAS,GACV,EAAE;QACD,UAAU,EAAE,OAAO,CAAC;QACpB,eAAe,EAAE,OAAO,CAAC;QACzB,SAAS,CAAC,EAAE,OAAO,CAAC;KACrB,GAAG,IAAI;IASR,mBAAmB,CAAC,EAClB,UAAU,EACV,gBAAgB,EAChB,SAAS,GACV,EAAE;QACD,UAAU,EAAE,OAAO,CAAC;QACpB,gBAAgB,EAAE,OAAO,CAAC;QAC1B,SAAS,CAAC,EAAE,OAAO,CAAC;KACrB,GAAG,IAAI;CA2BT"}

package/lib/math/geometry/quadrilaterals/rectangle.js

@@ -0,0 +1,59 @@
+import { randfloat } from "../../../math/utils/random/randfloat.js";
+import { Point, PointConstructor } from "../point.js";
+import { Parallelogram } from "./parallelogram.js";
+export class RectangleConstructor {
+    static random() {
+        const angle = randfloat(0, Math.PI / 2);
+        const additionalAngle = randfloat(Math.PI / 4, (3 * Math.PI) / 4);
+        const xRand = randfloat(5, 8);
+        const origin = new Point("O", (0).toTree(), (0).toTree());
+        const A = new Point("A", (-xRand).toTree(), (0).toTree()).rotate(angle, origin);
+        const C = new Point("C", xRand.toTree(), (0).toTree()).rotate(angle, origin);
+        const yRand = randfloat(3, 6);
+        const B = new Point("B", (-xRand).toTree(), (0).toTree()).rotate(angle + additionalAngle, origin);
+        const D = new 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) => PointConstructor.fromIdentifiers(point)));
+    }
+}
+export class Rectangle extends 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)`);
+        }
+    }
+}

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

@@ -0,0 +1,19 @@
+import { Point, PointIdentifiers } from "../point.js";
+import { Parallelogram } from "./parallelogram.js";
+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/quadrilaterals/rhombus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rhombus.d.ts","sourceRoot":"","sources":["../../../../src/math/geometry/quadrilaterals/rhombus.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAoB,gBAAgB,EAAE,MAAM,aAAa,CAAC;AACxE,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAGnD,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/quadrilaterals/rhombus.js

@@ -0,0 +1,41 @@
+import { randfloat } from "../../../math/utils/random/randfloat.js";
+import { Point, PointConstructor } from "../point.js";
+import { Parallelogram } from "./parallelogram.js";
+export class RhombusConstructor {
+    static random() {
+        const angle = randfloat(0, Math.PI / 2);
+        const xRand = randfloat(5, 8);
+        const origin = new Point("O", (0).toTree(), (0).toTree());
+        const A = new Point("A", (-xRand).toTree(), (0).toTree()).rotate(angle, origin);
+        const C = new Point("C", xRand.toTree(), (0).toTree()).rotate(angle, origin);
+        const yRand = randfloat(3, 6);
+        const B = new Point("B", (0).toTree(), yRand.toTree()).rotate(angle, origin);
+        const D = new 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) => PointConstructor.fromIdentifiers(point)));
+    }
+}
+export class Rhombus extends 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)`);
+        });
+    }
+}

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

@@ -0,0 +1,22 @@
+import { Point, PointIdentifiers } from "../point.js";
+import { Rectangle } from "./rectangle.js";
+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/quadrilaterals/square.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"square.d.ts","sourceRoot":"","sources":["../../../../src/math/geometry/quadrilaterals/square.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAoB,gBAAgB,EAAE,MAAM,aAAa,CAAC;AACxE,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAG3C,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/quadrilaterals/square.js

@@ -0,0 +1,38 @@
+import { randfloat } from "../../../math/utils/random/randfloat.js";
+import { Point, PointConstructor } from "../point.js";
+import { Rectangle } from "./rectangle.js";
+export class SquareConstructor {
+    static random() {
+        const angle = randfloat(0, Math.PI / 2);
+        const xRand = randfloat(5, 8);
+        const origin = new Point("O", (0).toTree(), (0).toTree());
+        const A = new Point("A", (-xRand).toTree(), (0).toTree()).rotate(angle, origin);
+        const C = new Point("C", xRand.toTree(), (0).toTree()).rotate(angle, origin);
+        const B = new Point("B", (0).toTree(), xRand.toTree()).rotate(angle, origin);
+        const D = new 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) => PointConstructor.fromIdentifiers(point)));
+    }
+}
+export class Square extends 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,
+        });
+    }
+}

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

@@ -0,0 +1,21 @@
+import { Point } from "../point.js";
+import { Triangle, TriangleIdentifiers, TriangleProps } from "./triangle.js";
+export declare abstract class EquilateralTriangleConstructor {
+    static fromIdentifiers(identifiers: TriangleIdentifiers): EquilateralTriangle;
+    static randomNiceSides({ names, randomName, intSides, minAngle, }: {
+        names?: string[] | undefined;
+        randomName?: boolean | undefined;
+        intSides?: boolean | undefined;
+        minAngle?: number | undefined;
+    }): Triangle;
+}
+type EquilateralTriangleProps = {} & TriangleProps;
+export declare class EquilateralTriangle extends Triangle {
+    /**
+     *
+     */
+    constructor(points: Point[], props?: EquilateralTriangleProps);
+    drawSidesDecoration(): void;
+}
+export {};
+//# sourceMappingURL=equilateralTriangle.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"equilateralTriangle.d.ts","sourceRoot":"","sources":["../../../../src/math/geometry/triangles/equilateralTriangle.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,EAAoB,MAAM,aAAa,CAAC;AACtD,OAAO,EACL,QAAQ,EAER,mBAAmB,EACnB,aAAa,EACd,MAAM,eAAe,CAAC;AAEvB,8BAAsB,8BAA8B;IAClD,MAAM,CAAC,eAAe,CACpB,WAAW,EAAE,mBAAmB,GAC/B,mBAAmB;IAgBtB,MAAM,CAAC,eAAe,CAAC,EACrB,KAAuB,EACvB,UAAkB,EAClB,QAAgB,EAChB,QAAY,GACb;;;;;KAAA,GAAG,QAAQ;CAkCb;AAED,KAAK,wBAAwB,GAAG,EAAE,GAAG,aAAa,CAAC;AACnD,qBAAa,mBAAoB,SAAQ,QAAQ;IAC/C;;OAEG;gBACS,MAAM,EAAE,KAAK,EAAE,EAAE,KAAK,CAAC,EAAE,wBAAwB;IAa7D,mBAAmB,IAAI,IAAI;CAO5B"}

package/lib/math/geometry/triangles/equilateralTriangle.js

@@ -0,0 +1,52 @@
+import { randfloat } from "../../../math/utils/random/randfloat.js";
+import { round } from "../../../math/utils/round.js";
+import { reifyAlgebraic } from "../../../tree/nodes/nodeConstructor.js";
+import { Point, PointConstructor } from "../point.js";
+import { Triangle, TriangleConstructor, } from "./triangle.js";
+export class EquilateralTriangleConstructor {
+    static fromIdentifiers(identifiers) {
+        return new EquilateralTriangle(identifiers.points.map((p) => PointConstructor.fromIdentifiers(p)), {
+            anglesRadianValues: identifiers.props?.anglesRadianValues?.map((n) => reifyAlgebraic(n)),
+            anglesDegreeValues: identifiers.props?.anglesDegreeValues?.map((n) => reifyAlgebraic(n)),
+            sidesLengths: identifiers.props?.sidesLengths?.map((n) => n ? reifyAlgebraic(n) : undefined),
+        });
+    }
+    static randomNiceSides({ names = ["A", "B", "C"], randomName = false, intSides = false, minAngle = 0, }) {
+        let vertices = [];
+        if (randomName)
+            vertices = TriangleConstructor.randomName();
+        else
+            vertices = names;
+        let A;
+        let B;
+        let C;
+        const origin = new Point("O", (0).toTree(), (0).toTree());
+        const angle = randfloat(0, 2 * Math.PI);
+        const midSide = randfloat(3, 8, 1);
+        C = new Point(vertices[2], midSide.toTree(), (0).toTree()).rotate(angle, origin);
+        B = new Point(vertices[1], (-midSide).toTree(), (0).toTree()).rotate(angle, origin);
+        const height = Math.sqrt(3) * midSide;
+        A = new Point(vertices[0], (0).toTree(), height.toTree()).rotate(angle, origin);
+        return new Triangle([A, B, C], {
+            sidesLengths: [
+                round(B.distanceTo(C), intSides ? 0 : 1).toTree(),
+                round(A.distanceTo(C), intSides ? 0 : 1).toTree(),
+                round(A.distanceTo(B), intSides ? 0 : 1).toTree(),
+            ],
+        });
+    }
+}
+export class EquilateralTriangle extends Triangle {
+    /**
+     *
+     */
+    constructor(points, props) {
+        super(points, props);
+        if (Math.abs(points[0].distanceTo(points[1]) - points[0].distanceTo(points[2])) > 0.001 ||
+            Math.abs(points[1].distanceTo(points[2]) - points[1].distanceTo(points[0])) > 0.001)
+            throw new Error("Not an equilateral triangle");
+    }
+    drawSidesDecoration() {
+        this.commands.push(`SetDecoration(${this.sides[1].ggbName}, 2)`, `SetDecoration(${this.sides[2].ggbName}, 2)`, `SetDecoration(${this.sides[0].ggbName}, 2)`);
+    }
+}

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

@@ -0,0 +1,23 @@
+import { Point } from "../point.js";
+import { Triangle, TriangleIdentifiers, TriangleProps } from "./triangle.js";
+export declare abstract class IsoceleTriangleConstructor {
+    static fromIdentifiers(identifiers: TriangleIdentifiers): IsoceleTriangle;
+    static randomNiceSides({ names, randomName, intSides, minAngle, }: {
+        names?: string[] | undefined;
+        randomName?: boolean | undefined;
+        intSides?: boolean | undefined;
+        minAngle?: number | undefined;
+    }): Triangle;
+}
+type IsoceleTriangleProps = {} & TriangleProps;
+export declare class IsoceleTriangle extends Triangle {
+    /**
+     *
+     * @param points points[0] est le sommet principal
+     * sides[0] est la base
+     */
+    constructor(points: Point[], props?: IsoceleTriangleProps);
+    drawSidesDecoration(): void;
+}
+export {};
+//# sourceMappingURL=isoceleTriangle.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"isoceleTriangle.d.ts","sourceRoot":"","sources":["../../../../src/math/geometry/triangles/isoceleTriangle.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,EAAoB,MAAM,aAAa,CAAC;AACtD,OAAO,EACL,QAAQ,EAER,mBAAmB,EACnB,aAAa,EACd,MAAM,eAAe,CAAC;AAEvB,8BAAsB,0BAA0B;IAC9C,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,mBAAmB,GAAG,eAAe;IAgBzE,MAAM,CAAC,eAAe,CAAC,EACrB,KAAuB,EACvB,UAAkB,EAClB,QAAgB,EAChB,QAAY,GACb;;;;;KAAA,GAAG,QAAQ;CA8Cb;AAED,KAAK,oBAAoB,GAAG,EAAE,GAAG,aAAa,CAAC;AAC/C,qBAAa,eAAgB,SAAQ,QAAQ;IAC3C;;;;OAIG;gBACS,MAAM,EAAE,KAAK,EAAE,EAAE,KAAK,CAAC,EAAE,oBAAoB;IAUzD,mBAAmB,IAAI,IAAI;CAM5B"}

package/lib/math/geometry/triangles/isoceleTriangle.js

@@ -0,0 +1,66 @@
+import { randfloat } from "../../../math/utils/random/randfloat.js";
+import { round } from "../../../math/utils/round.js";
+import { reifyAlgebraic } from "../../../tree/nodes/nodeConstructor.js";
+import { Angle } from "../angle.js";
+import { Point, PointConstructor } from "../point.js";
+import { Triangle, TriangleConstructor, } from "./triangle.js";
+export class IsoceleTriangleConstructor {
+    static fromIdentifiers(identifiers) {
+        return new IsoceleTriangle(identifiers.points.map((p) => PointConstructor.fromIdentifiers(p)), {
+            anglesRadianValues: identifiers.props?.anglesRadianValues?.map((n) => reifyAlgebraic(n)),
+            anglesDegreeValues: identifiers.props?.anglesDegreeValues?.map((n) => reifyAlgebraic(n)),
+            sidesLengths: identifiers.props?.sidesLengths?.map((n) => n ? reifyAlgebraic(n) : undefined),
+        });
+    }
+    static randomNiceSides({ names = ["A", "B", "C"], randomName = false, intSides = false, minAngle = 0, }) {
+        let vertices = [];
+        if (randomName)
+            vertices = TriangleConstructor.randomName();
+        else
+            vertices = names;
+        let A;
+        let B;
+        let C;
+        const anglesAreNice = () => {
+            const values = [
+                new Angle([C, B, A]).evaluate(),
+                new Angle([A, C, B]).evaluate(),
+                new Angle([B, A, C]).evaluate(),
+            ];
+            if (minAngle)
+                return values.every((v) => v > minAngle && v < 180 - minAngle);
+            return values.every((v) => v > 20 && v < 110);
+        };
+        do {
+            const origin = new Point("O", (0).toTree(), (0).toTree());
+            const angle = randfloat(0, 2 * Math.PI);
+            const midBase = randfloat(3, 8, 1);
+            const height = randfloat(3, 8, 1, [2 * midBase]);
+            C = new Point(vertices[2], midBase.toTree(), (0).toTree()).rotate(angle, origin);
+            B = new Point(vertices[1], (-midBase).toTree(), (0).toTree()).rotate(angle, origin);
+            A = new Point(vertices[0], (0).toTree(), height.toTree()).rotate(angle, origin);
+        } while (!anglesAreNice());
+        return new Triangle([A, B, C], {
+            sidesLengths: [
+                round(B.distanceTo(C), intSides ? 0 : 1).toTree(),
+                round(A.distanceTo(C), intSides ? 0 : 1).toTree(),
+                round(A.distanceTo(B), intSides ? 0 : 1).toTree(),
+            ],
+        });
+    }
+}
+export class IsoceleTriangle extends Triangle {
+    /**
+     *
+     * @param points points[0] est le sommet principal
+     * sides[0] est la base
+     */
+    constructor(points, props) {
+        super(points, props);
+        if (Math.abs(points[0].distanceTo(points[1]) - points[0].distanceTo(points[2])) > 0.001)
+            throw new Error("Not an isocele triangle");
+    }
+    drawSidesDecoration() {
+        this.commands.push(`SetDecoration(${this.sides[1].ggbName}, 2)`, `SetDecoration(${this.sides[2].ggbName}, 2)`);
+    }
+}

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

@@ -0,0 +1,31 @@
+import { Angle } from "../angle.js";
+import { Point } from "../point.js";
+import { Triangle, TriangleIdentifiers, TriangleProps } from "./triangle.js";
+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.js").Segment;
+    getAdjacentSide(summitIndex: number): import("../segment.js").Segment;
+}
+export {};
+//# sourceMappingURL=rightTriangle.d.ts.map