math-exercises 3.0.29 → 3.0.31

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"rightTriangle.d.ts","sourceRoot":"","sources":["../../../../src/math/geometry/triangles/rightTriangle.ts"],"names":[],"mappings":"AAYA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACpC,OAAO,EAAE,KAAK,EAAoB,MAAM,aAAa,CAAC;AACtD,OAAO,EACL,QAAQ,EAER,mBAAmB,EACnB,aAAa,EACd,MAAM,eAAe,CAAC;AAEvB,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/triangles/rightTriangle.js

@@ -0,0 +1,108 @@
+import { reifyAlgebraic } from "../../../tree/nodes/nodeConstructor.js";
+import { random } from "../../../utils/alea/random.js";
+import { pythagoricianTripletsNiceAngles, } from "../../utils/geometry/pythagoricianTriplets.js";
+import { randfloat } from "../../utils/random/randfloat.js";
+import { randint } from "../../utils/random/randint.js";
+import { round } from "../../utils/round.js";
+import { Point, PointConstructor } from "../point.js";
+import { Triangle, TriangleConstructor, } from "./triangle.js";
+export class RightTriangleConstructor {
+    static randomNiceSides({ names = ["A", "B", "C"], randomName = false, }) {
+        let vertices = [];
+        if (randomName)
+            vertices = TriangleConstructor.randomName();
+        else
+            vertices = names;
+        const triplet = random(pythagoricianTripletsNiceAngles);
+        // const triplet = pythagoricianTriplets[0];
+        const coeff = random([1, 2, 0.1, 0.2, 0.25, 0.4, 0.5, 0.75, 0.8]);
+        let [ac, ab, bc] = triplet.map((e) => 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 = 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("O", (0).toTree(), (0).toTree());
+        const A = new Point(vertices[0], (-midAc).toTree(), (0).toTree()).rotate(angle, origin);
+        const C = new Point(vertices[2], midAc.toTree(), (0).toTree()).rotate(angle, origin);
+        const B = new 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 = TriangleConstructor.randomName();
+        else
+            vertices = names;
+        const angleB = randfloat(20, 60, 1);
+        const angleC = round(90 - angleB, 1);
+        const angles = [90, angleB, angleC];
+        //a / sin(A) = b/sin(B) = c/sin(C)
+        const niceSide = niceSideIndex !== undefined ? niceSideIndex : randint(0, 3);
+        const sideLenght = 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 = 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("O", (0).toTree(), (0).toTree());
+        const A = new Point(vertices[0], (-midAc).toTree(), (0).toTree()).rotate(angle, origin);
+        const C = new Point(vertices[2], midAc.toTree(), (0).toTree()).rotate(angle, origin);
+        const B = new 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) => PointConstructor.fromIdentifiers(p)), {
+            anglesRadianValues: identifiers.props?.anglesRadianValues?.map((n) => reifyAlgebraic(n)),
+            sidesLengths: identifiers.props?.sidesLengths?.map((n) => n ? reifyAlgebraic(n) : undefined),
+        });
+    }
+}
+export 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, 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];
+    }
+}

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

