math-exercises 3.0.126 → 3.0.128

package/lib/exercises/pc/motion/typeOfAcceleration.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"typeOfAcceleration.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/motion/typeOfAcceleration.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,IAAI,EAAE,MAAM,CAAC;CAEd,CAAC;AA2FF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAcpD,CAAC"}
+{"version":3,"file":"typeOfAcceleration.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/motion/typeOfAcceleration.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,IAAI,EAAE,MAAM,CAAC;CAEd,CAAC;AAuFF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAapD,CAAC"}

package/lib/exercises/pc/motion/typeOfAcceleration.js

@@ -79,9 +79,6 @@ const getPropositions = (n, { answer }) => {
     tryToAddWrongProp(propositions, "On ne peut pas savoir", "raw");
     return shuffleProps(propositions, n);
 };
-const isAnswerValid = (ans, { answer }) => {
-    return ans === answer;
-};
 export const typeOfAcceleration = {
     id: "typeOfAcceleration",
     label: "Déterminer le type d'accélération du mouvement d'un objet",
@@ -90,7 +87,6 @@ export const typeOfAcceleration = {
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
-    isAnswerValid,
     hasGeogebra: true,
     answerType: "QCU",
     subject: "Physique",

package/lib/exercises/pc/sound/frequencyComparison.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"frequencyComparison.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/sound/frequencyComparison.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAKrC,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAwEF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAcrD,CAAC"}
+{"version":3,"file":"frequencyComparison.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/sound/frequencyComparison.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAKrC,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAoEF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAarD,CAAC"}

package/lib/exercises/pc/sound/frequencyComparison.js

@@ -41,9 +41,6 @@ const getPropositions = (n, { answer, soundAsked }) => {
     tryToAddWrongProp(propositions, `Aussi aigu que le son $${soundCompared}$`, "raw");
     return shuffleProps(propositions, n);
 };
-const isAnswerValid = (ans, { answer }) => {
-    return ans === answer;
-};
 export const frequencyComparison = {
     id: "frequencyComparison",
     label: "Comparer deux fréquences sonores",
@@ -52,7 +49,6 @@ export const frequencyComparison = {
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
-    isAnswerValid,
     subject: "Physique",
     answerType: "QCU",
     pdfOptions: { shouldSpreadPropositions: true },

package/lib/index.d.ts

@@ -159,7 +159,7 @@ declare const mathExercises: (Exercise<{
     nodeIdsStartingNumber: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
     progCalcIds: import("./math/progCalc/progCalc.js").ProgCalcIdentifiers;
 }, {
-    numberType: "Integer" | "Decimal";
+    numberType: "Entier" | "D\u00E9cimal";
     nbSteps: number;
     nbDigits: number;
 }, string | number | boolean | string[] | number[] | boolean[]> | Exercise<{
@@ -734,7 +734,9 @@ declare const mathExercises: (Exercise<{
 }, object, string | number | boolean | string[] | number[] | boolean[]> | Exercise<{
     distance: number;
     minutes: number;
-}, object, string | number | boolean | string[] | number[] | boolean[]> | Exercise<{
+}, {
+    unitTex: string;
+}, string | number | boolean | string[] | number[] | boolean[]> | Exercise<{
     isSecondsToHours: boolean;
     nodeIdsSeconds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
     nodeIdsHours: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
@@ -1019,6 +1021,8 @@ declare const mathExercises: (Exercise<{
     items: {
         tex: string;
         isValid: boolean;
+        point?: import("./math/geometry/point.js").PointIdentifiers | undefined;
+        isPointValid?: boolean;
     }[];
 }, object, string | number | boolean | string[] | number[] | boolean[]> | Exercise<{
     pointIdsA: import("./math/geometry/point.js").PointIdentifiers;
@@ -2464,7 +2468,6 @@ declare const mathExercises: (Exercise<{
         isTailoredStr: boolean;
     };
     arrProba: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
-    isProbasAreNumbers: boolean;
 }, {
     nbElem: number[];
     unionLength: number[];
@@ -2920,8 +2923,10 @@ declare const mathExercises: (Exercise<{
     };
     questionStr: string;
     answerStr: string;
-    displayType: "horizMulti" | "vertStacked";
-}, object, string | number | boolean | string[] | number[] | boolean[]> | Exercise<{
+    displayType: string;
+}, {
+    displayType: string;
+}, string | number | boolean | string[] | number[] | boolean[]> | Exercise<{
     indexSituation: number;
     bigNumber: number;
 }, object, string | number | boolean | string[] | number[] | boolean[]> | Exercise<{

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;AAC7D,OAAO,KAAK,aAAa,MAAM,2BAA2B,CAAC;AAE3D,OAAO,4BAA4B,CAAC;AACpC,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0EAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kEAA6B,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":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,KAAK,aAAa,MAAM,2BAA2B,CAAC;AAE3D,OAAO,4BAA4B,CAAC;AACpC,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0EAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kEAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAE,cAAc,EAAE,CAAC"}

package/lib/math/progCalc/progCalc.d.ts

@@ -18,9 +18,9 @@ export type ProgCalcOperationIdentifiers = {
 export declare class ProgCalcOperation {
     operationIds: ProgCalcOperationIdentifiers;
     strFrench: string;
-    func: (node: AlgebraicNode) => AlgebraicNode;
+    func: (node: AlgebraicNode) => AlgebraicNode | undefined;
     inverseOperationIds: ProgCalcOperationIdentifiers;
-    constructor(operationIds: ProgCalcOperationIdentifiers, strFrench: string, func: (node: AlgebraicNode) => AlgebraicNode, inverseOperationIds: ProgCalcOperationIdentifiers);
+    constructor(operationIds: ProgCalcOperationIdentifiers, strFrench: string, func: (node: AlgebraicNode) => AlgebraicNode | undefined, inverseOperationIds: ProgCalcOperationIdentifiers);
     getInverseOperation(): ProgCalcOperation;
     toIdentifiers(): ProgCalcOperationIdentifiers;
 }
@@ -37,7 +37,7 @@ export declare abstract class ProgCalcConstructor {
 export declare class ProgCalc {
     operations: ProgCalcOperation[];
     constructor(arrOperation: ProgCalcOperation[]);
-    apply(node: AlgebraicNode): AlgebraicNode;
+    apply(node: AlgebraicNode): AlgebraicNode | undefined;
     getArrOfFrenchStrings(): string[];
     getInverseProgCalc(): ProgCalc | undefined;
     toTree(nodeVariable: VariableNode): AlgebraicNode;

package/lib/math/progCalc/progCalc.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"progCalc.d.ts","sourceRoot":"","sources":["../../../src/math/progCalc/progCalc.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAMlE,OAAO,EAAE,YAAY,EAAE,MAAM,4CAA4C,CAAC;AAI1E,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAG7C,MAAM,MAAM,gBAAgB,GACxB,UAAU,GACV,SAAS,GACT,KAAK,GACL,UAAU,GACV,UAAU,GACV,QAAQ,CAAC;AAEb,MAAM,WAAW,iCAAiC;IAChD,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,WAAW,EAAE,MAAM,MAAM,GAAG,SAAS,CAAC;CACvC;AAED,eAAO,MAAM,qBAAqB,EAAE,iCAAiC,EA2BpE,CAAC;AAEF,8BAAsB,4BAA4B;IAChD,MAAM,CAAC,qBAAqB,CAAC,WAAW,EAAE,iCAAiC;IAS3E,MAAM,CAAC,eAAe,CAAC,KAAK,EAAE,4BAA4B;CAwE3D;AAED,MAAM,MAAM,4BAA4B,GAAG;IACzC,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,KAAK,CAAC,EAAE,eAAe,CAAC;CACzB,CAAC;AAEF,qBAAa,iBAAiB;IAC5B,YAAY,EAAE,4BAA4B,CAAC;IAC3C,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,CAAC,IAAI,EAAE,aAAa,KAAK,aAAa,CAAC;IAC7C,mBAAmB,EAAE,4BAA4B,CAAC;gBAGhD,YAAY,EAAE,4BAA4B,EAC1C,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,CAAC,IAAI,EAAE,aAAa,KAAK,aAAa,EAC5C,mBAAmB,EAAE,4BAA4B;IAQnD,mBAAmB,IAAI,iBAAiB;IAMxC,aAAa,IAAI,4BAA4B;CAG9C;AAED,MAAM,MAAM,mBAAmB,GAAG;IAChC,YAAY,EAAE,4BAA4B,EAAE,CAAC;CAC9C,CAAC;AAEF,8BAAsB,mBAAmB;IACvC,MAAM,CAAC,MAAM,CACX,OAAO,EAAE,MAAM,EACf,oBAAoB,GAAE,OAAc,EACpC,uBAAuB,GAAE,iCAAiC,EAA0B;IAatF,MAAM,CAAC,mBAAmB,CACxB,OAAO,EAAE,MAAM,EACf,oBAAoB,EAAE,OAAO,EAC7B,uBAAuB,EAAE,iCAAiC,EAAE,EAC5D,iBAAiB,EAAE,iCAAiC,EAAE;IAyBxD,MAAM,CAAC,mBAAmB,CACxB,OAAO,GAAE,MAAU,EACnB,oBAAoB,GAAE,OAAc;IA6CtC,MAAM,CAAC,YAAY,CACjB,OAAO,EAAE,MAAM,EACf,kBAAkB,EAAE,aAAa,EACjC,QAAQ,GAAE,MAAU,EACpB,oBAAoB,GAAE,OAAc;IA2EtC,MAAM,CAAC,eAAe,CAAC,KAAK,EAAE,mBAAmB;CAMlD;AAED,qBAAa,QAAQ;IACnB,UAAU,EAAE,iBAAiB,EAAE,CAAC;gBAEpB,YAAY,EAAE,iBAAiB,EAAE;IAI7C,KAAK,CAAC,IAAI,EAAE,aAAa,GAAG,aAAa;IASzC,qBAAqB,IAAI,MAAM,EAAE;IAIjC,kBAAkB,IAAI,QAAQ,GAAG,SAAS;IAO1C,MAAM,CAAC,YAAY,EAAE,YAAY,GAAG,aAAa;IAIjD,aAAa,IAAI,mBAAmB;CAOrC"}
+{"version":3,"file":"progCalc.d.ts","sourceRoot":"","sources":["../../../src/math/progCalc/progCalc.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAMlE,OAAO,EAAE,YAAY,EAAE,MAAM,4CAA4C,CAAC;AAI1E,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAG7C,MAAM,MAAM,gBAAgB,GACxB,UAAU,GACV,SAAS,GACT,KAAK,GACL,UAAU,GACV,UAAU,GACV,QAAQ,CAAC;AAEb,MAAM,WAAW,iCAAiC;IAChD,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,WAAW,EAAE,MAAM,MAAM,GAAG,SAAS,CAAC;CACvC;AAED,eAAO,MAAM,qBAAqB,EAAE,iCAAiC,EA2BpE,CAAC;AAEF,8BAAsB,4BAA4B;IAChD,MAAM,CAAC,qBAAqB,CAAC,WAAW,EAAE,iCAAiC;IAS3E,MAAM,CAAC,eAAe,CAAC,KAAK,EAAE,4BAA4B;CA8E3D;AAED,MAAM,MAAM,4BAA4B,GAAG;IACzC,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,KAAK,CAAC,EAAE,eAAe,CAAC;CACzB,CAAC;AAEF,qBAAa,iBAAiB;IAC5B,YAAY,EAAE,4BAA4B,CAAC;IAC3C,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,CAAC,IAAI,EAAE,aAAa,KAAK,aAAa,GAAG,SAAS,CAAC;IACzD,mBAAmB,EAAE,4BAA4B,CAAC;gBAGhD,YAAY,EAAE,4BAA4B,EAC1C,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,CAAC,IAAI,EAAE,aAAa,KAAK,aAAa,GAAG,SAAS,EACxD,mBAAmB,EAAE,4BAA4B;IAQnD,mBAAmB,IAAI,iBAAiB;IAMxC,aAAa,IAAI,4BAA4B;CAG9C;AAED,MAAM,MAAM,mBAAmB,GAAG;IAChC,YAAY,EAAE,4BAA4B,EAAE,CAAC;CAC9C,CAAC;AAEF,8BAAsB,mBAAmB;IACvC,MAAM,CAAC,MAAM,CACX,OAAO,EAAE,MAAM,EACf,oBAAoB,GAAE,OAAc,EACpC,uBAAuB,GAAE,iCAAiC,EAA0B;IAatF,MAAM,CAAC,mBAAmB,CACxB,OAAO,EAAE,MAAM,EACf,oBAAoB,EAAE,OAAO,EAC7B,uBAAuB,EAAE,iCAAiC,EAAE,EAC5D,iBAAiB,EAAE,iCAAiC,EAAE;IAyBxD,MAAM,CAAC,mBAAmB,CACxB,OAAO,GAAE,MAAU,EACnB,oBAAoB,GAAE,OAAc;IA6CtC,MAAM,CAAC,YAAY,CACjB,OAAO,EAAE,MAAM,EACf,kBAAkB,EAAE,aAAa,EACjC,QAAQ,GAAE,MAAU,EACpB,oBAAoB,GAAE,OAAc;IA4EtC,MAAM,CAAC,eAAe,CAAC,KAAK,EAAE,mBAAmB;CAMlD;AAED,qBAAa,QAAQ;IACnB,UAAU,EAAE,iBAAiB,EAAE,CAAC;gBAEpB,YAAY,EAAE,iBAAiB,EAAE;IAI7C,KAAK,CAAC,IAAI,EAAE,aAAa,GAAG,aAAa,GAAG,SAAS;IAYrD,qBAAqB,IAAI,MAAM,EAAE;IAIjC,kBAAkB,IAAI,QAAQ,GAAG,SAAS;IAO1C,MAAM,CAAC,YAAY,EAAE,YAAY,GAAG,aAAa;IAIjD,aAAa,IAAI,mBAAmB;CAOrC"}

package/lib/math/progCalc/progCalc.js

@@ -47,7 +47,14 @@ export class ProgCalcOperationConstructor {
             case "opposite":
                 return new ProgCalcOperation(opIds, `Prendre l'opposé`, (node) => opposite(node), { operator: "opposite" });
             case "inverse":
-                return new ProgCalcOperation(opIds, `Prendre l'inverse`, (node) => frac(1, node), { operator: "inverse" });
+                return new ProgCalcOperation(opIds, `Prendre l'inverse`, (node) => {
+                    if (node.simplify().evaluate() === 0) {
+                        return undefined;
+                    }
+                    else {
+                        return frac(1, node);
+                    }
+                }, { operator: "inverse" });
             case "add": {
                 const nodeParam = NodeConstructor.fromIdentifiers(opIds.param);
                 return new ProgCalcOperation(opIds, `Ajouter $ ${nodeParam.toTex()} $`, (nodeX) => add(nodeX, nodeParam), { operator: "subtract", param: opIds.param });
@@ -185,8 +192,8 @@ export class ProgCalcConstructor {
                 operation =
                     ProgCalcOperationConstructor.randomFromOpGenConfig(opGenConfig);
                 const nodeResult = operation.func(nodeCurrent);
-                const numberResult = nodeResult.evaluate();
-                const isValidResult = isInt(numberResult * Math.pow(10, nbDigits));
+                const numberResult = nodeResult && nodeResult.evaluate();
+                const isValidResult = numberResult && isInt(numberResult * Math.pow(10, nbDigits));
                 if (isValidResult) {
                     isOperationValid = true;
                     nodeCurrent = nodeResult;
@@ -216,6 +223,9 @@ export class ProgCalc {
         for (let i = 0; i < this.operations.length; i++) {
             const operation = this.operations[i];
             nodeCurrent = operation.func(nodeCurrent);
+            if (nodeCurrent === undefined) {
+                return undefined;
+            }
         }
         return nodeCurrent;
     }

package/lib/tests/exoTest.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"exoTest.d.ts","sourceRoot":"","sources":["../../src/tests/exoTest.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,6BAA6B,CAAC;AAIvD,eAAO,MAAM,OAAO,GAAI,KAAK,QAAQ,CAAC,MAAM,CAAC;;;;CA+F5C,CAAC"}
+{"version":3,"file":"exoTest.d.ts","sourceRoot":"","sources":["../../src/tests/exoTest.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,6BAA6B,CAAC;AAIvD,eAAO,MAAM,OAAO,GAAI,KAAK,QAAQ,CAAC,MAAM,CAAC;;;;CA0G5C,CAAC"}

package/lib/tests/exoTest.js

@@ -46,6 +46,13 @@ export const exoTest = (exo) => {
         if (!exo.isAnswerTableValid)
             throw new Error(`exo ${exo.id} has no isAnswerTableValid`);
     }
+    if (exo.answerType === "QCU" || exo.answerType === "QCM") {
+        if (exo.isAnswerValid)
+            throw new Error(`exo ${exo.id} has isAnswerValid but has answer type ${exo.answerType}`);
+        // console.log(
+        //   `exo ${exo.id} has isAnswerValid but has answer type ${exo.answerType}`,
+        // );
+    }
     questions.forEach((question) => {
         const times = questionTest(exo, question);
         qcmTime = times.qcmTime;

package/lib/tests/questionTest.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"questionTest.d.ts","sourceRoot":"","sources":["../../src/tests/questionTest.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,6BAA6B,CAAC;AAKjE,eAAO,MAAM,YAAY,GACvB,KAAK,QAAQ,CAAC,MAAM,CAAC,EACrB,UAAU,QAAQ,CAAC,MAAM,CAAC;;;CA0P3B,CAAC"}
+{"version":3,"file":"questionTest.d.ts","sourceRoot":"","sources":["../../src/tests/questionTest.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,6BAA6B,CAAC;AAKjE,eAAO,MAAM,YAAY,GACvB,KAAK,QAAQ,CAAC,MAAM,CAAC,EACrB,UAAU,QAAQ,CAAC,MAAM,CAAC;;;CAqP3B,CAAC"}

package/lib/tests/questionTest.js

@@ -146,6 +146,7 @@ export const questionTest = (exo, question) => {
             exo.id +
             " has answerFormat raw but answerType is not QCU or QCM");
     }
+    const jsonIds = JSON.stringify(question.identifiers);
     if (exo.answerType !== "QCM" &&
         exo.answerType !== "QCU" &&
         exo.answerType !== "GGB" &&
@@ -158,7 +159,7 @@ export const questionTest = (exo, question) => {
         const before = Date.now();
         console.log("will test vea : ", exo.id);
         if (!exo.isAnswerValid(answer, { answer, ...question.identifiers })) {
-            throw new Error(`exo ${exo.id} has invalid VEA, ids ${JSON.stringify(question.identifiers)}, answer ${question.answer}`);
+            throw new Error(`exo ${exo.id} has invalid VEA, ids ${jsonIds}, answer ${question.answer}`);
         }
         const after = Date.now();
         veaTime = after - before;
@@ -171,7 +172,7 @@ export const questionTest = (exo, question) => {
         if (exo.answerType === "QCM" && !exo.isQCM)
             throw new Error("exo " + exo.id + " has answerType QCM but not isQCM");
         const before = Date.now();
-        console.log("will generate props : ", exo.id, "ids :", question.identifiers);
+        console.log("will generate props : ", exo.id, "ids :", jsonIds);
         const props = exo.getPropositions(4, {
             answer: question.answer,
             ...question.identifiers,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "math-exercises",
   "type": "module",
-  "version": "3.0.126",
+  "version": "3.0.128",
   "description": "Math exercises generator for middle school and high school",
   "main": "lib/index.js",
   "files": [