math-exercises 2.2.70 → 2.2.71

package/lib/exercises/math/calcul/fractions/fractionsOperations.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fractionsOperations.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/fractions/fractionsOperations.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,0BAA0B,CAAC;AAKlC,OAAO,EAEL,eAAe,EAChB,MAAM,kCAAkC,CAAC;AAS1C,KAAK,WAAW,GAAG;IACjB,oBAAoB,EAAE,eAAe,CAAC;CACvC,CAAC;AA8EF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAgBrD,CAAC"}
+{"version":3,"file":"fractionsOperations.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/fractions/fractionsOperations.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,0BAA0B,CAAC;AAKlC,OAAO,EAEL,eAAe,EAChB,MAAM,kCAAkC,CAAC;AAS1C,KAAK,WAAW,GAAG;IACjB,oBAAoB,EAAE,eAAe,CAAC;CACvC,CAAC;AAqFF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAgBrD,CAAC"}

package/lib/exercises/math/calcul/fractions/fractionsOperations.js

@@ -20,7 +20,6 @@ const getPropositions = (n, { answer }) => {
     return (0, exercise_1.shuffleProps)(propositions, n);
 };
 const getAnswer = (identifiers) => {
-    console.log(identifiers);
     const statement = nodeConstructor_1.NodeConstructor.fromIdentifiers(identifiers.statementIdentifiers);
     return statement.simplify().toTex();
 };
@@ -52,7 +51,12 @@ const getFractionsOperationsQuestion = (ops) => {
         rational_1.RationalConstructor.randomIrreductible().toTree(),
     ];
     const statement = firstOp(secondOp(rationals[0], rationals[1]), rationals[2]);
-    statement.shuffle();
+    //éviter division par une soustraction qui donne 0
+    if (firstOpIndex !== 3 ||
+        secondOpIndex !== 1 ||
+        rationals[0].evaluate() - rationals[1].evaluate() !== 0) {
+        statement.shuffle();
+    }
     const ids = statement.toIdentifiers();
     const identifiers = {
         statementIdentifiers: ids,

package/lib/exercises/math/calculLitteral/distributivity/doubleDistributivitySubstract.d.ts

@@ -0,0 +1,12 @@
+import { Exercise } from "../../../../exercises/exercise";
+import { GeneralAffineIdentifiers } from "../../../../math/polynomials/generalAffine";
+type Identifiers = {
+    type: number;
+    affine1: GeneralAffineIdentifiers;
+    affine2: GeneralAffineIdentifiers;
+    affine3: GeneralAffineIdentifiers;
+    affine4?: GeneralAffineIdentifiers;
+};
+export declare const doubleDistributivitySubstract: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=doubleDistributivitySubstract.d.ts.map

package/lib/exercises/math/calculLitteral/distributivity/doubleDistributivitySubstract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"doubleDistributivitySubstract.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/distributivity/doubleDistributivitySubstract.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,0BAA0B,CAAC;AAElC,OAAO,EAGL,wBAAwB,EACzB,MAAM,sCAAsC,CAAC;AAU9C,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IAEb,OAAO,EAAE,wBAAwB,CAAC;IAClC,OAAO,EAAE,wBAAwB,CAAC;IAElC,OAAO,EAAE,wBAAwB,CAAC;IAElC,OAAO,CAAC,EAAE,wBAAwB,CAAC;CACpC,CAAC;AAiIF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,CAmB/D,CAAC"}

