math-exercises 2.2.18 → 2.2.19

package/lib/exercises/math/geometry/euclidianConstructions/buildMediatriceWithCompass.d.ts

@@ -0,0 +1,8 @@
+import { Exercise } from "../../../../exercises/exercise";
+type Identifiers = {
+    A: number[];
+    B: number[];
+};
+export declare const buildMediatriceWithCompass: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=buildMediatriceWithCompass.d.ts.map

package/lib/exercises/math/geometry/euclidianConstructions/buildMediatriceWithCompass.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildMediatriceWithCompass.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/euclidianConstructions/buildMediatriceWithCompass.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,0BAA0B,CAAC;AAalC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,EAAE,CAAC;IACZ,CAAC,EAAE,MAAM,EAAE,CAAC;CACb,CAAC;AA8GF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAe5D,CAAC"}

package/lib/exercises/math/geometry/euclidianConstructions/buildMediatriceWithCompass.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildMediatriceWithCompass = void 0;
+const exercise_1 = require("../../../../exercises/exercise");
+const isGGBLine_1 = require("../../../../exercises/utils/geogebra/isGGBLine");
+const toolBarConstructor_1 = require("../../../../exercises/utils/geogebra/toolBarConstructor");
+const randomSegmentName_1 = require("../../../../exercises/utils/geometry/randomSegmentName");
+const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const colors_1 = require("../../../../geogebra/colors");
+const geogebraConstructor_1 = require("../../../../geogebra/geogebraConstructor");
+const point_1 = require("../../../../math/geometry/point");
+const segment_1 = require("../../../../math/geometry/segment");
+const getBuildMediatriceWithCompassQuestion = () => {
+    const segmentName = (0, randomSegmentName_1.randomSegmentName)();
+    const A = segmentName[0];
+    const B = segmentName[1];
+    const pointA = point_1.PointConstructor.random(A);
+    const pointB = point_1.PointConstructor.random(B);
+    const segment = new segment_1.Segment(pointA, pointB);
+    const length = segment.getLength();
+    const [xa, ya] = [pointA.x.evaluate({}), pointA.y.evaluate({})];
+    const [xb, yb] = [pointB.x.evaluate({}), pointB.y.evaluate({})];
+    const xMin = Math.min(xa, xb) - length;
+    const xMax = Math.max(xa, xb) + length;
+    const yMin = Math.min(ya, yb) - length;
+    const yMax = Math.max(ya, yb) + length;
+    const ggbAnswer = [
+        `${pointA.toGGBCommand()}`,
+        `${pointB.toGGBCommand()}`,
+        `SetFixed(${A}, true)`,
+        `SetFixed(${B}, true)`,
+        `ShowLabel(${A}, true)`,
+        `ShowLabel(${B}, true)`,
+        `Seg = Segment(${A},${B})`,
+        `C_1 = Circle(${A},${B})`,
+        `C_2 = Circle(${B},${A})`,
+        `I_1 = Intersect(C_1, C_2,1)`,
+        `I_2 = Intersect(C_1, C_2,2)`,
+        `Ans = Line(I_1,I_2)`,
+        `SetColor(Ans, "${colors_1.greenDark}")`,
+    ];
+    const studentGGB = new geogebraConstructor_1.GeogebraConstructor({
+        commands: [
+            `${pointA.toGGBCommand()}`,
+            `${pointB.toGGBCommand()}`,
+            `SetFixed(${A}, true)`,
+            `SetFixed(${B}, true)`,
+            `ShowLabel(${A}, true)`,
+            `ShowLabel(${B}, true)`,
+            `Seg = Segment(${A},${B})`,
+        ],
+        hideGrid: true,
+        hideAxes: true,
+        customToolBar: (0, toolBarConstructor_1.toolBarConstructor)({
+            join: true,
+            circleTwoPoints: true,
+            intersect: true,
+        }),
+    });
+    const question = {
+        ggbAnswer: ggbAnswer,
+        instruction: `Avec les outils disponibles, tracer la médiatrice du segment $[${segmentName}]$.`,
+        keys: [],
+        answerFormat: "tex",
+        identifiers: {
+            A: [xa, ya],
+            B: [xb, yb],
+        },
+        studentGgbOptions: studentGGB.getOptions({
+            coords: [xMin, xMax, yMin, yMax],
+        }),
+    };
+    return question;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    while (propositions.length < n) {
+        throw Error("QCM not implemented");
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isGGBAnswerValid = (ans, { ggbAnswer, A, B }) => {
+    const lines = ans.filter((s) => (0, isGGBLine_1.isGGBLine)(s));
+    const segmentPointA = new point_1.Point("Seg_A", A[0].toTree(), A[1].toTree());
+    const segmentPointB = new point_1.Point("Seg_B", B[0].toTree(), B[1].toTree());
+    if (!lines.length)
+        return false;
+    for (const line of lines) {
+        const formatted = line
+            .replace(" ", "")
+            .replace("Line", "")
+            .replace("[", "")
+            .replace("]", "")
+            .split("=")[1];
+        const [nameA, nameB] = formatted.split(",");
+        const pointACmd = ans.find((s) => s.startsWith(nameA));
+        const pointBCmd = ans.find((s) => s.startsWith(nameB));
+        if (!pointACmd || !pointBCmd)
+            return false;
+        const pointA = point_1.PointConstructor.fromGGBCommand(pointACmd);
+        const pointB = point_1.PointConstructor.fromGGBCommand(pointBCmd);
+        if (pointA.distanceTo(segmentPointA) - pointA.distanceTo(segmentPointB) <
+            0.0000001 &&
+            pointB.distanceTo(segmentPointA) - pointB.distanceTo(segmentPointB) <
+                0.0000001)
+            return true;
+    }
+    return false;
+};
+exports.buildMediatriceWithCompass = {
+    id: "buildMediatriceWithCompass",
+    connector: "=",
+    label: "Tracer une médiatrice avec un compas",
+    levels: [],
+    isSingleStep: true,
+    sections: [],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getBuildMediatriceWithCompassQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isGGBAnswerValid,
+    subject: "Mathématiques",
+    answerType: "GGB",
+};

package/lib/exercises/math/geometry/euclidianConstructions/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./buildMediatriceWithCompass";
+//# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/geometry/euclidianConstructions/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/euclidianConstructions/index.ts"],"names":[],"mappings":"AAAA,cAAc,8BAA8B,CAAC"}

package/lib/exercises/math/geometry/euclidianConstructions/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./buildMediatriceWithCompass"), exports);

package/lib/exercises/math/geometry/index.d.ts

@@ -6,4 +6,5 @@ export * from "./thales";
 export * from "./vectors";
 export * from "./convexity";
 export * from "./volumes";
+export * from "./euclidianConstructions";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/geometry/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/geometry/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,aAAa,CAAC;AAC5B,cAAc,cAAc,CAAC;AAC7B,cAAc,aAAa,CAAC;AAC5B,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC;AAC5B,cAAc,WAAW,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/geometry/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,aAAa,CAAC;AAC5B,cAAc,cAAc,CAAC;AAC7B,cAAc,aAAa,CAAC;AAC5B,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC;AAC5B,cAAc,WAAW,CAAC;AAE1B,cAAc,0BAA0B,CAAC"}

package/lib/exercises/math/geometry/index.js

@@ -22,3 +22,5 @@ __exportStar(require("./thales"), exports);
 __exportStar(require("./vectors"), exports);
 __exportStar(require("./convexity"), exports);
 __exportStar(require("./volumes"), exports);
+// export * from "./triangles";
+__exportStar(require("./euclidianConstructions"), exports);

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

@@ -0,0 +1 @@
+//# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/geometry/triangles/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/triangles/index.ts"],"names":[],"mappings":""}

package/lib/exercises/math/geometry/triangles/index.js

@@ -0,0 +1,2 @@
+"use strict";
+// export * from './traceMedianInTriangle'

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

@@ -0,0 +1 @@
+//# sourceMappingURL=traceMedianInTriangle.d.ts.map

package/lib/exercises/math/geometry/triangles/traceMedianInTriangle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"traceMedianInTriangle.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/triangles/traceMedianInTriangle.ts"],"names":[],"mappings":""}