@@ -0,0 +1,68 @@
+import { Point, PointIdentifiers } from "../point.js";
+import { Segment } from "../segment.js";
+import { Angle } from "../angle.js";
+import { AlgebraicNode } from "../../../tree/nodes/algebraicNode.js";
+import { NodeIdentifiers } from "../../../tree/nodes/nodeConstructor.js";
+export type TriangleIdentifiers = {
+    points: PointIdentifiers[];
+    props?: TrianglePropsIdentifiers;
+};
+export declare abstract class TriangleConstructor {
+    static fromIdentifiers(identifiers: TriangleIdentifiers): Triangle;
+    static randomNiceSides({ names, randomName, intSides, minAngle, }: {
+        names?: string[] | undefined;
+        randomName?: boolean | undefined;
+        intSides?: boolean | undefined;
+        minAngle?: number | undefined;
+    }): Triangle;
+    static randomName(): string[];
+}
+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 {
+    angles: Angle[];
+    points: Point[];
+    sides: Segment[];
+    commands: string[];
+    name: string;
+    props?: TriangleProps;
+    constructor(points: Point[], props?: TriangleProps);
+    toIdentifiers(): TriangleIdentifiers;
+    getPerimeter(): number;
+    getArea(): number;
+    isRight(): Boolean;
+    isEquilateral(): Boolean;
+    isIsosceles(): Boolean;
+    isScalene(): boolean;
+    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;
+        footPoint?: Point;
+    }): void;
+    generateCoords(): number[];
+    drawAngles(hidden: number[], opts?: {
+        fitCaption: boolean;
+        color?: string;
+    }): void;
+}
+//# sourceMappingURL=triangle.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"triangle.d.ts","sourceRoot":"","sources":["../../../../src/math/geometry/triangles/triangle.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAoB,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAExE,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AACxC,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAKpC,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAClE,OAAO,EAEL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAG7C,MAAM,MAAM,mBAAmB,GAAG;IAChC,MAAM,EAAE,gBAAgB,EAAE,CAAC;IAC3B,KAAK,CAAC,EAAE,wBAAwB,CAAC;CAClC,CAAC;AAEF,8BAAsB,mBAAmB;IACvC,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,mBAAmB,GAAG,QAAQ;IAgBlE,MAAM,CAAC,eAAe,CAAC,EACrB,KAAuB,EACvB,UAAkB,EAClB,QAAgB,EAChB,QAAY,GACb;;;;;KAAA,GAAG,QAAQ;IA+CZ,MAAM,CAAC,UAAU;CAQlB;AAED,MAAM,MAAM,wBAAwB,GAAG;IACrC,YAAY,CAAC,EAAE,CAAC,eAAe,GAAG,SAAS,CAAC,EAAE,CAAC;IAC/C,kBAAkB,CAAC,EAAE,eAAe,EAAE,CAAC;IACvC,kBAAkB,CAAC,EAAE,eAAe,EAAE,CAAC;CACxC,CAAC;AACF,MAAM,MAAM,aAAa,GAAG;IAC1B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,YAAY,CAAC,EAAE,CAAC,aAAa,GAAG,SAAS,CAAC,EAAE,CAAC;IAC7C,kBAAkB,CAAC,EAAE,aAAa,EAAE,CAAC;IACrC,kBAAkB,CAAC,EAAE,aAAa,EAAE,CAAC;CACtC,CAAC;AACF,qBAAa,QAAQ;IACnB,MAAM,EAAE,KAAK,EAAE,CAAC;IAChB,MAAM,EAAE,KAAK,EAAE,CAAC;IAChB,KAAK,EAAE,OAAO,EAAE,CAAC;IACjB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,aAAa,CAAC;gBACV,MAAM,EAAE,KAAK,EAAE,EAAE,KAAK,CAAC,EAAE,aAAa;IA0ClD,aAAa,IAAI,mBAAmB;IAepC,YAAY,IAAI,MAAM;IAItB,OAAO,IAAI,MAAM;IASjB,OAAO,IAAI,OAAO;IAIlB,aAAa,IAAI,OAAO;IAMxB,WAAW,IAAI,OAAO;IAUtB,SAAS,IAAI,OAAO;IASpB,aAAa,CACX,KAAK,EAAE,MAAM,EACb,IAAI,EAAE;QACJ,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,OAAO,CAAC,EAAE,MAAM,CAAC;KAClB;IAcH,cAAc,CACZ,KAAK,EAAE,MAAM,EACb,IAAI,CAAC,EAAE;QACL,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,SAAS,CAAC,EAAE,OAAO,CAAC;KACrB;IAKH,eAAe,CAAC,WAAW,CAAC,EAAE,MAAM,EAAE;IAQtC,SAAS,CACP,WAAW,EAAE,MAAM,EACnB,IAAI,CAAC,EAAE;QACL,QAAQ,CAAC,EAAE,MAAM,CAAC;KACnB;IAYH,UAAU,CACR,WAAW,EAAE,MAAM,EACnB,IAAI,CAAC,EAAE;QACL,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,SAAS,CAAC,EAAE,KAAK,CAAC;KACnB;IAoCH,cAAc,IAAI,MAAM,EAAE;IAkB1B,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,IAAI,CAAC,EAAE;QAAE,UAAU,EAAE,OAAO,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE;CAgB5E"}

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