package/lib/exercises/math/calculLitteral/distributivity/doubleDistributivitySubstract.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.doubleDistributivitySubstract = void 0;
+const exercise_1 = require("../../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const generalAffine_1 = require("../../../../math/polynomials/generalAffine");
+const randint_1 = require("../../../../math/utils/random/randint");
+const addNode_1 = require("../../../../tree/nodes/operators/addNode");
+const multiplyNode_1 = require("../../../../tree/nodes/operators/multiplyNode");
+const powerNode_1 = require("../../../../tree/nodes/operators/powerNode");
+const substractNode_1 = require("../../../../tree/nodes/operators/substractNode");
+const trinomNode_1 = require("../../../../tree/nodes/polynomials/trinomNode");
+//(ax+b)(cx+d)-ex(gx+h)
+//(ax+b)(cx+d)-(ex+f)(gx+h)
+//(ax+b)(cx+d)-(ex+-f)^2
+const getPropositions = (n, { answer, affine1, affine2, affine3, type, affine4 }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    let affs = [
+        generalAffine_1.GeneralAffineConstructor.fromIdentifiers(affine1),
+        generalAffine_1.GeneralAffineConstructor.fromIdentifiers(affine2),
+        generalAffine_1.GeneralAffineConstructor.fromIdentifiers(affine3),
+    ].map((e) => e.toTree());
+    if (affine4) {
+        affs.push(generalAffine_1.GeneralAffineConstructor.fromIdentifiers(affine4).toTree());
+    }
+    if (type === 3)
+        (0, exercise_1.tryToAddWrongProp)(propositions, (0, addNode_1.add)((0, multiplyNode_1.multiply)(affs[0], affs[1]), (0, powerNode_1.square)(affs[2]))
+            .simplify({
+            forbidFactorize: true,
+            towardsDistribute: true,
+        })
+            .toTex());
+    else
+        (0, exercise_1.tryToAddWrongProp)(propositions, (0, addNode_1.add)((0, multiplyNode_1.multiply)(affs[0], affs[1]), (0, multiplyNode_1.multiply)(affs[2], affs[3]))
+            .simplify({
+            forbidFactorize: true,
+            towardsDistribute: true,
+        })
+            .toTex());
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, trinomNode_1.TrinomNodeConstructor.random().toTex());
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const getAnswerNode = (identifiers) => {
+    return getStatementNode(identifiers).simplify({
+        forbidFactorize: true,
+        towardsDistribute: true,
+    });
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).toTex();
+};
+const getStatementNode = (identifiers) => {
+    let affs = [
+        generalAffine_1.GeneralAffineConstructor.fromIdentifiers(identifiers.affine1),
+        generalAffine_1.GeneralAffineConstructor.fromIdentifiers(identifiers.affine2),
+        generalAffine_1.GeneralAffineConstructor.fromIdentifiers(identifiers.affine3),
+    ].map((e) => e.toTree());
+    if (identifiers.affine4) {
+        affs.push(generalAffine_1.GeneralAffineConstructor.fromIdentifiers(identifiers.affine4).toTree());
+    }
+    if (identifiers.affine4)
+        return (0, substractNode_1.substract)((0, multiplyNode_1.multiply)(affs[0], affs[1]), (0, multiplyNode_1.multiply)(affs[2], affs[3]));
+    return (0, substractNode_1.substract)((0, multiplyNode_1.multiply)(affs[0], affs[1]), (0, powerNode_1.square)(affs[2]));
+};
+const getInstruction = (identifiers) => {
+    return `Développer et réduire : 
+  
+$$
+${getStatementNode(identifiers).toTex()}
+$$
+`;
+};
+// const getHint: GetHint<Identifiers> = (identifiers) => {};
+// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {};
+const getKeys = (identifiers) => {
+    return ["x"];
+};
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
+    const texs = getAnswerNode(identifiers).toAllValidTexs({});
+    return texs.includes(ans);
+};
+const getDoubleDistributivitySubstractQuestion = (ops) => {
+    const type = (0, randint_1.randint)(1, 4);
+    const affine1 = generalAffine_1.GeneralAffineConstructor.randomInts({ allowBNull: false });
+    const affine2 = generalAffine_1.GeneralAffineConstructor.randomInts({ allowBNull: false });
+    const affine3 = type === 1
+        ? new generalAffine_1.GeneralAffine((0, randint_1.randint)(-10, 11, [0]), 0)
+        : generalAffine_1.GeneralAffineConstructor.randomInts({ allowBNull: false });
+    const affine4 = type === 3
+        ? undefined
+        : generalAffine_1.GeneralAffineConstructor.randomInts({ allowBNull: false });
+    const identifiers = {
+        type,
+        affine1: affine1.toIdentifiers(),
+        affine2: affine2.toIdentifiers(),
+        affine3: affine3.toIdentifiers(),
+        affine4: affine4?.toIdentifiers(),
+    };
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        // hint: getHint(identifiers),
+        // correction: getCorrection(identifiers),
+    };
+    return question;
+};
+exports.doubleDistributivitySubstract = {
+    id: "doubleDistributivitySubstract",
+    connector: "=",
+    label: "Double distributivité : soustraction de deux produits",
+    isSingleStep: false,
+    generator: (nb, opts) => (0, getDistinctQuestions_1.getDistinctQuestions)(() => getDoubleDistributivitySubstractQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    // getHint,
+    // getCorrection,
+    getAnswer,
+};

package/lib/exercises/math/calculLitteral/distributivity/index.d.ts

@@ -7,4 +7,5 @@ export { thirdIdentity } from "./thirdIdentity";
 export * from "./doubleDistributivityWithCoeff";
 export * from "./canonicalFormDevelopment";
 export * from "./simpleDistriXCoeff";
+export * from "./doubleDistributivitySubstract";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/calculLitteral/distributivity/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/distributivity/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,wBAAwB,CAAC;AACvC,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,cAAc,wBAAwB,CAAC;AACvC,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,cAAc,iCAAiC,CAAC;AAChD,cAAc,4BAA4B,CAAC;AAC3C,cAAc,sBAAsB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/distributivity/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,wBAAwB,CAAC;AACvC,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,cAAc,wBAAwB,CAAC;AACvC,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,cAAc,iCAAiC,CAAC;AAChD,cAAc,4BAA4B,CAAC;AAC3C,cAAc,sBAAsB,CAAC;AACrC,cAAc,iCAAiC,CAAC"}

package/lib/exercises/math/calculLitteral/distributivity/index.js

@@ -27,3 +27,4 @@ Object.defineProperty(exports, "thirdIdentity", { enumerable: true, get: functio
 __exportStar(require("./doubleDistributivityWithCoeff"), exports);
 __exportStar(require("./canonicalFormDevelopment"), exports);
 __exportStar(require("./simpleDistriXCoeff"), exports);
+__exportStar(require("./doubleDistributivitySubstract"), exports);

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

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

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

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

package/lib/exercises/math/geometry/angles/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("./recognizeAngleType"), exports);

package/lib/exercises/math/geometry/angles/recognizeAngleType.d.ts

@@ -0,0 +1,11 @@
+import { Exercise } from "../../../../exercises/exercise";
+import { PointIdentifiers } from "../../../../math/geometry/point";
+type Identifiers = {
+    points: PointIdentifiers[];
+    angleType: string;
+    angleIndex: number;
+    apexIndex: number;
+};
+export declare const recognizeAngleType: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=recognizeAngleType.d.ts.map

package/lib/exercises/math/geometry/angles/recognizeAngleType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recognizeAngleType.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/angles/recognizeAngleType.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,0BAA0B,CAAC;AASlC,OAAO,EAGL,gBAAgB,EACjB,MAAM,2BAA2B,CAAC;AAWnC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,gBAAgB,EAAE,CAAC;IAC3B,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AA8TF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAkBpD,CAAC"}

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

@@ -0,0 +1,272 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.recognizeAngleType = void 0;
+const exercise_1 = require("../../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const geogebraConstructor_1 = require("../../../../geogebra/geogebraConstructor");
+const angle_1 = require("../../../../math/geometry/angle");
+const line_1 = require("../../../../math/geometry/line");
+const point_1 = require("../../../../math/geometry/point");
+const randfloat_1 = require("../../../../math/utils/random/randfloat");
+const randint_1 = require("../../../../math/utils/random/randint");
+const numberNode_1 = require("../../../../tree/nodes/numbers/numberNode");
+const random_1 = require("../../../../utils/alea/random");
+const isLetter_1 = require("../../../../utils/strings/isLetter");
+const randomLetter_1 = require("../../../../utils/strings/randomLetter");
+const getAngle = (identifiers) => {
+    const indexes = getAnglePointsIndexes(identifiers.angleIndex, identifiers.apexIndex);
+    return new angle_1.Angle(indexes.map((i) => point_1.PointConstructor.fromIdentifiers(identifiers.points[i])));
+};
+const getAnglePointsIndexes = (angleIndex, apexIndex) => {
+    const angles = [
+        [apexIndex + 2, apexIndex, apexIndex + 1],
+        [(apexIndex + 3 + 12) % 12, apexIndex, apexIndex + 2],
+        [(apexIndex - 3 + 12) % 12, apexIndex, (apexIndex + 3 + 12) % 12],
+        [apexIndex + 1, apexIndex, (apexIndex - 3 + 12) % 12],
+    ];
+    //les angles 0 ne peuvent pas etre alterne-interne
+    return angles[angleIndex];
+};
+const getPropositions = (n, { answer, angleIndex, angleType, apexIndex, points }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    let anglesPointsIndexes = [];
+    switch (angleType) {
+        case "alterne-interne":
+            //angles 0 exclus
+            if (angleIndex === 1) {
+                //angle+1 de l'apex supérieur
+                //angles 1: une solution :
+                anglesPointsIndexes = [
+                    getAnglePointsIndexes(angleIndex, (apexIndex + 3) % 12),
+                    getAnglePointsIndexes((angleIndex + 2) % 4, (apexIndex + 3) % 12),
+                    getAnglePointsIndexes((angleIndex + 3) % 4, (apexIndex + 3) % 12),
+                ];
+            }
+            if (angleIndex === 2) {
+                //angles 2 ont deux solution :
+                //-- apex inférieur : angle -1
+                //-- apex supérieur : angle +1
+                //on choisit l'apex supérieur arbitrairement
+                anglesPointsIndexes = [
+                    getAnglePointsIndexes(angleIndex, (apexIndex + 3 + 12) % 12),
+                    getAnglePointsIndexes((angleIndex + 2) % 4, (apexIndex + 3 + 12) % 12),
+                    getAnglePointsIndexes((angleIndex + 3) % 4, (apexIndex + 3 + 12) % 12),
+                ];
+            }
+            //angles 3 : une solution :
+            //-- angle-1 de l'apex inférieur
+            if (angleIndex === 3) {
+                anglesPointsIndexes = [
+                    getAnglePointsIndexes(angleIndex, (apexIndex - 3 + 12) % 12),
+                    getAnglePointsIndexes((angleIndex + 2) % 4, (apexIndex - 3 + 12) % 12),
+                    getAnglePointsIndexes((angleIndex + 1) % 4, (apexIndex - 3 + 12) % 12),
+                ];
+            }
+            break;
+        case "correspondant":
+            //deux solutions :
+            //-- apex supérieur: angle-1
+            //-- apex inférieur : angle +1
+            //on choisit l'apex supérieur arbitrairement
+            anglesPointsIndexes = [
+                getAnglePointsIndexes(angleIndex, (apexIndex + 3 + 12) % 12),
+                getAnglePointsIndexes((angleIndex + 1) % 4, (apexIndex + 3 + 12) % 12),
+                getAnglePointsIndexes((angleIndex + 2) % 4, (apexIndex + 3 + 12) % 12),
+            ];
+            break;
+        case "opposé par le sommet":
+        default:
+            //sol == angle +2 du meme apex
+            anglesPointsIndexes = [
+                getAnglePointsIndexes(angleIndex, apexIndex),
+                getAnglePointsIndexes((angleIndex + 1) % 4, apexIndex),
+                getAnglePointsIndexes((angleIndex + 3) % 4, apexIndex),
+            ];
+            break;
+    }
+    anglesPointsIndexes.forEach((indexes) => {
+        (0, exercise_1.tryToAddWrongProp)(propositions, new angle_1.Angle(indexes.map((i) => point_1.PointConstructor.fromIdentifiers(points[i]))).toTex());
+    });
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const getAnswerAngle = (identifiers) => {
+    const { angleIndex, angleType, apexIndex, points } = identifiers;
+    let anglePointsIndexes = [];
+    switch (angleType) {
+        case "alterne-interne":
+            //angles 0 exclus
+            if (angleIndex === 1) {
+                //angles 1: une solution :
+                //angle+1 de l'apex supérieur
+                anglePointsIndexes = getAnglePointsIndexes((angleIndex + 1) % 4, (identifiers.apexIndex + 3) % 12);
+            }
+            if (angleIndex === 2) {
+                //angles 2 ont deux solution :
+                //-- apex inférieur : angle -1
+                //-- apex supérieur : angle +1
+                //on choisit l'apex supérieur arbitrairement
+                anglePointsIndexes = getAnglePointsIndexes((angleIndex + 1) % 4, (identifiers.apexIndex + 3 + 12) % 12);
+            }
+            //angles 3 : une solution :
+            //-- angle-1 de l'apex inférieur
+            if (angleIndex === 3) {
+                anglePointsIndexes = getAnglePointsIndexes((angleIndex - 1 + 4) % 4, (identifiers.apexIndex - 3 + 12) % 12);
+            }
+            break;
+        case "correspondant":
+            //deux solutions :
+            //-- apex supérieur: angle-1
+            //-- apex inférieur : angle +1
+            //on choisit l'apex supérieur arbitrairement
+            anglePointsIndexes = getAnglePointsIndexes((angleIndex - 1 + 4) % 4, (identifiers.apexIndex + 3 + 12) % 12);
+            break;
+        case "opposé par le sommet":
+        default:
+            //angle +2 du meme apex
+            anglePointsIndexes = getAnglePointsIndexes((angleIndex + 2) % 4, identifiers.apexIndex);
+            break;
+    }
+    const angle = new angle_1.Angle(anglePointsIndexes.map((i) => point_1.PointConstructor.fromIdentifiers(points[i])));
+    return angle;
+};
+const getAnswer = (identifiers) => {
+    return getAnswerAngle(identifiers).toTex();
+};
+const getInstruction = (identifiers) => {
+    const angleTex = getAngle(identifiers).toTex();
+    return `Donner un angle ${identifiers.angleType} à l'angle $${angleTex}$.`;
+};
+// const getHint: GetHint<Identifiers> = (identifiers) => {};
+// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {};
+const getGGBOptions = (identifiers) => {
+    const points = identifiers.points.map(point_1.PointConstructor.fromIdentifiers);
+    const lines = [
+        new line_1.Line(points[0], points[3]),
+        new line_1.Line(points[3], points[6]),
+        new line_1.Line(points[6], points[9]),
+        new line_1.Line(points[9], points[0]),
+    ];
+    const angle = getAngle(identifiers);
+    const ggb = new geogebraConstructor_1.GeogebraConstructor({
+        commands: [
+            ...points.flatMap((p) => p.toGGBCommand()),
+            ...lines.flatMap((l) => l.toGGBCommands(false)),
+            ...angle.toCommands({ color: "red" }),
+        ],
+        hideAxes: true,
+        hideGrid: true,
+    });
+    return ggb.getOptions({
+        coords: [-5, 5, -5, 5],
+    });
+};
+const getKeys = (identifiers) => {
+    const points = identifiers.points.map(point_1.PointConstructor.fromIdentifiers);
+    //! devrait on mettre widehat
+    return points.map((p) => p.name);
+};
+const isAnswerValid = (ans, { answer, angleIndex, angleType, apexIndex, points }) => {
+    let formated = ans;
+    if (ans.includes("widehat")) {
+        formated = formated.replaceAll("\\widehat{", "").replaceAll("}", "");
+    }
+    const pointsNames = Array.from(new Set(formated.split("")));
+    if (pointsNames.length !== 3 || pointsNames.some((char) => !(0, isLetter_1.isLetter)(char)))
+        return false;
+    const studentPoints = pointsNames.map((char) => point_1.PointConstructor.fromIdentifiers(points.find((p) => p.name === char)));
+    const answerAngle = getAngle({ angleIndex, apexIndex, points });
+    const studentAngle = new angle_1.Angle(studentPoints);
+    //? on va accpter aussi des angles correspondants ou alternes-internes qui ne sont pas définis par les sécantes tracées
+    //? c'est chelou mais dans le fond ça fait sens (c'est vrai mathémtiquement)
+    switch (angleType) {
+        case "opposé par le sommet":
+            return studentAngle.isSummitOpposite(answerAngle);
+        case "alterne-interne":
+            return studentAngle.isAlterneInterne(answerAngle);
+            break;
+        case "correspondant":
+        default:
+            return studentAngle.isCorrespondant(answerAngle);
+            break;
+    }
+    return false;
+};
+//deux paires de sécantes
+const getRecognizeAngleTypeQuestion = (opts) => {
+    const angleType = (0, random_1.random)([
+        "alterne-interne",
+        "correspondant",
+        "opposé par le sommet",
+    ]);
+    const names = [];
+    for (let i = 0; i < 12; i++) {
+        names.push((0, randomLetter_1.randomLetter)(true, names));
+    }
+    const buildIntersectionsPoints = (index) => {
+        //les 4 intersections sont (+-2, +-2)
+        let [x, y] = [index < 3 || index > 8 ? -2 : 2, index < 6 ? 2 : -2];
+        //bruit
+        x += (0, randfloat_1.randfloat)(-1, 1, 1);
+        y += (0, randfloat_1.randfloat)(-1, 1, 1);
+        return new point_1.Point(names[index], x.toTree(), y.toTree());
+    };
+    const intersections = [0, 3, 6, 9].map(buildIntersectionsPoints);
+    const buildAnglesPoints = (index) => {
+        const intersectionIndex = Math.floor(index / 3);
+        const apex = intersections[intersectionIndex];
+        const next = intersections[(intersectionIndex + 1) % 4];
+        const prev = intersections[(intersectionIndex - 1 + 4) % 4];
+        let [x, y] = [apex.x.evaluate(), apex.y.evaluate()];
+        if (index % 2 === 0) {
+            const line = new line_1.Line(apex, intersectionIndex % 2 === 0 ? prev : next);
+            //lignes verticales (ordonnées +-1)
+            y = y + (y < 0 ? -1 : 1);
+            return line.getPointWithY(new numberNode_1.NumberNode(y), names[index]);
+        }
+        else {
+            //lignes horizontales (abscisse +-1)
+            const line = new line_1.Line(apex, intersectionIndex % 2 === 0 ? next : prev);
+            x = x + (x < 0 ? -1 : 1);
+            return line.getPointWithX(new numberNode_1.NumberNode(x), names[index]);
+        }
+    };
+    const points = names.map((n, i) => i % 3 === 0 ? intersections[Math.floor(i / 3)] : buildAnglesPoints(i));
+    const apex = (0, random_1.random)([0, 3, 6, 9]);
+    //les angles 0 ne peuvent pas etre alterne-interne
+    let angleIndex = (0, randint_1.randint)(angleType !== "alterne-interne" ? 0 : 1, 4);
+    const identifiers = {
+        angleType,
+        apexIndex: apex,
+        angleIndex,
+        points: points.map((p) => p.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;
+};
+exports.recognizeAngleType = {
+    id: "recognizeAngleType",
+    label: "Reconnaître un angle alterne-interne, correspondant, opposé par le sommet",
+    isSingleStep: true,
+    generator: (nb, opts) => (0, getDistinctQuestions_1.getDistinctQuestions)(() => getRecognizeAngleTypeQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    // getHint,
+    // getCorrection,
+    getInstruction,
+    getAnswer,
+    getGGBOptions,
+    hasGeogebra: true,
+};

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

@@ -23,7 +23,7 @@ const getEndPoint = (identifiers) => {
     ];
     const vector = vector_1.VectorConstructor.fromPoints(translationPoints[0], translationPoints[1]);
     const startPoint = point_1.PointConstructor.fromIdentifiers(identifiers.points.find((p) => p.name === identifiers.startPoint));
-    const end = vector.getEndPoint(startPoint, "M");
+    const end = vector.getEndPoint(startPoint, identifiers.startPoint + "'");
     return end;
 };
 // const getHint: GetHint<Identifiers> = (identifiers) => {};

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

@@ -10,4 +10,5 @@ export * from "./euclidianConstructions";
 export * from "./shapes";
 export * from "./parametric";
 export * from "./quadrilaterals";
+export * from "./angles";
 //# 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;AAE1B,cAAc,0BAA0B,CAAC;AACzC,cAAc,UAAU,CAAC;AAEzB,cAAc,cAAc,CAAC;AAC7B,cAAc,kBAAkB,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;AACzC,cAAc,UAAU,CAAC;AAEzB,cAAc,cAAc,CAAC;AAC7B,cAAc,kBAAkB,CAAC;AACjC,cAAc,UAAU,CAAC"}

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

@@ -28,3 +28,4 @@ __exportStar(require("./shapes"), exports);
 // export * from "./euclidian";
 __exportStar(require("./parametric"), exports);
 __exportStar(require("./quadrilaterals"), exports);
+__exportStar(require("./angles"), exports);

package/lib/exercises/math/geometry/volumes/parallelepipedVolume.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parallelepipedVolume.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/volumes/parallelepipedVolume.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAOlC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAoIF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CActD,CAAC"}
+{"version":3,"file":"parallelepipedVolume.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/volumes/parallelepipedVolume.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAOlC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAmIF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CActD,CAAC"}

package/lib/exercises/math/geometry/volumes/parallelepipedVolume.js

@@ -102,7 +102,6 @@ const getPropositions = (n, { answer, length, width, height }) => {
         const wrongLength = length + (0, randint_1.randint)(1, 5);
         const wrongWidth = width + (0, randint_1.randint)(1, 5);
         const wrongHeight = height + (0, randint_1.randint)(1, 5);
-        console.log(wrongLength, wrongWidth, wrongHeight);
         const wrongVolume = (0, round_1.round)(wrongLength * wrongWidth * wrongHeight, 2)
             .toTree()
             .toTex();

package/lib/index.d.ts

@@ -230,6 +230,12 @@ declare const mathExercises: (Exercise<{
     a: number;
     b: number;
     c: number;
+}, {}> | Exercise<{
+    type: number;
+    affine1: import("./math/polynomials/generalAffine").GeneralAffineIdentifiers;
+    affine2: import("./math/polynomials/generalAffine").GeneralAffineIdentifiers;
+    affine3: import("./math/polynomials/generalAffine").GeneralAffineIdentifiers;
+    affine4?: import("./math/polynomials/generalAffine").GeneralAffineIdentifiers | undefined;
 }, {}> | Exercise<{
     randNbr: number;
 }, {}> | Exercise<{
@@ -1175,6 +1181,11 @@ declare const mathExercises: (Exercise<{
     showDiagonals: boolean;
     drawAngles: boolean;
     shapeIdentifiers: import("./math/geometry/parallelogram").ParallelogramIdentifiers | import("./math/geometry/rhombus").RhombusIdentifiers | import("./math/geometry/rectangle").RectangleIdentifiers | import("./math/geometry/square").SquareIdentifiers;
+}, {}> | Exercise<{
+    points: import("./math/geometry/point").PointIdentifiers[];
+    angleType: string;
+    angleIndex: number;
+    apexIndex: number;
 }, {}> | 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,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAG1D,OAAO,yBAAyB,CAAC;AAEjC,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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

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

@@ -1,18 +1,39 @@
 import { AlgebraicNode } from "../../tree/nodes/algebraicNode";
-import { Point } from "./point";
+import { Point, PointIdentifiers } from "./point";
+import { NodeIdentifiers } from "../../tree/nodes/nodeConstructor";
+export declare abstract class AngleConstructor {
+    static fromIdentifiers(identifiers: AngleIdentifiers): Angle;
+}
 type AngleProps = {
     radianValueNode?: AlgebraicNode;
     degreeValueNode?: AlgebraicNode;
 };
+type AnglePropsIdentifiers = {
+    radianValueNode?: NodeIdentifiers;
+    degreeValueNode?: NodeIdentifiers;
+};
+export type AngleIdentifiers = {
+    points: PointIdentifiers[];
+    props?: AnglePropsIdentifiers;
+};
 export declare class Angle {
     points: Point[];
     radianValueNode?: AlgebraicNode;
     degreeValueNode?: AlgebraicNode;
+    props?: AngleProps;
     /**
      *
      * @param points [pointA, pointB, pointC] with apex = B
      */
     constructor(points: Point[], props?: AngleProps);
+    toIdentifiers(): AngleIdentifiers;
+    hasSameApex(a: Angle): boolean;
+    equals(a: Angle): boolean;
+    isAlterne(a: Angle): boolean;
+    isAlterneInterne(a: Angle): boolean;
+    isFlat(): boolean;
+    isCorrespondant(a: Angle): boolean;
+    isSummitOpposite(a: Angle): boolean;
     evaluate(inRadian?: boolean): number;
     getValueNode(inDegree?: boolean): AlgebraicNode | import("../../tree/nodes/numbers/constantNode").ConstantNode | import("../../tree/nodes/numbers/numberNode").NumberNode;
     isRight(): boolean;

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

@@ -1 +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"}
+{"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,EAAoB,gBAAgB,EAAE,MAAM,SAAS,CAAC;AACpE,OAAO,EACL,eAAe,EAEhB,MAAM,kCAAkC,CAAC;AAI1C,8BAAsB,gBAAgB;IACpC,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,gBAAgB;CAUrD;AACD,KAAK,UAAU,GAAG;IAChB,eAAe,CAAC,EAAE,aAAa,CAAC;IAChC,eAAe,CAAC,EAAE,aAAa,CAAC;CACjC,CAAC;AAEF,KAAK,qBAAqB,GAAG;IAC3B,eAAe,CAAC,EAAE,eAAe,CAAC;IAClC,eAAe,CAAC,EAAE,eAAe,CAAC;CACnC,CAAC;AACF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,MAAM,EAAE,gBAAgB,EAAE,CAAC;IAC3B,KAAK,CAAC,EAAE,qBAAqB,CAAC;CAC/B,CAAC;AACF,qBAAa,KAAK;IAChB,MAAM,EAAE,KAAK,EAAE,CAAC;IAChB,eAAe,CAAC,EAAE,aAAa,CAAC;IAChC,eAAe,CAAC,EAAE,aAAa,CAAC;IAChC,KAAK,CAAC,EAAE,UAAU,CAAC;IACnB;;;OAGG;gBACS,MAAM,EAAE,KAAK,EAAE,EAAE,KAAK,CAAC,EAAE,UAAU;IAkB/C,aAAa,IAAI,gBAAgB;IASjC,WAAW,CAAC,CAAC,EAAE,KAAK;IAIpB,MAAM,CAAC,CAAC,EAAE,KAAK;IAqBf,SAAS,CAAC,CAAC,EAAE,KAAK;IASlB,gBAAgB,CAAC,CAAC,EAAE,KAAK;IAwCzB,MAAM;IAMN,eAAe,CAAC,CAAC,EAAE,KAAK;IAsCxB,gBAAgB,CAAC,CAAC,EAAE,KAAK;IAoBzB,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"}