package/lib/exercises/math/geometry/triangles/traceMedianInTriangle.js

@@ -0,0 +1,55 @@
+"use strict";
+// import {
+//   Exercise,
+//   Proposition,
+//   QCMGenerator,
+//   Question,
+//   QuestionGenerator,
+//   VEA,
+//   GGBVEA,
+//   addValidProp,
+//   shuffleProps,
+//   tryToAddWrongProp,
+// } from '../../../../exercises/exercise';
+// import { getDistinctQuestions } from '../../../../exercises/utils/getDistinctQuestions';
+// type Identifiers = {
+// };
+// const getTraceMedianInTriangleQuestion: QuestionGenerator<Identifiers>  = ()=>{
+//   const question: Question<Identifiers> = {
+//     answer,
+//     instruction: ``,
+//     keys: [],
+//     answerFormat: 'tex',
+//     identifiers : {}
+//   };
+//   return question;
+// }
+// const getPropositions: QCMGenerator<Identifiers> = (n, { answer }) => {
+//   const propositions: Proposition[] = [];
+//   addValidProp(propositions, answer);
+//   while (propositions.length < n) {
+//     throw Error("QCM not implemented")
+//   }
+//   return shuffleProps(propositions, n);
+// };
+// const isAnswerValid: VEA<Identifiers> = (ans, {answer})=>{
+//   throw Error("VEA not implemented")
+// }
+// const isGGBAnswerValid: GGBVEA<Identifiers> = (ans, {ggbAnswer}) => {
+//   throw Error("GGBVea not implemented")
+// }
+// export const traceMedianInTriangle: Exercise<Identifiers> = {
+//   id: 'traceMedianInTriangle',
+//   connector: "",
+//   label: "",
+//   levels: [],
+//   isSingleStep: true,
+//   sections: [],
+//   generator: (nb: number) => getDistinctQuestions(getTraceMedianInTriangleQuestion, nb),
+//   qcmTimer: 60,
+//   freeTimer: 60,
+//   getPropositions,
+//   isAnswerValid,
+//   isGGBAnswerValid,
+//   subject: "Mathématiques"
+// };