@@ -0,0 +1,240 @@
+import { Point, PointConstructor } from "../point.js";
+import { randomLetter } from "../../../utils/strings/randomLetter.js";
+import { Segment } from "../segment.js";
+import { Angle } from "../angle.js";
+import { arrayRotation } from "../../../utils/arrays/rotation.js";
+import { round } from "../../utils/round.js";
+import { randfloat } from "../../utils/random/randfloat.js";
+import { LineConstructor } from "../line.js";
+import { reifyAlgebraic, } from "../../../tree/nodes/nodeConstructor.js";
+import { randint } from "../../utils/random/randint.js";
+export class TriangleConstructor {
+    static fromIdentifiers(identifiers) {
+        return new Triangle(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 angle = randfloat(0, 2 * Math.PI);
+            const addAngle = randfloat(Math.PI / 4, (3 * Math.PI) / 4);
+            //on construit [AC] sur (Ox) de milieu O et de taille 2*xRand
+            //puis [AB] sur (Ox) qu'on rotate
+            const xRand = intSides ? randint(5, 9) : randfloat(5, 8, 1);
+            const xRand2 = intSides ? randint(-5, 5) : randfloat(-5, 5, 1);
+            const origin = new Point("O", (0).toTree(), (0).toTree());
+            const startA = new Point(vertices[0], (-xRand).toTree(), (0).toTree());
+            A = startA.rotate(angle, origin);
+            C = new Point(vertices[2], xRand.toTree(), (0).toTree()).rotate(angle, origin);
+            B = new Point(vertices[1], (-xRand + xRand2).toTree(), (0).toTree()).rotate(angle + addAngle, startA);
+        } 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(),
+            ],
+        });
+    }
+    static randomName() {
+        const startVertix = randomLetter(true, ["Y", "Z"]);
+        return [
+            startVertix,
+            String.fromCharCode(startVertix.charCodeAt(0) + 1),
+            String.fromCharCode(startVertix.charCodeAt(0) + 2),
+        ];
+    }
+}
+export class Triangle {
+    angles;
+    points;
+    sides;
+    commands;
+    name;
+    props;
+    constructor(points, props) {
+        if (points.length !== 3)
+            throw new Error("Triangle must have 3 points");
+        this.props = props;
+        this.name = points.map((p) => p.name).join("");
+        this.points = points;
+        const anglePoints = [points[0], points[2], points[1]];
+        this.angles = [
+            new Angle(arrayRotation(anglePoints, 2), {
+                radianValueNode: props?.anglesRadianValues?.[0],
+                degreeValueNode: props?.anglesDegreeValues?.[0],
+            }),
+            new Angle(anglePoints, {
+                radianValueNode: props?.anglesRadianValues?.[1],
+                degreeValueNode: props?.anglesDegreeValues?.[1],
+            }),
+            new Angle(arrayRotation(anglePoints, 1), {
+                radianValueNode: props?.anglesRadianValues?.[2],
+                degreeValueNode: props?.anglesDegreeValues?.[2],
+            }),
+        ];
+        this.sides = [
+            new Segment(points[1], points[2], {
+                lengthNode: props?.sidesLengths?.[0],
+            }),
+            new Segment(points[0], points[2], {
+                lengthNode: props?.sidesLengths?.[1],
+            }),
+            new Segment(points[0], points[1], {
+                lengthNode: props?.sidesLengths?.[2],
+            }),
+        ];
+        this.commands = [
+            ...points.flatMap((p) => p.toGGBCommand({
+                isFixed: true,
+                showLabel: true,
+            })),
+            ...this.sides.flatMap((s) => s.toGGBCommands(false)),
+        ];
+    }
+    toIdentifiers() {
+        return {
+            points: this.points.map((point) => point.toIdentifiers()),
+            props: {
+                anglesRadianValues: this.props?.anglesRadianValues?.map((n) => n.toIdentifiers()),
+                anglesDegreeValues: this.props?.anglesDegreeValues?.map((n) => n.toIdentifiers()),
+                sidesLengths: this.props?.sidesLengths?.map((n) => n?.toIdentifiers()),
+            },
+        };
+    }
+    getPerimeter() {
+        return this.sides.reduce((acc, curr) => acc + curr.getLength(), 0);
+    }
+    getArea() {
+        const s = this.getPerimeter() / 2;
+        const lengths = this.sides.map((s) => s.getLength());
+        return round(Math.sqrt(s * (s - lengths[0]) * (s - lengths[1]) * (s - lengths[2])), 6);
+    }
+    isRight() {
+        return this.angles.some((a) => a.isRight());
+    }
+    isEquilateral() {
+        const lengths = this.sides.map((s) => s.getLength());
+        return lengths[0] === lengths[1] && lengths[1] === lengths[2];
+    }
+    isIsosceles() {
+        const lengths = this.sides.map((s) => s.getLength());
+        return (lengths[0] === lengths[1] ||
+            lengths[1] === lengths[2] ||
+            lengths[0] === lengths[2]);
+    }
+    isScalene() {
+        const lengths = this.sides.map((s) => s.getLength());
+        return (lengths[0] !== lengths[1] &&
+            lengths[1] !== lengths[2] &&
+            lengths[0] !== lengths[2]);
+    }
+    highlightSide(index, opts) {
+        const side = this.sides[index];
+        if (opts.color)
+            this.commands.push(`SetColor(${side.ggbName}, "${opts.color}")`);
+        if (opts.caption) {
+            this.commands.push(...side.getFitCaptionCommands({
+                text: opts.caption,
+                color: opts.color,
+            }));
+        }
+    }
+    highlightAngle(index, opts) {
+        this.commands.push(...this.angles[index].toCommands(opts));
+    }
+    showSidesLength(hiddenSides) {
+        this.commands.push(...this.sides
+            .filter((s, i) => !hiddenSides?.includes(i))
+            .flatMap((s) => s.getFitCaptionCommands()));
+    }
+    getHeight(summitIndex, opts) {
+        const base = LineConstructor.fromSegment(this.sides[summitIndex]);
+        const perp = base.getPerpendicular(this.points[summitIndex]);
+        const foot = perp.intersect(base, opts?.footName);
+        while (this.name.includes(foot.name)) {
+            foot.name = randomLetter(true);
+        }
+        const segmentHeight = new Segment(this.points[summitIndex], foot);
+        return segmentHeight;
+    }
+    drawHeight(summitIndex, opts) {
+        let height;
+        let foot;
+        if (opts?.footPoint) {
+            foot = opts.footPoint;
+            height = new Segment(this.points[summitIndex], foot);
+        }
+        else {
+            height = this.getHeight(summitIndex, opts);
+            foot = height.pointB;
+        }
+        const angle = new Angle([
+            this.points[summitIndex],
+            foot,
+            this.points[(summitIndex + 1) % 3],
+        ]);
+        this.commands.push(...foot.toGGBCommand(), ...height.toGGBCommands(false, { style: 2 }), ...angle.toCommands());
+        if (!this.sides[summitIndex].includes(foot)) {
+            const distancesToSideSummits = [
+                this.sides[summitIndex].pointA,
+                this.sides[summitIndex].pointB,
+            ].map((p) => p.distanceTo(foot));
+            const closestPoint = distancesToSideSummits[0] < distancesToSideSummits[1]
+                ? this.sides[summitIndex].pointA
+                : this.sides[summitIndex].pointB;
+            const prolongement = new Segment(closestPoint, foot);
+            this.commands.push(...prolongement.toGGBCommands(false, { style: 2 }));
+        }
+    }
+    generateCoords() {
+        const coords = this.points.map((p) => [p.x.evaluate(), p.y.evaluate()]);
+        const [x1, y1, x2, y2, x3, y3] = coords.flatMap((p) => p);
+        const [xMin, xMax, yMin, yMax] = [
+            Math.min(x1, x2, x3),
+            Math.max(x1, x2, x3),
+            Math.min(y1, y2, y3),
+            Math.max(y1, y2, y3),
+        ];
+        const xDelta = Math.abs(xMax - xMin);
+        const yDelta = Math.abs(yMax - yMin);
+        return [
+            xMin - 0.1 * xDelta,
+            xMax + 0.1 * xDelta,
+            yMin - 0.1 * yDelta,
+            yMax + 0.1 * yDelta,
+        ];
+    }
+    drawAngles(hidden, opts) {
+        this.angles.forEach((a, i) => {
+            if (!hidden.includes(i)) {
+                this.commands.push(...a.toCommands({ showValue: false, color: opts?.color }));
+                if (opts?.fitCaption)
+                    this.commands.push(...a.getFitCaptionCommands({
+                        size: "scriptsize",
+                        color: opts?.color,
+                    }));
+            }
+        });
+    }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "math-exercises",
   "type": "module",
-  "version": "3.0.29",
+  "version": "3.0.31",
   "description": "Math exercises generator for middle school and high school",
   "main": "lib/index.js",
   "files": [