math-exercises 2.2.69 → 2.2.70

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

@@ -0,0 +1,26 @@
+import { AlgebraicNode } from "../../tree/nodes/algebraicNode";
+import { Point } from "./point";
+type AngleProps = {
+    radianValueNode?: AlgebraicNode;
+    degreeValueNode?: AlgebraicNode;
+};
+export declare class Angle {
+    points: Point[];
+    radianValueNode?: AlgebraicNode;
+    degreeValueNode?: AlgebraicNode;
+    /**
+     *
+     * @param points [pointA, pointB, pointC] with apex = B
+     */
+    constructor(points: Point[], props?: AngleProps);
+    evaluate(inRadian?: boolean): number;
+    getValueNode(inDegree?: boolean): AlgebraicNode | import("../../tree/nodes/numbers/constantNode").ConstantNode | import("../../tree/nodes/numbers/numberNode").NumberNode;
+    isRight(): boolean;
+    toTex(): string;
+    toCommands(opts?: {
+        color?: string;
+        showValue?: boolean;
+    }): string[];
+}
+export {};
+//# sourceMappingURL=angle.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"angle.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/angle.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAM/D,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAEhC,KAAK,UAAU,GAAG;IAChB,eAAe,CAAC,EAAE,aAAa,CAAC;IAChC,eAAe,CAAC,EAAE,aAAa,CAAC;CACjC,CAAC;AACF,qBAAa,KAAK;IAChB,MAAM,EAAE,KAAK,EAAE,CAAC;IAChB,eAAe,CAAC,EAAE,aAAa,CAAC;IAChC,eAAe,CAAC,EAAE,aAAa,CAAC;IAEhC;;;OAGG;gBACS,MAAM,EAAE,KAAK,EAAE,EAAE,KAAK,CAAC,EAAE,UAAU;IAkB/C,QAAQ,CAAC,QAAQ,UAAQ;IAiBzB,YAAY,CAAC,QAAQ,UAAQ;IAW7B,OAAO;IAIP,KAAK;IAGL,UAAU,CAAC,IAAI,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,OAAO,CAAA;KAAE;CAgB1D"}