package/lib/exercises/utils/geogebra/toolBarConstructor.d.ts

@@ -5,5 +5,6 @@ export declare const toolBarConstructor: (options: {
     orthogonal?: boolean;
     intersect?: boolean;
     vector?: boolean;
+    circleTwoPoints?: boolean;
 }) => string;
 //# sourceMappingURL=toolBarConstructor.d.ts.map

package/lib/exercises/utils/geogebra/toolBarConstructor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"toolBarConstructor.d.ts","sourceRoot":"","sources":["../../../../src/exercises/utils/geogebra/toolBarConstructor.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,kBAAkB,YAAa;IAC1C,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB,WASA,CAAC"}
+{"version":3,"file":"toolBarConstructor.d.ts","sourceRoot":"","sources":["../../../../src/exercises/utils/geogebra/toolBarConstructor.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,kBAAkB,YAAa;IAC1C,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B,WAUA,CAAC"}

package/lib/exercises/utils/geogebra/toolBarConstructor.js

@@ -15,6 +15,8 @@ const toolBarConstructor = (options) => {
         customToolBar += "||5";
     if (options.vector)
         customToolBar += "||7";
+    if (options.circleTwoPoints)
+        customToolBar += "||10";
     return customToolBar;
 };
 exports.toolBarConstructor = toolBarConstructor;

package/lib/exercises/utils/geometry/randomSegmentName.d.ts

@@ -0,0 +1,2 @@
+export declare const randomSegmentName: () => string;
+//# sourceMappingURL=randomSegmentName.d.ts.map

package/lib/exercises/utils/geometry/randomSegmentName.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"randomSegmentName.d.ts","sourceRoot":"","sources":["../../../../src/exercises/utils/geometry/randomSegmentName.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,iBAAiB,cAI7B,CAAC"}

package/lib/exercises/utils/geometry/randomSegmentName.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.randomSegmentName = void 0;
+const randomLetter_1 = require("../../../utils/strings/randomLetter");
+const randomSegmentName = () => {
+    const A = (0, randomLetter_1.randomLetter)(true);
+    const B = (0, randomLetter_1.randomLetter)(true, [A]);
+    return `${A}${B}`;
+};
+exports.randomSegmentName = randomSegmentName;

package/lib/index.d.ts

@@ -964,6 +964,9 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
     width: number;
     height: number;
     angle: number;
+}> | import("./exercises/exercise").Exercise<{
+    A: number[];
+    B: number[];
 }> | import("./exercises/exercise").Exercise<{
     coeffs: number[];
     to: string;

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAaA,OAAO,yBAAyB,CAAC;AAEjC,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAaA,OAAO,yBAAyB,CAAC;AAEjC,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,CAAC"}

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

@@ -10,7 +10,7 @@ export declare class Line {
     b: AlgebraicNode | undefined;
     constructor(pointA: Point, pointB: Point);
     getParallele(point: Point): Line;
-    includes(point: Point): boolean;
+    includes(point: Point, allowApprox?: boolean): boolean;
     getRandomPoint(name?: string): Point;
     getEquation: (u: Vector, a: Point) => EqualNode;
     getCartesianEquation(): EqualNode;

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,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAC/D,OAAO,EAAE,SAAS,EAAE,MAAM,sCAAsC,CAAC;AAQjE,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAChC,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAElC,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;gBACjB,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK;IAkBxC,YAAY,CAAC,KAAK,EAAE,KAAK;IASzB,QAAQ,CAAC,KAAK,EAAE,KAAK;IAarB,cAAc,CAAC,IAAI,CAAC,EAAE,MAAM;IAa5B,WAAW,MAAO,MAAM,KAAK,KAAK,KAAG,SAAS,CAmB5C;IAEF,oBAAoB,IAAI,SAAS;CAsBlC"}
+{"version":3,"file":"line.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/line.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAC/D,OAAO,EAAE,SAAS,EAAE,MAAM,sCAAsC,CAAC;AAQjE,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAChC,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAElC,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;gBACjB,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK;IAkBxC,YAAY,CAAC,KAAK,EAAE,KAAK;IASzB,QAAQ,CAAC,KAAK,EAAE,KAAK,EAAE,WAAW,GAAE,OAAe;IAgBnD,cAAc,CAAC,IAAI,CAAC,EAAE,MAAM;IAa5B,WAAW,MAAO,MAAM,KAAK,KAAK,KAAG,SAAS,CAmB5C;IAEF,oBAAoB,IAAI,SAAS;CAsBlC"}

package/lib/math/geometry/line.js

@@ -47,11 +47,20 @@ class Line {
         const secondPoint = new point_1.Point("D", x, y);
         return new Line(point, secondPoint);
     }
-    includes(point) {
+    includes(point, allowApprox = false) {
         if (this.isVertical) {
-            return point.x.equals(this.pointA.x);
+            if (allowApprox) {
+            }
+            else
+                return point.x.equals(this.pointA.x);
         }
-        return (new substractNode_1.SubstractNode(point.y, new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(this.a, point.x), this.b)).evaluate({}) === 0);
+        const evaluation = new substractNode_1.SubstractNode(point.y, new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(this.a, point.x), this.b)).evaluate({});
+        console.log("eval", evaluation);
+        if (allowApprox) {
+            return Math.abs(evaluation) < 0.0000001;
+        }
+        else
+            return evaluation === 0;
     }
     //! caution: simplify ne gère pas bien ici
     getRandomPoint(name) {

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

@@ -3,6 +3,7 @@ import { AlgebraicNode } from "../../tree/nodes/algebraicNode";
 export declare abstract class PointConstructor {
     static random(name: string): Point;
     static randomDifferent(names: string[]): Point[];
+    static fromGGBCommand(str: string): Point;
 }
 export declare class Point {
     name: string;

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":"AAAA,OAAO,EAAE,OAAO,EAAY,MAAM,uBAAuB,CAAC;AAI1D,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAI/D,8BAAsB,gBAAgB;IACpC,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,KAAK;IAMlC,MAAM,CAAC,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE;CAevC;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;;;;;;;;;;IAQb,eAAe,IAAI,MAAM;IAGzB,QAAQ,IAAI,MAAM;IAIlB,UAAU,IAAI,MAAM;IAMpB,UAAU,IAAI,MAAM;IAMpB,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;CAKb"}
+{"version":3,"file":"point.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/point.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAY,MAAM,uBAAuB,CAAC;AAI1D,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAI/D,8BAAsB,gBAAgB;IACpC,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,KAAK;IAMlC,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;;;;;;;;;;IAQb,eAAe,IAAI,MAAM;IAGzB,QAAQ,IAAI,MAAM;IAIlB,UAAU,IAAI,MAAM;IAMpB,UAAU,IAAI,MAAM;IAMpB,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;CAKb"}

package/lib/math/geometry/point.js

@@ -27,6 +27,16 @@ class PointConstructor {
         }
         return res;
     }
+    static fromGGBCommand(str) {
+        const formatted = str.replace(" ", "");
+        const name = formatted.split("=")[0];
+        const [x, y] = formatted
+            .split("=")[1]
+            .replace("(", "")
+            .replace(")", "")
+            .split(",");
+        return new Point(name, new numberNode_1.NumberNode(Number(x)), new numberNode_1.NumberNode(Number(y)));
+    }
 }
 exports.PointConstructor = PointConstructor;
 class Point {

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

@@ -0,0 +1,9 @@
+import { Point } from "./point";
+export declare class Segment {
+    pointA: Point;
+    pointB: Point;
+    constructor(pointA: Point, pointB: Point);
+    getLength(): number;
+    getName(): string;
+}
+//# sourceMappingURL=segment.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"segment.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/segment.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAEhC,qBAAa,OAAO;IAClB,MAAM,EAAE,KAAK,CAAC;IACd,MAAM,EAAE,KAAK,CAAC;gBACF,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK;IAIxC,SAAS;IAGT,OAAO;CAMR"}

package/lib/math/geometry/segment.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Segment = void 0;
+class Segment {
+    constructor(pointA, pointB) {
+        this.pointA = pointA;
+        this.pointB = pointB;
+    }
+    getLength() {
+        return this.pointA.distanceTo(this.pointB);
+    }
+    getName() {
+        return `\\left[${this.pointA.name}, ${this.pointB.name}\\right]`;
+    }
+}
+exports.Segment = Segment;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "math-exercises",
-  "version": "2.2.18",
+  "version": "2.2.19",
   "description": "Math exercises generator for middle school and high school",
   "main": "lib/index.js",
   "files": [