math-exercises 3.0.18 → 3.0.20

package/lib/exercises/math/calcul/proportionality/rectangleSideAfterReduction.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rectangleSideAfterReduction.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/proportionality/rectangleSideAfterReduction.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;CAGnB,CAAC;AA8OF,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,WAAW,CAoB7D,CAAC"}
+{"version":3,"file":"rectangleSideAfterReduction.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/proportionality/rectangleSideAfterReduction.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;CAGnB,CAAC;AA8OF,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,WAAW,CAmB7D,CAAC"}

package/lib/exercises/math/calcul/proportionality/rectangleSideAfterReduction.js

@@ -68,7 +68,7 @@ const getInstruction = (identifiers) => {
     const d3n = new D3Node();
     // Set SVG dimensions
     const width = 300, height = 150;
-    const svg = d3n.createSVG(width, height);
+    const svg = d3n.createSVG(width, height, { id: "nonLatex" });
     // Function to add rotated rectangles
     function addRectangle(svg, x, y, w, h, angle, color, label1, label2) {
         const group = svg
@@ -183,7 +183,7 @@ const getRectangleSideAfterReductionQuestion = (ops) => {
 export const rectangleSideAfterReduction = {
     id: "rectangleSideAfterReduction",
     // connector: "",
-    label: "Utiliser la proportionnalité pour déterminer les dimensions d'un rectangle après réduction",
+    label: "Déterminer les dimensions d'un rectangle après réduction",
     isSingleStep: true,
     generator: (nb, opts) => getDistinctQuestions(() => getRectangleSideAfterReductionQuestion(opts), nb),
     qcmTimer: 60,

package/lib/exercises/math/geometry/angles/recognizeAngleType.js

@@ -148,7 +148,7 @@ const getGGBOptions = (identifiers) => {
     const ggb = new GeogebraConstructor({
         commands: [
             ...points.flatMap((p) => p.toGGBCommand()),
-            ...lines.flatMap((l) => l.toGGBCommands(false)),
+            ...lines.flatMap((l) => l.toGGBCommands(false, { color: "black" })),
             ...angle.toCommands({ color: "red" }),
         ],
         hideAxes: true,

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

@@ -1 +1 @@
-{"version":3,"file":"buildPointFromAxialSymetry.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/euclidianConstructions/buildPointFromAxialSymetry.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAOrC,OAAO,EAGL,eAAe,EAChB,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAEtC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,gBAAgB,CAAC;IACxB,IAAI,EAAE,eAAe,CAAC;CACvB,CAAC;AAiGF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAe5D,CAAC"}
+{"version":3,"file":"buildPointFromAxialSymetry.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/euclidianConstructions/buildPointFromAxialSymetry.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAOrC,OAAO,EAGL,eAAe,EAChB,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAEtC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,gBAAgB,CAAC;IACxB,IAAI,EAAE,eAAe,CAAC;CACvB,CAAC;AAkGF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAe5D,CAAC"}

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

@@ -26,7 +26,7 @@ const getGGBAnswer = (identifiers) => {
     const circle = new Circle(center, point, "C");
     return [
         ...sol.toGGBCommand(),
-        ...perp.toGGBCommands(false),
+        ...perp.toGGBCommands(false, { color: "black" }),
         ...circle.toGGBCommands(false),
     ];
 };
@@ -37,6 +37,7 @@ const getStudentGGBOptions = (identifiers) => {
         ...point.toGGBCommand(),
         ...line.toGGBCommands(false, {
             showLabel: true,
+            color: "black",
         }),
     ];
     const sol = getSolutionPoint(identifiers);

package/lib/exercises/math/geometry/shapes/basicShapesNaming.js

@@ -29,7 +29,7 @@ const getBasicShapesNamingQuestion = () => {
         case 3: //droite
         default:
             const line = LineConstructor.random();
-            commands.push(...line.toGGBCommands(true));
+            commands.push(...line.toGGBCommands(true, { color: "black" }));
             answer = line.toTexNoLeftRight();
             break;
     }

package/lib/exercises/math/geometry/shapes/basicShapesRecognition.js

@@ -31,7 +31,7 @@ const getBasicShapesRecognitionQuestion = () => {
         default:
             answer = "Une droite";
             const line = LineConstructor.random();
-            commands.push(...line.toGGBCommands(true));
+            commands.push(...line.toGGBCommands(true, { color: "black" }));
             break;
     }
     const ggb = new GeogebraConstructor({

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

@@ -1,3 +1,4 @@
 export * from "./scalarProductViaCoords.js";
 export * from "./scalarProductViaCos.js";
+export * from "./scalarProductViaNorms.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/geometry/vectors/scalarProduct/index.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC;AAC5C,cAAc,0BAA0B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/geometry/vectors/scalarProduct/index.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC;AAC5C,cAAc,0BAA0B,CAAC;AAGzC,cAAc,4BAA4B,CAAC"}

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

@@ -1,3 +1,4 @@
 export * from "./scalarProductViaCoords.js";
 export * from "./scalarProductViaCos.js";
 // export * from "./scalarProductOrthoInSquare.js";
+export * from "./scalarProductViaNorms.js";

package/lib/exercises/math/geometry/vectors/scalarProduct/scalarProductViaNorms.d.ts

@@ -0,0 +1,8 @@
+import { Exercise } from "../../../../../exercises/exercise.js";
+import { TriangleIdentifiers } from "../../../../../math/geometry/triangle.js";
+type Identifiers = {
+    triangleIdentifiers: TriangleIdentifiers;
+};
+export declare const scalarProductViaNorms: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=scalarProductViaNorms.d.ts.map

package/lib/exercises/math/geometry/vectors/scalarProduct/scalarProductViaNorms.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scalarProductViaNorms.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/geometry/vectors/scalarProduct/scalarProductViaNorms.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAEL,mBAAmB,EACpB,MAAM,iCAAiC,CAAC;AAWzC,KAAK,WAAW,GAAG;IACjB,mBAAmB,EAAE,mBAAmB,CAAC;CAC1C,CAAC;AA8IF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAkBvD,CAAC"}

package/lib/exercises/math/geometry/vectors/scalarProduct/scalarProductViaNorms.js

@@ -0,0 +1,147 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { rationalVEA } from "../../../../../exercises/vea/rationalVEA.js";
+import { GeogebraConstructor } from "../../../../../geogebra/geogebraConstructor.js";
+import { TriangleConstructor, } from "../../../../../math/geometry/triangle.js";
+import { randint } from "../../../../../math/utils/random/randint.js";
+import { add } from "../../../../../tree/nodes/operators/addNode.js";
+import { frac } from "../../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../../tree/nodes/operators/multiplyNode.js";
+import { cdot } from "../../../../../tree/nodes/operators/scalarProductNode.js";
+import { substract } from "../../../../../tree/nodes/operators/substractNode.js";
+import { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../../utils/latex/alignTex.js";
+const getPropositions = (n, { answer, triangleIdentifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const triangle = TriangleConstructor.fromIdentifiers(triangleIdentifiers);
+    const A = triangle.sides[0].getLength();
+    const B = triangle.sides[1].getLength();
+    const C = triangle.sides[2].getLength();
+    // return multiply(frac(1, 2), substract(add(C, B), A));
+    tryToAddWrongProp(propositions, substract(add(C ** 2, B ** 2), A ** 2)
+        .simplify()
+        .toTex());
+    tryToAddWrongProp(propositions, multiply(frac(1, 2), substract(add(C, B), A))
+        .simplify()
+        .toTex());
+    tryToAddWrongProp(propositions, multiply(frac(1, 2), substract(add(A ** 2, B ** 2), C ** 2))
+        .simplify()
+        .toTex());
+    while (propositions.length < n) {
+        tryToAddWrongProp(propositions, randint(-50, 50).frenchify());
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswerNode = (identifiers) => {
+    const { triangleIdentifiers } = identifiers;
+    const triangle = TriangleConstructor.fromIdentifiers(triangleIdentifiers);
+    const A = triangle.sides[0].getLength() ** 2;
+    const B = triangle.sides[1].getLength() ** 2;
+    const C = triangle.sides[2].getLength() ** 2;
+    return multiply(frac(1, 2), substract(add(C, B), A));
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).simplify().toTex();
+};
+const getInstruction = (identifiers) => {
+    const { triangleIdentifiers } = identifiers;
+    const triangle = TriangleConstructor.fromIdentifiers(triangleIdentifiers);
+    const sides = triangle.sides.map((e) => e.toLengthTex()).reverse();
+    const vectors = triangle.sides.map((e) => e.toVector()).reverse();
+    return `Le triangle $${triangle.name}$ est tel que $${sides[0]}$, $${sides[1]}$ et $${sides[2]}$. 
+
+Calculer $${cdot(vectors[0], vectors[1]).toTex()}$.`;
+};
+const getHint = (identifiers) => {
+    return `Si $A$, $B$ et $C$ sont trois points du plan, alors : 
+  
+$$
+\\overrightarrow{AB}\\cdot \\overrightarrow{AC} = \\frac{1}{2}\\left(AB^2 + AC^2 - BC^2 \\right)
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { triangleIdentifiers } = identifiers;
+    const triangle = TriangleConstructor.fromIdentifiers(triangleIdentifiers);
+    const sidesInsideNames = triangle.sides
+        .map((e) => e.toInsideName())
+        .reverse();
+    const answerNode = getAnswerNode(identifiers);
+    return `D'après le cours, on a : 
+ 
+${alignTex([
+        [
+            "",
+            `\\overrightarrow{${sidesInsideNames[0]}}\\cdot \\overrightarrow{${sidesInsideNames[1]}}`,
+        ],
+        [
+            "=",
+            `\\frac{1}{2}\\left(${sidesInsideNames[0]}^2 + ${sidesInsideNames[1]}^2 - ${sidesInsideNames[2]}^2 \\right)`,
+        ],
+        ["=", answerNode.toTex()],
+        ["=", answerNode.simplify().toTex()],
+    ])}
+`;
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return rationalVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getGGBOptions = (identifiers) => {
+    const { triangleIdentifiers } = identifiers;
+    const triangle = TriangleConstructor.fromIdentifiers(triangleIdentifiers);
+    triangle.showSidesLength();
+    const ggb = new GeogebraConstructor({
+        commands: triangle.commands,
+        hideAxes: true,
+        hideGrid: true,
+    });
+    return ggb.getOptions({
+        coords: triangle.generateCoords(),
+    });
+};
+const getScalarProductViaNormsQuestion = (ops) => {
+    const triangle = TriangleConstructor.randomNiceSides({
+        randomName: true,
+        intSides: true,
+    });
+    const identifiers = {
+        triangleIdentifiers: triangle.toIdentifiers(),
+    };
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
+    };
+    return question;
+};
+export const scalarProductViaNorms = {
+    id: "scalarProductViaNorms",
+    connector: "=",
+    label: "Calculer un produit scalaire (formule des normes)",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getScalarProductViaNormsQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    hasHintAndCorrection: true,
+    hasGeogebra: true,
+};

package/lib/exercises/math/probaStat/basicStats/calculateFrequency.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"calculateFrequency.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/basicStats/calculateFrequency.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,CAAC,EAAE,MAAM,CAAC;IACV,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AA+FF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAiBpD,CAAC"}
+{"version":3,"file":"calculateFrequency.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/basicStats/calculateFrequency.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,CAAC,EAAE,MAAM,CAAC;IACV,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAyGF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAiBpD,CAAC"}

package/lib/exercises/math/probaStat/basicStats/calculateFrequency.js

@@ -3,37 +3,44 @@ import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQue
 import { rationalVEA } from "../../../../exercises/vea/rationalVEA.js";
 import { RationalConstructor } from "../../../../math/numbers/rationals/rational.js";
 import { randint } from "../../../../math/utils/random/randint.js";
+import { round } from "../../../../math/utils/round.js";
 import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
 import { random } from "../../../../utils/alea/random.js";
 import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { approxOrEqual } from "../../../../utils/latex/approxOrEqual.js";
 const getPropositions = (n, { answer, ...identifiers }) => {
     const propositions = [];
     const { k, nbEssais } = identifiers;
     addValidProp(propositions, answer);
     tryToAddWrongProp(propositions, k + "");
-    tryToAddWrongProp(propositions, frac(k, 100).toTex());
+    tryToAddWrongProp(propositions, round(k / 100, 2).frenchify());
     while (propositions.length < n) {
-        tryToAddWrongProp(propositions, RationalConstructor.randomIrreductible().toTree().toTex());
+        tryToAddWrongProp(propositions, round(RationalConstructor.randomIrreductible().toTree().evaluate(), 2).frenchify());
     }
     return shuffleProps(propositions, n);
 };
 const getAnswer = (identifiers) => {
     const { k, nbEssais } = identifiers;
-    return frac(k, nbEssais).simplify().toTex();
+    return round(k / nbEssais, 2).frenchify();
 };
 const getInstruction = (identifiers) => {
     const { type, k, nbEssais, caracType } = identifiers;
+    let instruction = ";";
     switch (type) {
         case 0: //pièce
-            return `On lance une pièce de monnaie $${nbEssais}$ fois. On tombe $${k}$ fois sur ${caracType}. Quelle est la fréquence d'apparition de ${caracType} ?`;
+            instruction = `On lance une pièce de monnaie $${nbEssais}$ fois. On tombe $${k}$ fois sur ${caracType}.`;
         case 1: //dé 6 faces
-            return `On lance un dé à $6$ faces $${nbEssais}$ fois. On tombe  $${k}$ fois sur ${caracType}. Quelle est la fréquence d'apparition de ${caracType} ?`;
+            instruction = `On lance un dé à $6$ faces $${nbEssais}$ fois. On tombe  $${k}$ fois sur ${caracType}.`;
         case 2: // dé X faces
-            return `On lance un dé à $12$ faces $${nbEssais}$ fois. On tombe  $${k}$ fois sur ${caracType}. Quelle est la fréquence d'apparition de ${caracType} ?`;
+            instruction = `On lance un dé à $12$ faces $${nbEssais}$ fois. On tombe  $${k}$ fois sur ${caracType}.`;
         case 3:
         default: //deux dés 6 faces
-            return `On lance deux dés à $6$ faces $${nbEssais}$ fois. On note la somme obtenue. On tombe $${k}$ fois sur ${caracType}. Quelle est la fréquence d'apparition de ${caracType} ?`;
+            instruction = `On lance deux dés à $6$ faces $${nbEssais}$ fois. On note la somme obtenue. On tombe $${k}$ fois sur ${caracType}.`;
     }
+    instruction += `
+
+Quelle est la fréquence d'apparition de ${caracType} ? Arrondir au centième près.`;
+    return instruction;
 };
 const getHint = (identifiers) => {
     const { type, k, nbEssais, caracType } = identifiers;
@@ -44,15 +51,17 @@ const getCorrection = (identifiers) => {
     return `On a obtenu $${k}$ fois ${caracType} sur les $${nbEssais}$ lancers. La fréquence d'apparition de ${caracType} est donc : 
   
 $$
-${frac(k, nbEssais).toSimplificationString()}
+${frac(k, nbEssais).toTex()} ${approxOrEqual(k / nbEssais, 2).join("")}
 $$`;
 };
 const getKeys = (identifiers) => {
     return [];
 };
-const isAnswerValid = (ans, { answer }) => {
+const isAnswerValid = (ans, { answer, k, nbEssais }) => {
     try {
-        return rationalVEA(ans, answer, { decimalPrecision: 2 });
+        return rationalVEA(ans, frac(k, nbEssais).simplify().toTex(), {
+            decimalPrecision: 2,
+        });
     }
     catch (err) {
         return handleVEAError(err);

package/lib/index.d.ts

@@ -1165,6 +1165,8 @@ declare const mathExercises: (Exercise<{
     AB: number;
     AC: number;
     trigoPoint: string;
+}, {}> | Exercise<{
+    triangleIdentifiers: import("./math/geometry/triangle.js").TriangleIdentifiers;
 }, {}> | Exercise<{
     points: import("./math/geometry/point.js").PointIdentifiers[];
     startPointIndex: number;

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAG7D,OAAO,4BAA4B,CAAC;AACpC,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAE/D,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAE,cAAc,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

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

@@ -9,9 +9,10 @@ export type TriangleIdentifiers = {
 };
 export declare abstract class TriangleConstructor {
     static fromIdentifiers(identifiers: TriangleIdentifiers): Triangle;
-    static randomNiceSides({ names, randomName, }: {
+    static randomNiceSides({ names, randomName, intSides, }: {
         names?: string[] | undefined;
         randomName?: boolean | undefined;
+        intSides?: boolean | undefined;
     }): Triangle;
     static randomName(): string[];
 }
@@ -35,12 +36,6 @@ export declare class Triangle {
     props?: TriangleProps;
     constructor(points: Point[], props?: TriangleProps);
     toIdentifiers(): TriangleIdentifiers;
-    /*************  ✨ Codeium Command ⭐  *************/
-    /**
-     * Returns the perimeter of the triangle.
-     * @returns {number} the perimeter of the triangle.
-     */
-    /******  fbb7c5d7-3919-4ef2-b5ba-db0d6770666d  *******/
     getPerimeter(): number;
     getArea(): number;
     isRight(): Boolean;

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

@@ -1 +1 @@
-{"version":3,"file":"triangle.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/triangle.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAoB,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAEvE,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAKnC,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAClE,OAAO,EAEL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAE7C,MAAM,MAAM,mBAAmB,GAAG;IAChC,MAAM,EAAE,gBAAgB,EAAE,CAAC;IAC3B,KAAK,CAAC,EAAE,wBAAwB,CAAC;CAClC,CAAC;AAEF,8BAAsB,mBAAmB;IACvC,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,mBAAmB,GAAG,QAAQ;IAgBlE,MAAM,CAAC,eAAe,CAAC,EACrB,KAAuB,EACvB,UAAkB,GACnB;;;KAAA,GAAG,QAAQ;IA8BZ,MAAM,CAAC,UAAU;CAQlB;AAED,MAAM,MAAM,wBAAwB,GAAG;IACrC,YAAY,CAAC,EAAE,CAAC,eAAe,GAAG,SAAS,CAAC,EAAE,CAAC;IAC/C,kBAAkB,CAAC,EAAE,eAAe,EAAE,CAAC;IACvC,kBAAkB,CAAC,EAAE,eAAe,EAAE,CAAC;CACxC,CAAC;AACF,MAAM,MAAM,aAAa,GAAG;IAC1B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,YAAY,CAAC,EAAE,CAAC,aAAa,GAAG,SAAS,CAAC,EAAE,CAAC;IAC7C,kBAAkB,CAAC,EAAE,aAAa,EAAE,CAAC;IACrC,kBAAkB,CAAC,EAAE,aAAa,EAAE,CAAC;CACtC,CAAC;AACF,qBAAa,QAAQ;IACnB,MAAM,EAAE,KAAK,EAAE,CAAC;IAChB,MAAM,EAAE,KAAK,EAAE,CAAC;IAChB,KAAK,EAAE,OAAO,EAAE,CAAC;IACjB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,aAAa,CAAC;gBACV,MAAM,EAAE,KAAK,EAAE,EAAE,KAAK,CAAC,EAAE,aAAa;IAyClD,aAAa,IAAI,mBAAmB;IAepC,mDAAmD;IACnD;;;OAGG;IACH,uDAAuD;IACvD,YAAY,IAAI,MAAM;IAItB,OAAO,IAAI,MAAM;IASjB,OAAO,IAAI,OAAO;IAIlB,aAAa,IAAI,OAAO;IAMxB,WAAW,IAAI,OAAO;IAUtB,SAAS,IAAI,OAAO;IASpB,aAAa,CACX,KAAK,EAAE,MAAM,EACb,IAAI,EAAE;QACJ,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,OAAO,CAAC,EAAE,MAAM,CAAC;KAClB;IAWH,cAAc,CACZ,KAAK,EAAE,MAAM,EACb,IAAI,CAAC,EAAE;QACL,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,SAAS,CAAC,EAAE,OAAO,CAAC;KACrB;IAKH,eAAe,CAAC,WAAW,CAAC,EAAE,MAAM,EAAE;IAQtC,SAAS,CACP,WAAW,EAAE,MAAM,EACnB,IAAI,CAAC,EAAE;QACL,QAAQ,CAAC,EAAE,MAAM,CAAC;KACnB;IAYH,UAAU,CACR,WAAW,EAAE,MAAM,EACnB,IAAI,CAAC,EAAE;QACL,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,SAAS,CAAC,EAAE,KAAK,CAAC;KACnB;IAoCH,cAAc,IAAI,MAAM,EAAE;CAkB3B"}
+{"version":3,"file":"triangle.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/triangle.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAoB,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAEvE,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAKnC,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAClE,OAAO,EAEL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAG7C,MAAM,MAAM,mBAAmB,GAAG;IAChC,MAAM,EAAE,gBAAgB,EAAE,CAAC;IAC3B,KAAK,CAAC,EAAE,wBAAwB,CAAC;CAClC,CAAC;AAEF,8BAAsB,mBAAmB;IACvC,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,mBAAmB,GAAG,QAAQ;IAgBlE,MAAM,CAAC,eAAe,CAAC,EACrB,KAAuB,EACvB,UAAkB,EAClB,QAAgB,GACjB;;;;KAAA,GAAG,QAAQ;IA8BZ,MAAM,CAAC,UAAU;CAQlB;AAED,MAAM,MAAM,wBAAwB,GAAG;IACrC,YAAY,CAAC,EAAE,CAAC,eAAe,GAAG,SAAS,CAAC,EAAE,CAAC;IAC/C,kBAAkB,CAAC,EAAE,eAAe,EAAE,CAAC;IACvC,kBAAkB,CAAC,EAAE,eAAe,EAAE,CAAC;CACxC,CAAC;AACF,MAAM,MAAM,aAAa,GAAG;IAC1B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,YAAY,CAAC,EAAE,CAAC,aAAa,GAAG,SAAS,CAAC,EAAE,CAAC;IAC7C,kBAAkB,CAAC,EAAE,aAAa,EAAE,CAAC;IACrC,kBAAkB,CAAC,EAAE,aAAa,EAAE,CAAC;CACtC,CAAC;AACF,qBAAa,QAAQ;IACnB,MAAM,EAAE,KAAK,EAAE,CAAC;IAChB,MAAM,EAAE,KAAK,EAAE,CAAC;IAChB,KAAK,EAAE,OAAO,EAAE,CAAC;IACjB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,aAAa,CAAC;gBACV,MAAM,EAAE,KAAK,EAAE,EAAE,KAAK,CAAC,EAAE,aAAa;IAyClD,aAAa,IAAI,mBAAmB;IAepC,YAAY,IAAI,MAAM;IAItB,OAAO,IAAI,MAAM;IASjB,OAAO,IAAI,OAAO;IAIlB,aAAa,IAAI,OAAO;IAMxB,WAAW,IAAI,OAAO;IAUtB,SAAS,IAAI,OAAO;IASpB,aAAa,CACX,KAAK,EAAE,MAAM,EACb,IAAI,EAAE;QACJ,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,OAAO,CAAC,EAAE,MAAM,CAAC;KAClB;IAWH,cAAc,CACZ,KAAK,EAAE,MAAM,EACb,IAAI,CAAC,EAAE;QACL,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,SAAS,CAAC,EAAE,OAAO,CAAC;KACrB;IAKH,eAAe,CAAC,WAAW,CAAC,EAAE,MAAM,EAAE;IAQtC,SAAS,CACP,WAAW,EAAE,MAAM,EACnB,IAAI,CAAC,EAAE;QACL,QAAQ,CAAC,EAAE,MAAM,CAAC;KACnB;IAYH,UAAU,CACR,WAAW,EAAE,MAAM,EACnB,IAAI,CAAC,EAAE;QACL,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,SAAS,CAAC,EAAE,KAAK,CAAC;KACnB;IAoCH,cAAc,IAAI,MAAM,EAAE;CAkB3B"}

package/lib/math/geometry/triangle.js

@@ -7,6 +7,7 @@ import { round } from "../utils/round.js";
 import { randfloat } from "../utils/random/randfloat.js";
 import { LineConstructor } from "./line.js";
 import { reifyAlgebraic, } from "../../tree/nodes/nodeConstructor.js";
+import { randint } from "../utils/random/randint.js";
 export class TriangleConstructor {
     static fromIdentifiers(identifiers) {
         return new Triangle(identifiers.points.map((p) => PointConstructor.fromIdentifiers(p)), {
@@ -15,7 +16,7 @@ export class TriangleConstructor {
             sidesLengths: identifiers.props?.sidesLengths?.map((n) => n ? reifyAlgebraic(n) : undefined),
         });
     }
-    static randomNiceSides({ names = ["A", "B", "C"], randomName = false, }) {
+    static randomNiceSides({ names = ["A", "B", "C"], randomName = false, intSides = false, }) {
         let vertices = [];
         if (randomName)
             vertices = TriangleConstructor.randomName();
@@ -25,8 +26,8 @@ export class TriangleConstructor {
         const addAngle = randfloat(Math.PI / 4, (3 * Math.PI) / 4);
         //on construit [AC] sur (Ox) de milieu O et de taille 2*xRand
         //puis [AB] sur (Ox) qu'on rotate
-        const xRand = randfloat(5, 8, 1);
-        const xRand2 = randfloat(-5, 5, 1);
+        const xRand = intSides ? randint(5, 9) : randfloat(5, 8, 1);
+        const xRand2 = intSides ? randint(-5, 5) : randfloat(-5, 5, 1);
         const origin = new Point("O", (0).toTree(), (0).toTree());
         const startA = new Point(vertices[0], (-xRand).toTree(), (0).toTree());
         const A = startA.rotate(angle, origin);
@@ -34,9 +35,9 @@ export class TriangleConstructor {
         const B = new Point(vertices[1], (-xRand + xRand2).toTree(), (0).toTree()).rotate(angle + addAngle, startA);
         return new Triangle([A, B, C], {
             sidesLengths: [
-                round(B.distanceTo(C), 1).toTree(),
-                round(A.distanceTo(C), 1).toTree(),
-                round(A.distanceTo(B), 1).toTree(),
+                round(B.distanceTo(C), intSides ? 0 : 1).toTree(),
+                round(A.distanceTo(C), intSides ? 0 : 1).toTree(),
+                round(A.distanceTo(B), intSides ? 0 : 1).toTree(),
             ],
         });
     }
@@ -105,12 +106,6 @@ export class Triangle {
             },
         };
     }
-    /*************  ✨ Codeium Command ⭐  *************/
-    /**
-     * Returns the perimeter of the triangle.
-     * @returns {number} the perimeter of the triangle.
-     */
-    /******  fbb7c5d7-3919-4ef2-b5ba-db0d6770666d  *******/
     getPerimeter() {
         return this.sides.reduce((acc, curr) => acc + curr.getLength(), 0);
     }

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

@@ -0,0 +1,11 @@
+import { NodeOptions, ToTexOptions } from "../node.js";
+import { Vector } from "../../../math/geometry/vector.js";
+export declare const cdot: (a: Vector, b: Vector) => ScalarProductNode;
+export declare class ScalarProductNode {
+    leftChild: Vector;
+    rightChild: Vector;
+    opts?: NodeOptions;
+    constructor(leftChild: Vector, rightChild: Vector, opts?: NodeOptions);
+    toTex(options?: ToTexOptions): string;
+}
+//# sourceMappingURL=scalarProductNode.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"scalarProductNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/scalarProductNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAiB,WAAW,EAAY,YAAY,EAAE,MAAM,YAAY,CAAC;AA2BhF,OAAO,EAAE,MAAM,EAAE,MAAM,+BAA+B,CAAC;AAEvD,eAAO,MAAM,IAAI,MAAO,MAAM,KAAK,MAAM,sBAExC,CAAC;AAEF,qBAAa,iBAAiB;IAC5B,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,WAAW,CAAC;gBACP,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,WAAW;IAMrE,KAAK,CAAC,OAAO,CAAC,EAAE,YAAY,GAAG,MAAM;CAGtC"}

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

@@ -0,0 +1,16 @@
+export const cdot = (a, b) => {
+    return new ScalarProductNode(a, b);
+};
+export class ScalarProductNode {
+    leftChild;
+    rightChild;
+    opts;
+    constructor(leftChild, rightChild, opts) {
+        this.leftChild = leftChild;
+        this.rightChild = rightChild;
+        this.opts = opts;
+    }
+    toTex(options) {
+        return `${this.leftChild.toTex()}\\cdot ${this.rightChild.toTex()}`;
+    }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "math-exercises",
   "type": "module",
-  "version": "3.0.18",
+  "version": "3.0.20",
   "description": "Math exercises generator for middle school and high school",
   "main": "lib/index.js",
   "files": [
@@ -18,7 +18,8 @@
     "testpdf": "npm run build && node lib/tests/pdfExo.test.js",
     "testsimplify": "npx jest simplify.test.js",
     "prepublishOnly": "npm run build",
-    "build": "tsc && tsc-alias"
+    "build": "tsc && tsc-alias",
+    "patch": "npm run testml && npm version patch && npm publish"
   },
   "keywords": [],
   "author": "Heureux Hasard",