package/lib/math/geometry/angle.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Angle = void 0;
+const piNode_1 = require("../../tree/nodes/numbers/piNode");
+const fractionNode_1 = require("../../tree/nodes/operators/fractionNode");
+const multiplyNode_1 = require("../../tree/nodes/operators/multiplyNode");
+const round_1 = require("../utils/round");
+class Angle {
+    /**
+     *
+     * @param points [pointA, pointB, pointC] with apex = B
+     */
+    constructor(points, props) {
+        this.points = points;
+        this.radianValueNode = props?.radianValueNode;
+        this.degreeValueNode = props?.degreeValueNode;
+        if (props?.radianValueNode && !props.degreeValueNode) {
+            this.degreeValueNode = (0, fractionNode_1.frac)((0, multiplyNode_1.multiply)(props.radianValueNode, (180).toTree()), piNode_1.PiNode);
+        }
+        if (props?.degreeValueNode && !props.radianValueNode) {
+            this.radianValueNode = (0, fractionNode_1.frac)((0, multiplyNode_1.multiply)(props.degreeValueNode, piNode_1.PiNode), (180).toTree());
+        }
+    }
+    evaluate(inRadian = false) {
+        if (this.degreeValueNode || this.radianValueNode) {
+            if (inRadian)
+                return this.radianValueNode.evaluate();
+            return this.degreeValueNode.evaluate();
+        }
+        const coords = this.points.map((p) => [p.x.evaluate(), p.y.evaluate()]);
+        const [x1, y1, x2, y2, x3, y3] = coords.flatMap((p) => p);
+        const angleBA = Math.atan2(y1 - y2, x1 - x2);
+        const angleBC = Math.atan2(y3 - y2, x3 - x2);
+        let angleRadians = angleBC - angleBA;
+        if (angleRadians < 0) {
+            angleRadians += 2 * Math.PI;
+        }
+        if (inRadian)
+            return (0, round_1.round)(angleRadians, 4);
+        return (0, round_1.round)(angleRadians * (180 / Math.PI), 4);
+    }
+    getValueNode(inDegree = false) {
+        if (this.degreeValueNode || this.radianValueNode) {
+            if (inDegree)
+                return this.degreeValueNode;
+            return this.radianValueNode;
+        }
+        const angle = this.evaluate();
+        if (inDegree)
+            return angle.toTree();
+        return (0, fractionNode_1.frac)((0, multiplyNode_1.multiply)(angle, piNode_1.PiNode), 180).simplify();
+    }
+    isRight() {
+        const value = this.evaluate();
+        return Math.abs(value) - 90 < 0.000001 || Math.abs(value) - 270 < 0.000001;
+    }
+    toTex() {
+        return `\\widehat{${this.points[0].name}${this.points[1].name}${this.points[2].name}}`;
+    }
+    toCommands(opts) {
+        const name = `angle_{${this.points[0].name}${this.points[1].name}${this.points[2].name}}`;
+        const cmds = [
+            `${name} = Angle(${this.points[0].name},${this.points[1].name},${this.points[2].name}, xAxis)`,
+            `ShowLabel(${name}, ${opts?.showValue ? "true" : "false"})`,
+        ];
+        cmds.push(`SetCaption(${name}, "$\\footnotesize ${(0, round_1.round)(this.evaluate(), 1).frenchify() + "°"}$")`);
+        if (opts?.color) {
+            cmds.push(`SetColor(${name}, "${opts.color}")`);
+        }
+        return cmds;
+    }
+}
+exports.Angle = Angle;

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

@@ -4,6 +4,7 @@ import { EqualNode } from "../../tree/nodes/equations/equalNode";
 import { AddNode } from "../../tree/nodes/operators/addNode";
 import { SubstractNode } from "../../tree/nodes/operators/substractNode";
 import { Point, PointIdentifiers } from "./point";
