math-exercises 2.1.25 → 2.1.26-beta.10

package/lib/exercises/trigonometry/trigonometryAngleCalcul.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trigonometryAngleCalcul = void 0;
+const exercise_1 = require("../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../exercises/utils/getDistinctQuestions");
+const geogebraConstructor_1 = require("../../geogebra/geogebraConstructor");
+const triangles_1 = require("../../math/geometry/triangles");
+const randint_1 = require("../../math/utils/random/randint");
+const round_1 = require("../../math/utils/round");
+const shuffle_1 = require("../../utils/shuffle");
+const getTrigonometryAngleCalcul = () => {
+    const vertices = [];
+    const code = 65 + (0, randint_1.randint)(0, 24); // Générer un code de caractère majuscule aléatoire (A-Z)
+    for (let i = 0; i < 3; i++)
+        vertices.push(String.fromCharCode(code + i));
+    const triangle = triangles_1.TriangleConstructor.createRandomRightTriangle({
+        minRapport: 0.5,
+        maxRapport: 1.5,
+        names: vertices,
+    });
+    const sides = [
+        triangle.getSideCName(),
+        triangle.getSideBName(),
+        triangle.getSideAName(),
+    ];
+    const sideLengths = [
+        triangle.getSideCnumber(),
+        triangle.getSideBnumber(),
+        triangle.getSideAnumber(),
+    ].map((el) => (0, round_1.round)(el / 2, 2));
+    const angle = [triangle.vertexB.name, triangle.vertexC.name];
+    const randAngle = (0, randint_1.randint)(0, 2);
+    const randSides = (0, shuffle_1.shuffle)([0, 1, 2]);
+    const answer = randAngle === 0
+        ? Math.round((Math.acos(sideLengths[0] / sideLengths[2]) * 180) / Math.PI)
+        : Math.round((Math.acos(sideLengths[1] / sideLengths[2]) * 180) / Math.PI);
+    const answerTex = answer + "^{\\circ}";
+    const ggb = new geogebraConstructor_1.GeogebraConstructor(triangle.generateCommands({ highlightedAngle: angle[randAngle] }), {
+        hideAxes: true,
+        hideGrid: true,
+    });
+    const question = {
+        instruction: `Le triangle $${triangle.getTriangleName()}$ rectangle en $${triangle.getRightAngle()}$ est tel que $${sides[randSides[0]]} = ${(sideLengths[randSides[0]] + "").replace(".", ",")}$ cm et $${sides[randSides[1]]} = ${(sideLengths[randSides[1]] + "").replace(".", ",")}$ cm. Calculer $\\widehat{${angle[randAngle]}}$ à $1^\\circ$ près.`,
+        answer: answerTex,
+        keys: ["degree"],
+        commands: ggb.commands,
+        options: ggb.getOptions(),
+        coords: triangle.generateCoords(),
+        answerFormat: "tex",
+        identifiers: { randAngle, sideLengths, randSides },
+    };
+    return question;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, (0, randint_1.randint)(20, 80) + "°");
+    }
+    return (0, shuffle_1.shuffle)(propositions);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return [answer, answer.split("^")[0]].includes(ans);
+};
+exports.trigonometryAngleCalcul = {
+    id: "trigonometryAngleCalcul",
+    connector: "=",
+    label: "Utiliser la trigonométrie pour calculer un angle",
+    levels: ["4ème", "3ème", "2nde"],
+    isSingleStep: false,
+    sections: ["Trigonométrie", "Géométrie euclidienne"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getTrigonometryAngleCalcul, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    hasGeogebra: true,
+};

package/lib/exercises/trigonometry/trigonometrySideCalcul.d.ts

@@ -0,0 +1,10 @@
+import { MathExercise } from "../../exercises/exercise";
+type Identifiers = {
+    sideLengths: number[];
+    randAngle: number;
+    randSide: number;
+    randSideQuestion: number;
+};
+export declare const trigonometrySideCalcul: MathExercise<Identifiers>;
+export {};
+//# sourceMappingURL=trigonometrySideCalcul.d.ts.map

package/lib/exercises/trigonometry/trigonometrySideCalcul.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trigonometrySideCalcul.d.ts","sourceRoot":"","sources":["../../../src/exercises/trigonometry/trigonometrySideCalcul.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AASlC,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,gBAAgB,EAAE,MAAM,CAAC;CAC1B,CAAC;AA4FF,eAAO,MAAM,sBAAsB,EAAE,YAAY,CAAC,WAAW,CAc5D,CAAC"}

package/lib/exercises/trigonometry/trigonometrySideCalcul.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trigonometrySideCalcul = void 0;
+const exercise_1 = require("../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../exercises/utils/getDistinctQuestions");
+const geogebraConstructor_1 = require("../../geogebra/geogebraConstructor");
+const triangles_1 = require("../../math/geometry/triangles");
+const randint_1 = require("../../math/utils/random/randint");
+const round_1 = require("../../math/utils/round");
+const numberNode_1 = require("../../tree/nodes/numbers/numberNode");
+const shuffle_1 = require("../../utils/shuffle");
+const getTrigonometrySideCalcul = () => {
+    const vertices = [];
+    const code = 65 + (0, randint_1.randint)(0, 24); // Générer un code de caractère majuscule aléatoire (A-Z)
+    for (let i = 0; i < 3; i++)
+        vertices.push(String.fromCharCode(code + i));
+    const triangle = triangles_1.TriangleConstructor.createRandomRightTriangle({
+        minRapport: 0.5,
+        maxRapport: 1.5,
+        names: vertices,
+    });
+    const sides = [
+        triangle.getSideCName(),
+        triangle.getSideBName(),
+        triangle.getSideAName(),
+    ];
+    const sideLengths = [
+        triangle.getSideCnumber(),
+        triangle.getSideBnumber(),
+        triangle.getSideAnumber(),
+    ].map((el) => (0, round_1.round)(el / 2, 2));
+    const angle = [triangle.vertexB.name, triangle.vertexC.name];
+    const randAngle = (0, randint_1.randint)(0, 2);
+    const randSide = (0, randint_1.randint)(0, 3); // valeurs possible : 0 1 2
+    const randSideQuestion = (0, randint_1.randint)(0, 3, [randSide]); // si rand = 0, valeurs possible 1 2
+    const angleValue = [
+        (0, round_1.round)((Math.acos(sideLengths[0] / sideLengths[2]) * 180) / Math.PI, 1),
+        (0, round_1.round)((Math.acos(sideLengths[1] / sideLengths[2]) * 180) / Math.PI, 1),
+    ];
+    const commands = [
+        ...triangle.generateCommands({
+            highlightedAngle: angle[randAngle],
+            colorHighlightedAngle: "Black",
+            showLabels: [sides[randSideQuestion]],
+            setCaptions: ["?"],
+            highlightedSide: sides[randSideQuestion],
+        }),
+    ];
+    const ggb = new geogebraConstructor_1.GeogebraConstructor(commands, {
+        hideAxes: true,
+        hideGrid: true,
+    });
+    const answer = `${((0, round_1.round)(sideLengths[randSideQuestion], 1) + "").replace(".", ",")}`;
+    const question = {
+        instruction: `Le triangle $${triangle.getTriangleName()}$ rectangle en $${triangle.getRightAngle()}$ est tel que $${sides[randSide]} = ${(sideLengths[randSide] + "").replace(".", ",")}$ cm et $\\widehat{${angle[randAngle]}} = ${(angleValue[randAngle] + "").replace(".", ",")}^\\circ$. Calculer $${sides[randSideQuestion]}$ à $0,1$ cm près.`,
+        answer,
+        keys: [],
+        commands: ggb.commands,
+        options: ggb.getOptions(),
+        coords: triangle.generateCoords(),
+        answerFormat: "tex",
+        identifiers: { randAngle, randSide, randSideQuestion, sideLengths },
+    };
+    return question;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, `${((0, round_1.round)((0, randint_1.randint)(11, 100) / 10, 1) + "").replace(".", ",")}`);
+    }
+    return (0, shuffle_1.shuffle)(propositions);
+};
+const isAnswerValid = (ans, { answer }) => {
+    const answerTree = new numberNode_1.NumberNode(Number(answer.replace(",", ".")));
+    const texs = answerTree.toAllValidTexs();
+    return texs.includes(ans);
+};
+exports.trigonometrySideCalcul = {
+    id: "trigonometrySideCalcul",
+    connector: "=",
+    label: "Utiliser la trigonométrie pour calculer un côté",
+    levels: ["4ème", "3ème", "2nde"],
+    isSingleStep: false,
+    sections: ["Trigonométrie", "Géométrie euclidienne"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getTrigonometrySideCalcul, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    hasGeogebra: true,
+};

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

@@ -0,0 +1,3 @@
+import { Point } from "../../../math/geometry/point";
+export declare function getPointFromGGB(command: string, name: string, isInteger?: boolean): Point;
+//# sourceMappingURL=getPointFromGGB.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getPointFromGGB.d.ts","sourceRoot":"","sources":["../../../../src/exercises/utils/geogebra/getPointFromGGB.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,2BAA2B,CAAC;AAElD,wBAAgB,eAAe,CAC7B,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EACZ,SAAS,GAAE,OAAc,GACxB,KAAK,CASP"}

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPointFromGGB = void 0;
+const point_1 = require("../../../math/geometry/point");
+function getPointFromGGB(command, name, isInteger = true) {
+    const splitted = command.split(",");
+    const x = isInteger
+        ? +(+splitted[0].replace("(", "")).toFixed(0)
+        : +splitted[0].replace("(", "");
+    const y = isInteger
+        ? +(+splitted[1].replace(")", "")).toFixed(0)
+        : +splitted[1].replace(")", "");
+    return new point_1.Point(name, x.toTree(), y.toTree());
+}
+exports.getPointFromGGB = getPointFromGGB;

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

@@ -0,0 +1,3 @@
+import { Vector } from "../../../math/geometry/vector";
+export declare function getVectorFromGGB(command: string, name: string): Vector;
+//# sourceMappingURL=getVectorFromGGB.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getVectorFromGGB.d.ts","sourceRoot":"","sources":["../../../../src/exercises/utils/geogebra/getVectorFromGGB.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAC;AAEpD,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAKtE"}

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

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getVectorFromGGB = void 0;
+const vector_1 = require("../../../math/geometry/vector");
+function getVectorFromGGB(command, name) {
+    const splitted = command.split(";");
+    const x = +splitted[0].replace("(", "");
+    const y = +splitted[1].replace(")", "");
+    return new vector_1.Vector(name, x.toTree(), y.toTree());
+}
+exports.getVectorFromGGB = getVectorFromGGB;

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

@@ -0,0 +1,2 @@
+export declare function isGGBLine(command: string): boolean;
+//# sourceMappingURL=isGGBLine.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"isGGBLine.d.ts","sourceRoot":"","sources":["../../../../src/exercises/utils/geogebra/isGGBLine.ts"],"names":[],"mappings":"AAAA,wBAAgB,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAGlD"}

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

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isGGBLine = void 0;
+function isGGBLine(command) {
+    const regex = /Line\([A-Z],\s[A-Z]\)/;
+    return regex.test(command);
+}
+exports.isGGBLine = isGGBLine;

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

@@ -0,0 +1,2 @@
+export declare function isGGBPoint(command: string): boolean;
+//# sourceMappingURL=isGGBPoint.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"isGGBPoint.d.ts","sourceRoot":"","sources":["../../../../src/exercises/utils/geogebra/isGGBPoint.ts"],"names":[],"mappings":"AAAA,wBAAgB,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAGnD"}

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

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isGGBPoint = void 0;
+function isGGBPoint(command) {
+    const regex = /\(-?\d+(\.\d+)?\,-?\d+(\.\d+)?\)/;
+    return regex.test(command);
+}
+exports.isGGBPoint = isGGBPoint;

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

@@ -0,0 +1,9 @@
+export declare const toolBarConstructor: (options: {
+    point?: boolean;
+    join?: boolean;
+    parallel?: boolean;
+    orthogonal?: boolean;
+    intersect?: boolean;
+    vector?: boolean;
+}) => string;
+//# sourceMappingURL=toolBarConstructor.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toolBarConstructor = void 0;
+const toolBarConstructor = (options) => {
+    let customToolBar = "0||6";
+    if (options.point)
+        customToolBar += "||1";
+    if (options.join)
+        customToolBar += "||2";
+    if (options.parallel)
+        customToolBar += "||3";
+    if (options.orthogonal)
+        customToolBar += "||4";
+    if (options.intersect)
+        customToolBar += "||5";
+    if (options.vector)
+        customToolBar += "||7";
+    return customToolBar;
+};
+exports.toolBarConstructor = toolBarConstructor;

package/lib/index.d.ts

@@ -782,6 +782,9 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
     xValue: number;
     yValue: number;
 }> | import("./exercises/exercise").Exercise<{
+    correctA: number;
+    correctB: number;
+}> | import("./exercises/exercise").Exercise<{}> | import("./exercises/exercise").Exercise<{
     coin: boolean;
     radius: number;
     diametre: number;
@@ -889,6 +892,9 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
     uY: number;
     aX: number;
     aY: number;
+}> | import("./exercises/exercise").Exercise<{
+    x: number;
+    y: number;
 }> | import("./exercises/exercise").Exercise<{
     trinom: number[];
 }> | import("./exercises/exercise").Exercise<{
@@ -1611,6 +1617,20 @@ declare const pcExercises: (import("./exercises/exercise").Exercise<{
 }> | import("./exercises/exercise").Exercise<{
     power: number;
     seconds: number;
+}> | import("./exercises/exercise").Exercise<{
+    epsilon: number;
+    l: number;
+}> | import("./exercises/exercise").Exercise<{
+    moleculeName: string;
+    concentration: number;
+    molarAbsorptivity: number;
+    pathLength: number;
+    absorbance: number;
+    randomIndex: number;
+}> | import("./exercises/exercise").Exercise<{
+    wavelengths: import("./pc/measure/measure").Measure[];
+    targetColor: "rouge" | "verte" | "bleue";
+    energy: import("./pc/measure/measure").Measure;
 }>)[];
 export { mathExercises, pcExercises };
 //# sourceMappingURL=index.d.ts.map

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAG3D,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,MAAM;QACd,MAAM,EAAE,MAAM,aAAa,CAAC;QAC5B,SAAS,EAAE,MAAM,MAAM,CAAC;QACxB,YAAY,EAAE,CAAC,QAAQ,CAAC,EAAE,MAAM,KAAK,aAAa,CAAC;KACpD;CACF;AAcD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+BE;AAEF,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAjCnB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+BE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA/BF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+BE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAEgD,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":"AAUA,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAG3D,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,MAAM;QACd,MAAM,EAAE,MAAM,aAAa,CAAC;QAC5B,SAAS,EAAE,MAAM,MAAM,CAAC;QACxB,YAAY,EAAE,CAAC,QAAQ,CAAC,EAAE,MAAM,KAAK,aAAa,CAAC;KACpD;CACF;AAcD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+BE;AAEF,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAjCnB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+BE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA/BF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+BE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAEgD,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,CAAC"}

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

@@ -0,0 +1,20 @@
+import { Node } from '../../tree/nodes/node';
+import { Point } from './point';
+export declare abstract class DroiteConstructor {
+    static fromTwoPoints(A: Point, B: Point, name?: string): Droite;
+    static fromPointAndSlope(A: Point, m: Node, name?: string): Droite;
+    static fromPointAndAngle(A: Point, theta: Node, name?: string): Droite;
+}
+export declare class Droite {
+    name: string;
+    a: Node;
+    b: Node;
+    constructor(name: string | undefined, a: Node, b: Node);
+    toTex(): string;
+    toEquationForm(): string;
+    toEquationExpression(): string;
+    toPolynome(): string;
+    getLeadingCoefficient(): string;
+    intersection(D: Droite, name?: string): Point | void;
+}
+//# sourceMappingURL=droite.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"droite.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/droite.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,uBAAuB,CAAC;AAQ7C,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAIhC,8BAAsB,iBAAiB;IACrC,MAAM,CAAC,aAAa,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,IAAI,SAAM,GAAG,MAAM;IAM5D,MAAM,CAAC,iBAAiB,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,IAAI,EAAE,IAAI,SAAM,GAAG,MAAM;IAI/D,MAAM,CAAC,iBAAiB,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,SAAM,GAAG,MAAM;CAKpE;AAED,qBAAa,MAAM;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,IAAI,CAAC;IACR,CAAC,EAAE,IAAI,CAAC;gBAEI,IAAI,oBAAM,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI;IAOxC,KAAK,IAAI,MAAM;IAIf,cAAc,IAAI,MAAM;IAIxB,oBAAoB,IAAI,MAAM;IAI9B,UAAU,IAAI,MAAM;IAKpB,qBAAqB,IAAI,MAAM;IAI/B,YAAY,CAAC,CAAC,EAAE,MAAM,EAAE,IAAI,SAAM,GAAG,KAAK,GAAG,IAAI;CAMlD"}

package/lib/math/geometry/droite.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Droite = exports.DroiteConstructor = void 0;
+const numberNode_1 = require("../../tree/nodes/numbers/numberNode");
+const addNode_1 = require("../../tree/nodes/operators/addNode");
+const fractionNode_1 = require("../../tree/nodes/operators/fractionNode");
+const multiplyNode_1 = require("../../tree/nodes/operators/multiplyNode");
+const substractNode_1 = require("../../tree/nodes/operators/substractNode");
+const simplify_1 = require("../../tree/parsers/simplify");
+const mathjs_1 = require("mathjs");
+const point_1 = require("./point");
+const polynomial_1 = require("../polynomials/polynomial");
+const round_1 = require("../utils/round");
+class DroiteConstructor {
+    static fromTwoPoints(A, B, name = 'd') {
+        const a = new fractionNode_1.FractionNode(new substractNode_1.SubstractNode(B.y, A.y), new substractNode_1.SubstractNode(B.x, A.x));
+        const b = new substractNode_1.SubstractNode(A.y, new multiplyNode_1.MultiplyNode(a, A.x));
+        return new Droite(name, (0, simplify_1.simplifyNode)(a), (0, simplify_1.simplifyNode)(b));
+    }
+    static fromPointAndSlope(A, m, name = 'd') {
+        return new Droite(name, (0, simplify_1.simplifyNode)(m), (0, simplify_1.simplifyNode)(new substractNode_1.SubstractNode(A.y, new multiplyNode_1.MultiplyNode(m, A.x))));
+    }
+    static fromPointAndAngle(A, theta, name = 'd') {
+        const m = new numberNode_1.NumberNode((0, round_1.round)(Math.tan(parseFloat(theta.toMathString())), 2));
+        const b = new substractNode_1.SubstractNode(A.y, new multiplyNode_1.MultiplyNode(m, A.x));
+        return new Droite(name, (0, simplify_1.simplifyNode)(m), (0, simplify_1.simplifyNode)(b));
+    }
+}
+exports.DroiteConstructor = DroiteConstructor;
+class Droite {
+    constructor(name = 'D', a, b) {
+        // ax + b
+        this.name = name;
+        this.a = a;
+        this.b = b;
+    }
+    toTex() {
+        return `${this.name}`;
+    }
+    toEquationForm() {
+        return `${this.a.toTex()}x+${this.b.toTex()}`;
+    }
+    toEquationExpression() {
+        return `(${this.name}) : y = ${this.toEquationForm()}`; // (D) : y = ax + b
+    }
+    toPolynome() {
+        const polynome = new polynomial_1.Polynomial([(0, mathjs_1.evaluate)(this.b.toMathString()), (0, mathjs_1.evaluate)(this.a.toMathString())], 'x');
+        return polynome.toTex();
+    }
+    getLeadingCoefficient() {
+        return `${(0, simplify_1.simplifyNode)(this.a).toTex()}`;
+    }
+    // TODO : ajouter des conditions ou cas ou les deux droites sont Parallèles
+    intersection(D, name = 'P') {
+        if ((0, mathjs_1.evaluate)(D.a.toMathString()) === (0, mathjs_1.evaluate)(this.a.toMathString()))
+            return;
+        const x = new fractionNode_1.FractionNode(new substractNode_1.SubstractNode(D.b, this.b), new substractNode_1.SubstractNode(this.a, D.a));
+        const y = new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(this.a, x), this.b);
+        return new point_1.Point(name, (0, simplify_1.simplifyNode)(x), (0, simplify_1.simplifyNode)(y));
+    }
+}
+exports.Droite = Droite;

package/lib/pc/constants/quantic.d.ts

@@ -0,0 +1,9 @@
+import { Measure } from "../measure/measure";
+type PhysicalConstant = {
+    value: Measure;
+    unit: string;
+};
+export declare const planckConstant: PhysicalConstant;
+export declare const lightSpeed: PhysicalConstant;
+export {};
+//# sourceMappingURL=quantic.d.ts.map

package/lib/pc/constants/quantic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quantic.d.ts","sourceRoot":"","sources":["../../../src/pc/constants/quantic.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAE7C,KAAK,gBAAgB,GAAG;IACtB,KAAK,EAAE,OAAO,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,eAAO,MAAM,cAAc,EAAE,gBAI5B,CAAC;AAEF,eAAO,MAAM,UAAU,EAAE,gBAIxB,CAAC"}

package/lib/pc/constants/quantic.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lightSpeed = exports.planckConstant = void 0;
+const measure_1 = require("../measure/measure");
+exports.planckConstant = {
+    value: new measure_1.Measure(6.626, -34),
+    // value: 6.626 * Math.pow(10, -34),
+    unit: "\\text{J.s}",
+};
+exports.lightSpeed = {
+    value: new measure_1.Measure(3, 8),
+    // value: 3 * Math.pow(10, 8),
+    unit: "\\text{m.s^(-1)}",
+};