+import { Segment } from "./segment";
 import { Vector } from "./vector";
 export type LineIdentifiers = {
     name?: string;
@@ -13,6 +14,7 @@ export type LineIdentifiers = {
 export declare abstract class LineConstructor {
     static random(name?: string): Line;
     static fromIdentifiers(identifiers: LineIdentifiers): Line;
+    static fromSegment(segment: Segment): Line;
 }
 export declare class Line {
     pointA: Point;
@@ -30,7 +32,9 @@ export declare class Line {
         pointB: PointIdentifiers;
     };
     isParallele(line: Line): boolean;
+    getDirectorVector(): Vector;
     getParallele(point: Point): Line;
+    getPerpendicular(point: Point): Line;
     includes(point: Point, allowApprox?: boolean): boolean;
     getRandomPoint(name?: string): Point;
     getEquation: (u: Vector, a: Point) => EqualNode;
@@ -38,7 +42,7 @@ export declare class Line {
     toCartesian(): AddNode;
     toCartesianCoeffs(): {
         a: AlgebraicNode;
-        b: import("../../tree/nodes/functions/oppositeNode").OppositeNode;
+        b: import("../../tree/nodes/functions/oppositeNode").OppositeNode<AlgebraicNode>;
         c: SubstractNode;
     };
     toTex(): string;

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

@@ -1 +1 @@
-{"version":3,"file":"line.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/line.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,mDAAmD,CAAC;AAEvF,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAC/D,OAAO,EAAE,SAAS,EAAE,MAAM,sCAAsC,CAAC;AAGjE,OAAO,EAAE,OAAO,EAAO,MAAM,oCAAoC,CAAC;AAMlE,OAAO,EACL,aAAa,EAEd,MAAM,0CAA0C,CAAC;AAKlD,OAAO,EAAE,KAAK,EAAoB,gBAAgB,EAAE,MAAM,SAAS,CAAC;AACpE,OAAO,EAAE,MAAM,EAAqB,MAAM,UAAU,CAAC;AAErD,MAAM,MAAM,eAAe,GAAG;IAC5B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,gBAAgB,CAAC;IACzB,MAAM,EAAE,gBAAgB,CAAC;CAC1B,CAAC;AACF,8BAAsB,eAAe;IACnC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,MAAM;IAK3B,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,eAAe;CAOpD;AACD,qBAAa,IAAI;IACf,MAAM,EAAE,KAAK,CAAC;IACd,MAAM,EAAE,KAAK,CAAC;IACd,UAAU,EAAE,OAAO,CAAC;IACpB,CAAC,EAAE,aAAa,GAAG,SAAS,CAAC;IAC7B,CAAC,EAAE,aAAa,GAAG,SAAS,CAAC;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;gBACJ,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,CAAC,EAAE,MAAM;IAsBvD,aAAa;;;;;IAOb,WAAW,CAAC,IAAI,EAAE,IAAI;IAYtB,YAAY,CAAC,KAAK,EAAE,KAAK;IAWzB,QAAQ,CAAC,KAAK,EAAE,KAAK,EAAE,WAAW,GAAE,OAAe;IAenD,cAAc,CAAC,IAAI,CAAC,EAAE,MAAM;IAa5B,WAAW,MAAO,MAAM,KAAK,KAAK,KAAG,SAAS,CAmB5C;IAEF,oBAAoB,IAAI,SAAS;IAuBjC,WAAW;IAMX,iBAAiB;;;;;IAcjB,KAAK;IAGL,gBAAgB;IAIhB,aAAa,CACX,iBAAiB,EAAE,OAAO,EAC1B,EACE,OAAc,EACd,SAAiB,EACjB,yBAAgC,GACjC,GAAE,kBAAuB;IAqB5B,SAAS,CAAC,IAAI,EAAE,IAAI,EAAE,aAAa,CAAC,EAAE,MAAM;CAW7C"}
+{"version":3,"file":"line.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/line.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,mDAAmD,CAAC;AAEvF,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAC/D,OAAO,EAAE,SAAS,EAAE,MAAM,sCAAsC,CAAC;AAGjE,OAAO,EAAE,OAAO,EAAO,MAAM,oCAAoC,CAAC;AAMlE,OAAO,EACL,aAAa,EAEd,MAAM,0CAA0C,CAAC;AAKlD,OAAO,EAAE,KAAK,EAAoB,gBAAgB,EAAE,MAAM,SAAS,CAAC;AACpE,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,MAAM,EAAqB,MAAM,UAAU,CAAC;AAErD,MAAM,MAAM,eAAe,GAAG;IAC5B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,gBAAgB,CAAC;IACzB,MAAM,EAAE,gBAAgB,CAAC;CAC1B,CAAC;AACF,8BAAsB,eAAe;IACnC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,MAAM;IAK3B,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,eAAe;IAOnD,MAAM,CAAC,WAAW,CAAC,OAAO,EAAE,OAAO;CAGpC;AACD,qBAAa,IAAI;IACf,MAAM,EAAE,KAAK,CAAC;IACd,MAAM,EAAE,KAAK,CAAC;IACd,UAAU,EAAE,OAAO,CAAC;IACpB,CAAC,EAAE,aAAa,GAAG,SAAS,CAAC;IAC7B,CAAC,EAAE,aAAa,GAAG,SAAS,CAAC;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;gBACJ,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,CAAC,EAAE,MAAM;IAsBvD,aAAa;;;;;IAOb,WAAW,CAAC,IAAI,EAAE,IAAI;IAYtB,iBAAiB;IAIjB,YAAY,CAAC,KAAK,EAAE,KAAK;IAYzB,gBAAgB,CAAC,KAAK,EAAE,KAAK;IAW7B,QAAQ,CAAC,KAAK,EAAE,KAAK,EAAE,WAAW,GAAE,OAAe;IAenD,cAAc,CAAC,IAAI,CAAC,EAAE,MAAM;IAa5B,WAAW,MAAO,MAAM,KAAK,KAAK,KAAG,SAAS,CAmB5C;IAEF,oBAAoB,IAAI,SAAS;IAuBjC,WAAW;IAMX,iBAAiB;;;;;IAcjB,KAAK;IAGL,gBAAgB;IAIhB,aAAa,CACX,iBAAiB,EAAE,OAAO,EAC1B,EACE,OAAc,EACd,SAAiB,EACjB,yBAAgC,GACjC,GAAE,kBAAuB;IAqB5B,SAAS,CAAC,IAAI,EAAE,IAAI,EAAE,aAAa,CAAC,EAAE,MAAM;CAW7C"}

package/lib/math/geometry/line.js

@@ -23,6 +23,9 @@ class LineConstructor {
     static fromIdentifiers(identifiers) {
         return new Line(point_1.PointConstructor.fromIdentifiers(identifiers.pointA), point_1.PointConstructor.fromIdentifiers(identifiers.pointB), identifiers.name);
     }
+    static fromSegment(segment) {
+        return new Line(segment.pointA, segment.pointB);
+    }
 }
 exports.LineConstructor = LineConstructor;
 class Line {
@@ -73,6 +76,9 @@ class Line {
         const lineVec = vector_1.VectorConstructor.fromPoints(line.pointA, line.pointB);
         return vec.isColinear(lineVec);
     }
+    getDirectorVector() {
+        return vector_1.VectorConstructor.fromPoints(this.pointA, this.pointB);
+    }
     getParallele(point) {
         if (this.isVertical) {
             const y = (0, addNode_1.add)(point.y, 1).simplify();
@@ -84,6 +90,17 @@ class Line {
         const secondPoint = new point_1.Point("P", x, y);
         return new Line(point, secondPoint);
     }
+    getPerpendicular(point) {
+        if (this.isVertical) {
+            const x = (0, addNode_1.add)(point.x, 1).simplify();
+            const secondPoint = new point_1.Point("P", x, point.y);
+            return new Line(point, secondPoint);
+        }
+        const vec = this.getDirectorVector();
+        const ortho = vec.getOrthogonal();
+        const secondPoint = ortho.getEndPoint(point);
+        return new Line(point, secondPoint);
+    }
     includes(point, allowApprox = false) {
         if (this.isVertical) {
             if (allowApprox) {

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

@@ -0,0 +1,23 @@
+import { Point, PointIdentifiers } from "./point";
+import { Quadrilateral } from "./quadrilateral";
+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/parallelogram.d.ts.map

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

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Parallelogram = exports.ParallelogramConstructor = void 0;
+const randfloat_1 = require("../utils/random/randfloat");
+const point_1 = require("./point");
+const quadrilateral_1 = require("./quadrilateral");
+class ParallelogramConstructor {
+    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 xRand2 = (0, randfloat_1.randfloat)(3, 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", (-xRand2).toTree(), (0).toTree()).rotate(angle + additionalAngle, origin);
+        const D = new point_1.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) => point_1.PointConstructor.fromIdentifiers(point)));
+    }
+}
+exports.ParallelogramConstructor = ParallelogramConstructor;
+class Parallelogram extends quadrilateral_1.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)`);
+            });
+        }
+    }
+}
+exports.Parallelogram = Parallelogram;

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

@@ -8,6 +8,7 @@ export type PointIdentifiers = {
     y: NodeIdentifiers;
 };
 export declare abstract class PointConstructor {
+    static origin(name?: string): Point;
     static random(name: string, min?: number, max?: number): Point;
     static fromIdentifiers(identifiers: PointIdentifiers): Point;
     static onSegment(A: Point, B: Point, name: string, { spacing, coefficient, }?: {
@@ -32,6 +33,8 @@ export declare class Point {
     distanceTo(B: Point): number;
     equals(B: Point): boolean;
     isAligned(B: Point, C: Point): boolean;
+    toMathString(): string;
     toGGBCommand({ isFixed, showLabel, style, size, color, }?: ToGGBCommandsProps): string[];
+    rotate(angle: number, center: Point): Point;
 }
 //# sourceMappingURL=point.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"point.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/point.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAG/D,OAAO,EAAE,kBAAkB,EAAE,MAAM,mDAAmD,CAAC;AACvF,OAAO,EAEL,eAAe,EAChB,MAAM,kCAAkC,CAAC;AAG1C,MAAM,MAAM,gBAAgB,GAAG;IAC7B,EAAE,EAAE,OAAO,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,eAAe,CAAC;IACnB,CAAC,EAAE,eAAe,CAAC;CACpB,CAAC;AACF,8BAAsB,gBAAgB;IACpC,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,SAAM,EAAE,GAAG,SAAK,GAAG,KAAK;IAMvD,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,gBAAgB;IAQpD,MAAM,CAAC,SAAS,CACd,CAAC,EAAE,KAAK,EACR,CAAC,EAAE,KAAK,EACR,IAAI,EAAE,MAAM,EACZ,EACE,OAAa,EACb,WAAW,GACZ,GAAE;QAAE,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,WAAW,CAAC,EAAE,MAAM,CAAA;KAAO;IAQpD,MAAM,CAAC,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE;IAetC,MAAM,CAAC,cAAc,CAAC,GAAG,EAAE,MAAM;CAclC;AAED,qBAAa,KAAK;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;gBACL,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE,aAAa;IAM5D,KAAK,IAAI,MAAM;IAGf,aAAa,IAAI,gBAAgB;IAQjC,eAAe,IAAI,MAAM;IAGzB,QAAQ,IAAI,MAAM;IAIlB,UAAU,IAAI,MAAM;IAIpB,UAAU,IAAI,MAAM;IAIpB,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,SAAM,GAAG,KAAK;IAiBrC,UAAU,CAAC,CAAC,EAAE,KAAK,GAAG,MAAM;IAM5B,MAAM,CAAC,CAAC,EAAE,KAAK,GAAG,OAAO;IAGzB,SAAS,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK;IAM5B,YAAY,CAAC,EACX,OAAc,EACd,SAAgB,EAChB,KAAK,EACL,IAAI,EACJ,KAAK,GACN,GAAE,kBAAuB;CAiB3B"}
+{"version":3,"file":"point.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/point.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAG/D,OAAO,EAAE,kBAAkB,EAAE,MAAM,mDAAmD,CAAC;AACvF,OAAO,EAEL,eAAe,EAChB,MAAM,kCAAkC,CAAC;AAM1C,MAAM,MAAM,gBAAgB,GAAG;IAC7B,EAAE,EAAE,OAAO,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,eAAe,CAAC;IACnB,CAAC,EAAE,eAAe,CAAC;CACpB,CAAC;AACF,8BAAsB,gBAAgB;IACpC,MAAM,CAAC,MAAM,CAAC,IAAI,SAAM;IAGxB,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,SAAM,EAAE,GAAG,SAAK,GAAG,KAAK;IAMvD,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,gBAAgB;IAQpD,MAAM,CAAC,SAAS,CACd,CAAC,EAAE,KAAK,EACR,CAAC,EAAE,KAAK,EACR,IAAI,EAAE,MAAM,EACZ,EACE,OAAa,EACb,WAAW,GACZ,GAAE;QAAE,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,WAAW,CAAC,EAAE,MAAM,CAAA;KAAO;IAQpD,MAAM,CAAC,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE;IAetC,MAAM,CAAC,cAAc,CAAC,GAAG,EAAE,MAAM;CAclC;AAED,qBAAa,KAAK;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;gBACL,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE,aAAa;IAM5D,KAAK,IAAI,MAAM;IAGf,aAAa,IAAI,gBAAgB;IAQjC,eAAe,IAAI,MAAM;IAGzB,QAAQ,IAAI,MAAM;IAIlB,UAAU,IAAI,MAAM;IAIpB,UAAU,IAAI,MAAM;IAIpB,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,SAAM,GAAG,KAAK;IAiBrC,UAAU,CAAC,CAAC,EAAE,KAAK,GAAG,MAAM;IAM5B,MAAM,CAAC,CAAC,EAAE,KAAK,GAAG,OAAO;IAGzB,SAAS,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK;IAK5B,YAAY;IAGZ,YAAY,CAAC,EACX,OAAc,EACd,SAAgB,EAChB,KAAK,EACL,IAAI,EACJ,KAAK,GACN,GAAE,kBAAuB;IAiB1B,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK;CAiBpC"}

package/lib/math/geometry/point.js

@@ -8,7 +8,13 @@ const vector_1 = require("./vector");
 const randint_1 = require("../utils/random/randint");
 const nodeConstructor_1 = require("../../tree/nodes/nodeConstructor");
 const randfloat_1 = require("../utils/random/randfloat");
+const substractNode_1 = require("../../tree/nodes/operators/substractNode");
+const multiplyNode_1 = require("../../tree/nodes/operators/multiplyNode");
+const addNode_1 = require("../../tree/nodes/operators/addNode");
 class PointConstructor {
+    static origin(name = "O") {
+        return new Point(name, new numberNode_1.NumberNode(0), new numberNode_1.NumberNode(0));
+    }
     static random(name, min = -10, max = 11) {
         const x = (0, randint_1.randint)(min, max);
         const y = (0, randint_1.randint)(min, max);
@@ -103,6 +109,9 @@ class Point {
         const AC = vector_1.VectorConstructor.fromPoints(this, C);
         return AB.isColinear(AC);
     }
+    toMathString() {
+        return `(${this.x.toMathString()}, ${this.y.toMathString()})`;
+    }
     toGGBCommand({ isFixed = true, showLabel = true, style, size, color, } = {}) {
         const commands = [
             `${this.name} = (${this.x.toMathString()}, ${this.y.toMathString()})`,
@@ -120,5 +129,12 @@ class Point {
         }
         return commands;
     }
+    rotate(angle, center) {
+        //x' = cos(t)*x -sin(t)*y
+        //y' = sin(t)*x + cos(t)*y
+        const cos = Math.cos(angle);
+        const sin = Math.sin(angle);
+        return new Point(this.name, (0, substractNode_1.substract)((0, multiplyNode_1.multiply)(cos, this.x).simplify(), (0, multiplyNode_1.multiply)(sin, this.y).simplify()).simplify(), (0, addNode_1.add)((0, multiplyNode_1.multiply)(sin, this.x).simplify(), (0, multiplyNode_1.multiply)(cos, this.y).simplify()).simplify());
+    }
 }
 exports.Point = Point;

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

@@ -0,0 +1,15 @@
+import { Point } from "./point";
+import { Segment } from "./segment";
+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/quadrilateral.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quadrilateral.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/quadrilateral.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAChC,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,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/quadrilateral.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Quadrilateral = void 0;
+const segment_1 = require("./segment");
+class Quadrilateral {
+    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_1.Segment(points[0], points[1]),
+            new segment_1.Segment(points[1], points[2]),
+            new segment_1.Segment(points[2], points[3]),
+            new segment_1.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;
+    }
+}
+exports.Quadrilateral = Quadrilateral;

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"rectangle.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/rectangle.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,KAAK,EAAoB,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAIpE,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/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"}