package/lib/server.js

@@ -35,7 +35,9 @@ const dotenv_1 = __importDefault(require("dotenv"));
 const cors_1 = __importDefault(require("cors"));
 const numberNode_1 = require("./tree/nodes/numbers/numberNode");
 const infiniteNode_1 = require("./tree/nodes/numbers/infiniteNode");
+const multiplyNode_1 = require("./tree/nodes/operators/multiplyNode");
 const toScientific_1 = require("./utils/numberPrototype/toScientific");
+const variableNode_1 = require("./tree/nodes/variables/variableNode");
 const jsonParser = body_parser_1.default.json();
 const mathExercises = Object.values(MathExercises);
 const pcExercises = Object.values(PCExercises);
@@ -60,16 +62,10 @@ const runServer = () => {
     app.use((0, cors_1.default)());
     console.log("math exos", mathExercises.length);
     console.log("pc exos", pcExercises.length);
-    // const node = new MultiplyNode(
-    //   (4).toTree(),
-    //   new CosNode(
-    //     new MultiplyNode(
-    //       new FractionNode(new MultiplyNode((2).toTree(), PiNode), (3).toTree()),
-    //       new VariableNode("x"),
-    //     ),
-    //   ),
-    // ).simplify();
-    // console.log(node);
+    const node = new multiplyNode_1.MultiplyNode(new variableNode_1.VariableNode("x"), new variableNode_1.VariableNode("x"))
+        .simplify()
+        .toTex();
+    console.log(node);
     app.get("/", (req, res) => {
         res.json(allExercises);
     });
@@ -130,6 +126,24 @@ const runServer = () => {
             result,
         });
     });
+    app.post("/ggbvea", jsonParser, (req, res) => {
+        const exoId = req.query.exoId;
+        const { ggbAns, ggbVeaProps } = req.body;
+        const exoIndex = allExercises.findIndex((exo) => exo.id == exoId);
+        const exo = allExercises[exoIndex];
+        if (!exo) {
+            res.send("Exo not found");
+            return;
+        }
+        if (!exo.isGGBAnswerValid) {
+            res.send("No GGBVEA implemented");
+            return;
+        }
+        const result = exo.isGGBAnswerValid(ggbAns, ggbVeaProps) ?? false;
+        res.json({
+            result,
+        });
+    });
     app.listen("5000", () => {
         console.log(`[server]: Server is running at http://localhost:5000`);
     });

package/lib/tree/nodes/expression/expressionNode.d.ts

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

package/lib/tree/nodes/expression/expressionNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expressionNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/expression/expressionNode.ts"],"names":[],"mappings":""}

package/lib/tree/nodes/expression/expressionNode.js

@@ -0,0 +1 @@
+"use strict";

package/lib/tree/nodes/operators/equalNode.d.ts

@@ -0,0 +1,16 @@
+import { Node } from '../node';
+import { OperatorNode } from './operatorNode';
+type EqualNodeOptions = {
+    isRightChildOnlyValid?: boolean;
+};
+export declare class EqualNode extends OperatorNode implements Node {
+    opts: EqualNodeOptions | undefined;
+    constructor(leftChild: Node, rightChild: Node, opts?: EqualNodeOptions);
+    toEquivalentNodes(): Node[];
+    toAllValidTexs(): string[];
+    toMathString(): string;
+    toTex(): string;
+    toMathjs(): boolean | import("mathjs").MathCollection;
+}
+export {};
+//# sourceMappingURL=equalNode.d.ts.map

package/lib/tree/nodes/operators/equalNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"equalNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/equalNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAY,MAAM,SAAS,CAAC;AACzC,OAAO,EAAe,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAE3D,KAAK,gBAAgB,GAAG;IACtB,qBAAqB,CAAC,EAAE,OAAO,CAAC;CACjC,CAAC;AACF,qBAAa,SAAU,SAAQ,YAAa,YAAW,IAAI;IACzD,IAAI,EAAE,gBAAgB,GAAG,SAAS,CAAC;gBACvB,SAAS,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,IAAI,CAAC,EAAE,gBAAgB;IAKtE,iBAAiB;IAiBjB,cAAc,IAAI,MAAM,EAAE;IAI1B,YAAY,IAAI,MAAM;IAGtB,KAAK,IAAI,MAAM;IAIf,QAAQ;CAGT"}

package/lib/tree/nodes/operators/equalNode.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EqualNode = void 0;
+const mathjs_1 = require("mathjs");
+const operatorNode_1 = require("./operatorNode");
+class EqualNode extends operatorNode_1.OperatorNode {
+    constructor(leftChild, rightChild, opts) {
+        super(operatorNode_1.OperatorIds.equal, leftChild, rightChild, true, '=');
+        this.opts = opts;
+    }
+    toEquivalentNodes() {
+        const res = [];
+        const rightNodes = this.rightChild.toEquivalentNodes();
+        if (this.opts?.isRightChildOnlyValid) {
+            res.push(...rightNodes);
+        }
+        const leftNodes = this.leftChild.toEquivalentNodes();
+        rightNodes.forEach((rightNode) => {
+            leftNodes.forEach((leftNode) => {
+                res.push(new EqualNode(leftNode, rightNode));
+                res.push(new EqualNode(rightNode, leftNode));
+            });
+        });
+        return res;
+    }
+    toAllValidTexs() {
+        return this.toEquivalentNodes().map((node) => node.toTex());
+    }
+    toMathString() {
+        return `${this.leftChild.toMathString()} = ${this.rightChild.toMathString()}`;
+    }
+    toTex() {
+        return `${this.leftChild.toTex()}=${this.rightChild.toTex()}`;
+    }
+    toMathjs() {
+        return (0, mathjs_1.equal)(this.leftChild.toMathjs(), this.rightChild.toMathjs());
+    }
+}
+exports.EqualNode = EqualNode;

package/lib/tree/parsers/simplify.d.ts

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

package/lib/tree/parsers/simplify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"simplify.d.ts","sourceRoot":"","sources":["../../../src/tree/parsers/simplify.ts"],"names":[],"mappings":""}