math-exercises 3.0.125 → 3.0.126

package/lib/exercises/math/functions/basics/coordsOfPointOnCurveFindY.js

@@ -0,0 +1,216 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { Polynomial } from "../../../../math/polynomials/polynomial.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.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 { isOperatorNode, OperatorIds, } from "../../../../tree/nodes/operators/operatorNode.js";
+import { power } from "../../../../tree/nodes/operators/powerNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { random } from "../../../../utils/alea/random.js";
+const nodeByReplacingOperations = (node, replacementDict) => {
+    if (isOperatorNode(node)) {
+        const leftChild = nodeByReplacingOperations(node.leftChild, replacementDict);
+        const rightChild = nodeByReplacingOperations(node.rightChild, replacementDict);
+        const targetOperatorId = replacementDict[+node.id] ?? node.id;
+        switch (+targetOperatorId) {
+            case OperatorIds.add:
+                return add(leftChild, rightChild);
+            case OperatorIds.substract:
+                return substract(leftChild, rightChild);
+            case OperatorIds.multiply:
+                return multiply(leftChild, rightChild);
+            case OperatorIds.divide:
+                return frac(leftChild, rightChild);
+            case OperatorIds.power:
+                return power(leftChild, rightChild);
+            default:
+                return add(leftChild, rightChild);
+        }
+    }
+    else {
+        return node;
+    }
+};
+const nodeBySubstitutingX = (node, strVar) => {
+    return parseAlgebraic(node.toTex().replaceAll("x", `"${strVar}"`));
+};
+const getInstruction = (identifiers) => {
+    const { xValue, questionFunc } = identifiers;
+    const node = NodeConstructor.fromIdentifiers(questionFunc.nodeIds);
+    return `Le point $M$ d'abscisse $${xValue}$ appartient à la courbe d'équation 
+
+$$
+y=${node.toTex()} 
+$$
+
+Quelles sont les coordonnées de $M$ ?`;
+};
+const getAnswer = (identifiers) => {
+    const { xValue, questionFunc } = identifiers;
+    const node = NodeConstructor.fromIdentifiers(questionFunc.nodeIds);
+    const nodeWithXValue = nodeBySubstitutingX(node, `(${xValue})`);
+    const answer = `(${xValue.frenchify()};${nodeWithXValue
+        .simplify({ calculatePowers: true })
+        .toTex()})`;
+    return answer;
+};
+const getHint = (identifiers) => {
+    const { xValue, questionFunc } = identifiers;
+    const node = NodeConstructor.fromIdentifiers(questionFunc.nodeIds);
+    const texWithXM = node.toTex().replaceAll("x", "x_M");
+    const nodeWithXValue = nodeBySubstitutingX(node, `(${xValue})`);
+    return `Les coordonnées $(x_M;y_M)$ de $M$ vérifient:
+
+$$
+${texWithXM} = y_M 
+$$
+
+On doit calculer : 
+  
+$$
+y_M = ${nodeWithXValue.toTex()}  
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { xValue, questionFunc } = identifiers;
+    const node = NodeConstructor.fromIdentifiers(questionFunc.nodeIds);
+    const texWithXM = node.toTex().replaceAll("x", "x_M");
+    const nodeWithXValue = nodeBySubstitutingX(node, `(${xValue})`);
+    const answer = getAnswer(identifiers);
+    return `Les coordonnées $(x_M;y_M)$ de $M$ vérifient:
+
+$$
+${texWithXM} = y_M 
+$$
+  
+On calcule : 
+  
+$$
+y_M = ${nodeWithXValue.toTex()} 
+$$
+
+$$
+y_M = ${answer.slice(1, -1).split(";")[1]}  
+$$
+
+Les coordonnées de $M$ sont donc $${answer}$.`;
+};
+const getPropositions = (n, { answer, questionFunc, xValue }) => {
+    const node = NodeConstructor.fromIdentifiers(questionFunc.nodeIds);
+    const propositions = [];
+    addValidProp(propositions, answer);
+    //power becomes multiply
+    tryToAddWrongProp(propositions, `(${xValue.frenchify()};${nodeBySubstitutingX(nodeByReplacingOperations(node, {
+        [OperatorIds.power]: OperatorIds.multiply,
+    }), `(${xValue})`)
+        .simplify({ calculatePowers: true })
+        .toTex()})`);
+    //sign mistake
+    tryToAddWrongProp(propositions, `(${xValue.frenchify()};${nodeBySubstitutingX(nodeByReplacingOperations(node, {
+        [OperatorIds.add]: OperatorIds.substract,
+        [OperatorIds.substract]: coinFlip()
+            ? OperatorIds.add
+            : OperatorIds.substract,
+    }), `(${xValue})`)
+        .simplify({ calculatePowers: true })
+        .toTex()})`);
+    //multiply becomes add
+    tryToAddWrongProp(propositions, `(${xValue.frenchify()};${nodeBySubstitutingX(nodeByReplacingOperations(node, {
+        [OperatorIds.multiply]: OperatorIds.add,
+    }), `(${xValue})`)
+        .simplify({ calculatePowers: true })
+        .toTex()})`);
+    //let's try 0
+    tryToAddWrongProp(propositions, `(${xValue.frenchify()};0)`);
+    //(x,y) becomes (y,x)
+    if (propositions.length < n) {
+        const [x, y] = answer.slice(1, -1).split(";");
+        tryToAddWrongProp(propositions, `(${y};${x})`);
+    }
+    while (propositions.length < n) {
+        tryToAddWrongProp(propositions, `(${xValue.frenchify()};${randint(-50, 50, [0])})`);
+        tryToAddWrongProp(propositions, `(${randint(-50, 50, [0])};${xValue.frenchify()})`);
+    }
+    return shuffleProps(propositions, n);
+};
+const getCoordsOfPointOnAffineFindYQuestion = () => {
+    const xValue = randint(-9, 10);
+    const questionFunc = random([
+        {
+            type: "...x^2",
+            nodeIds: new Polynomial([
+                randint(-9, 10),
+                randint(-5, 6),
+                randint(-2, 3, [0]),
+            ])
+                .toTree()
+                .toIdentifiers(),
+        },
+        {
+            type: "...x^3",
+            nodeIds: new Polynomial([
+                randint(-9, 10),
+                randint(-5, 6),
+                0,
+                randint(-1, 2, [0]),
+            ])
+                .toTree()
+                .toIdentifiers(),
+        },
+        {
+            type: "(x-...)(x-...)",
+            nodeIds: multiply(substract("x", randint(-3, 4, [xValue])), substract("x", randint(-3, 4, [0, xValue]))).toIdentifiers(),
+        },
+        {
+            type: "(x+...)(x-...)",
+            nodeIds: multiply(add("x", randint(-3, 4, [-xValue])), substract("x", randint(-3, 4, [0, xValue]))).toIdentifiers(),
+        },
+        {
+            type: "(x+...)(x+...)",
+            nodeIds: multiply(add("x", randint(-3, 4, [-xValue])), add("x", randint(-3, 4, [0, -xValue]))).toIdentifiers(),
+        },
+        {
+            type: "a/(x+...)",
+            nodeIds: frac(randint(-3, 4, [0]), add("x", randint(-3, 4, [0, -xValue]))).toIdentifiers(),
+        },
+        {
+            type: "(x+...)/(x+...)",
+            nodeIds: frac(add("x", randint(-3, 4)), add("x", randint(-3, 4, [0, -xValue]))).toIdentifiers(),
+        },
+    ]);
+    const identifiers = {
+        questionFunc,
+        xValue,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        instruction: getInstruction(identifiers),
+        answer: getAnswer(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const coordsOfPointOnCurveFindY = {
+    id: "coordsOfPointOnCurveFindY",
+    getPropositions,
+    label: "Déterminer les coordonnées d'un point appartenant à une courbe et dont on connaît l'abscisse",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getCoordsOfPointOnAffineFindYQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

package/lib/exercises/math/functions/basics/index.d.ts

@@ -15,4 +15,5 @@ export * from "./valueTableFromGraph.js";
 export * from "./isPointOnFunction.js";
 export * from "./countFunctionZeroes.js";
 export * from "./findZeroesProductQuotient.js";
+export * from "./coordsOfPointOnCurveFindY.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/functions/basics/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/basics/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,mCAAmC,CAAC;AAClD,cAAc,sBAAsB,CAAC;AACrC,cAAc,wBAAwB,CAAC;AACvC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,kCAAkC,CAAC;AACjD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,qBAAqB,CAAC;AACpC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,0BAA0B,CAAC;AACzC,cAAc,wBAAwB,CAAC;AACvC,cAAc,0BAA0B,CAAC;AACzC,cAAc,gCAAgC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/basics/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,mCAAmC,CAAC;AAClD,cAAc,sBAAsB,CAAC;AACrC,cAAc,wBAAwB,CAAC;AACvC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,kCAAkC,CAAC;AACjD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,qBAAqB,CAAC;AACpC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,0BAA0B,CAAC;AACzC,cAAc,wBAAwB,CAAC;AACvC,cAAc,0BAA0B,CAAC;AACzC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,gCAAgC,CAAC"}

package/lib/exercises/math/functions/basics/index.js

@@ -15,3 +15,4 @@ export * from "./valueTableFromGraph.js";
 export * from "./isPointOnFunction.js";
 export * from "./countFunctionZeroes.js";
 export * from "./findZeroesProductQuotient.js";
+export * from "./coordsOfPointOnCurveFindY.js";

package/lib/exercises/math/functions/composition/functionComposition.d.ts

@@ -0,0 +1,8 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    nodeIds: NodeIdentifiers[];
+};
+export declare const functionComposition: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=functionComposition.d.ts.map

package/lib/exercises/math/functions/composition/functionComposition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"functionComposition.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/composition/functionComposition.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAQrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AA+D7C,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,eAAe,EAAE,CAAC;CAC5B,CAAC;AA+NF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAiBrD,CAAC"}

package/lib/exercises/math/functions/composition/functionComposition.js

@@ -0,0 +1,238 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { realize } from "../../../../math/utils/latex/realize.js";
+import { isFunctionNode, } from "../../../../tree/nodes/functions/functionNode.js";
+import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
+// import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { isOperatorNode } from "../../../../tree/nodes/operators/operatorNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { random } from "../../../../utils/alea/random.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const nodeBySubstitutingX = (node, strVar) => {
+    return parseAlgebraic(node.toTex({ forceParenthesis: true }).replaceAll("x", `("${strVar}")`));
+};
+const functionNameForFunctionId = (functionId) => {
+    return [
+        "opposite",
+        "sqrt",
+        "cos",
+        "sin",
+        "tan",
+        "log",
+        "log10",
+        "exp",
+        "abs",
+        "arcsin",
+        "arccos",
+        "arctan",
+    ][functionId];
+};
+const extractElementaryFunctionNamesDict = (nodes, functionNamesDictIn = {}) => {
+    let functionNamesDict = functionNamesDictIn;
+    nodes.forEach((node) => {
+        if (isFunctionNode(node)) {
+            const functionId = node.id;
+            const functionName = functionNameForFunctionId(functionId);
+            if (!(functionName in functionNamesDict)) {
+                functionNamesDict[functionName] = functionName;
+            }
+            functionNamesDict = Object.assign(functionNamesDict, extractElementaryFunctionNamesDict([node.child], functionNamesDict));
+        }
+        else if (isOperatorNode(node)) {
+            functionNamesDict = Object.assign(functionNamesDict, extractElementaryFunctionNamesDict([node.leftChild, node.rightChild], functionNamesDict));
+        }
+    });
+    return functionNamesDict;
+};
+const getInstruction = (identifiers) => {
+    const { nodeIds } = identifiers;
+    const [nodeU, nodeV] = nodeIds.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    return `Soient $u$ et $v$ deux fonctions telles que, pour tout $x$ réel :
+  
+$$
+u(x)=${nodeU.toTex()}
+$$
+
+$$
+v(x)=${nodeV.toTex()}
+$$
+
+Pour tout $x$ réel, donner l'expression de $u \\circ v(x)$.`;
+};
+const getHint = () => {
+    return `Pour tout $x$ réel on a: 
+  
+$$
+u \\circ v(x) = u(v(x))
+$$
+
+`;
+};
+const getCorrection = (identifiers) => {
+    const { nodeIds } = identifiers;
+    const [nodeU, nodeV] = nodeIds.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const arrayRHS = [
+        ...new Set([
+            ...(isOperatorNode(nodeV)
+                ? [`${nodeU.toTex().replaceAll("x", `(${nodeV.toTex()})`)}`]
+                : []),
+            getAnswer(identifiers),
+        ]).values(),
+    ];
+    return `Pour tout réel $x$, on a :
+  
+${alignTex([
+        [`u \\circ v(x)`, `=`, `u(v(x))`],
+        [``, `=`, `${nodeU.toTex().replaceAll("x", "v(x)")}`],
+        ...arrayRHS.map((rhs) => [``, `=`, rhs]),
+    ])}`;
+};
+const getAnswer = (identifiers) => {
+    const { nodeIds } = identifiers;
+    const [nodeU, nodeV] = nodeIds.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    return `${nodeBySubstitutingX(nodeU.simplify(), nodeV.simplify().toTex())
+        .simplify()
+        .toTex()}`;
+};
+const isAnswerValid = (ans, { answer }) => {
+    const nodeAns = parseAlgebraic(ans);
+    const nodeAnswer = parseAlgebraic(answer);
+    // return (
+    //   substract(nodeAns.simplify(), nodeAnswer.simplify())
+    //     .simplify()
+    //     .evaluate() === 0
+    // );
+    // return (
+    //   nodeAns.simplify().toMathString() === nodeAnswer.simplify().toMathString()
+    // );
+    //
+    //  Une façon de savoir que expr1(x) et expr2(x) sont équivalentes:
+    //  x|->expr1(expr2(x)) doit être la même fonction que x|->expr2(expr1(x))
+    const nodeAnsOfAnswer = nodeBySubstitutingX(nodeAns.simplify(), nodeAnswer.simplify().toTex()).simplify();
+    const nodeAnswerOfAns = nodeBySubstitutingX(nodeAnswer.simplify(), nodeAns.simplify().toTex()).simplify();
+    return [0, 1, 1000].every((x) => {
+        return (substract(nodeAnsOfAnswer.evaluate({ x }), nodeAnswerOfAns.evaluate({ x })).evaluate() === 0);
+    });
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const { nodeIds } = identifiers;
+    const [nodeU, nodeV] = nodeIds.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const wrongTexs = [
+        //mauvais ordre
+        `${nodeBySubstitutingX(nodeV, nodeU.toTex()).toTex({
+            forceParenthesis: true,
+        })}`,
+        `${nodeBySubstitutingX(nodeV, nodeU.toTex()).simplify().toTex()}`,
+        //multiplication
+        `${multiply(nodeU, nodeV).toTex({
+            forceParenthesis: true,
+        })}`,
+        //\\circ is 0
+        `${multiply(nodeU, multiply(0, nodeV)).toTex({
+            forceTimesSign: true,
+            forceParenthesis: true,
+        })}`,
+        //substitution littéraire
+        `${nodeU
+            .toTex({ forceParenthesis: true })
+            .replaceAll("x", `${nodeV.toTex()}`)}`,
+        `${nodeU
+            .toTex({ forceParenthesis: true })
+            .replaceAll("x", `${nodeV.toTex()}`)}`,
+    ];
+    wrongTexs.forEach((wrongTex) => {
+        tryToAddWrongProp(propositions, wrongTex);
+    });
+    if (propositions.length < n) {
+        [
+            `${nodeBySubstitutingX(nodeU, nodeU.toTex()).toTex({
+                forceParenthesis: true,
+            })}`,
+            `${nodeBySubstitutingX(nodeU, nodeU.toTex()).simplify().toTex()}`,
+            `${nodeBySubstitutingX(nodeV, nodeV.toTex()).toTex({
+                forceParenthesis: true,
+            })}`,
+            `${nodeBySubstitutingX(nodeV, nodeV.toTex()).simplify().toTex()}`,
+        ].forEach((wrongTex) => {
+            tryToAddWrongProp(propositions, wrongTex);
+        });
+    }
+    return shuffleProps(propositions, n);
+};
+const getKeys = (identifiers) => {
+    const { nodeIds } = identifiers;
+    const nodes = nodeIds.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const functionNamesDict = extractElementaryFunctionNamesDict(nodes);
+    return [
+        "x",
+        ...Object.values(functionNamesDict).map((functionName) => {
+            return {
+                id: "custom",
+                label: functionName,
+                labelType: "tex",
+                mathfieldInstructions: {
+                    method: "write",
+                    content: functionName,
+                },
+            };
+        }),
+    ];
+};
+const getFunctionCompositionQuestion = (_) => {
+    function getRandomNode() {
+        return random([
+            ...[
+                `x`,
+                realize({ a: "I" })(`x+a`),
+                realize({ a: "I" })(`ax`),
+                realize({ a: "I", b: "I" })(`ax+b`),
+                realize({ a: "I", b: "I" })(`(ax+b)^2`),
+                realize({ a: "RI", b: "RI" })(`(x+a)(x+b)`),
+                `\\sin(x)`,
+                realize({ a: "I" })(`\\sin(ax)`),
+                `\\cos(x)`,
+                realize({ a: "I" })(`\\sin(ax)`),
+            ].map((tex) => parseAlgebraic(tex)),
+            //! TODO: simplify({maxSimplificationSteps: 100}) to allow using fracs
+            // frac(randomNodeWithType("I"), "x"),
+            // frac(1, "x"),
+        ]);
+    }
+    const [nodeU, nodeV] = [0, 1].map(() => getRandomNode());
+    const identifiers = {
+        nodeIds: [nodeU, nodeV].map((node) => node.toIdentifiers()),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const functionComposition = {
+    id: "functionComposition",
+    label: "Déterminer l'expression d'une fonction composée",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getFunctionCompositionQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/functions/composition/index.d.ts

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

package/lib/exercises/math/functions/composition/index.d.ts.map

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

package/lib/exercises/math/functions/composition/index.js

@@ -0,0 +1 @@
+export * from "./functionComposition.js";

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

@@ -14,4 +14,5 @@ export * from "./sign/index.js";
 export * from "./variations/index.js";
 export * from "./sqrt/index.js";
 export * from "./inverse/index.js";
+export * from "./composition/index.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/functions/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC;AAChC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,oBAAoB,CAAC;AACnC,cAAc,wBAAwB,CAAC;AACvC,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,yBAAyB,CAAC;AACxC,cAAc,iBAAiB,CAAC;AAChC,cAAc,uBAAuB,CAAC;AACtC,cAAc,iBAAiB,CAAC;AAChC,cAAc,oBAAoB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/functions/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC;AAChC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,oBAAoB,CAAC;AACnC,cAAc,wBAAwB,CAAC;AACvC,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,yBAAyB,CAAC;AACxC,cAAc,iBAAiB,CAAC;AAChC,cAAc,uBAAuB,CAAC;AACtC,cAAc,iBAAiB,CAAC;AAChC,cAAc,oBAAoB,CAAC;AACnC,cAAc,wBAAwB,CAAC"}

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

@@ -14,3 +14,4 @@ export * from "./sign/index.js";
 export * from "./variations/index.js";
 export * from "./sqrt/index.js";
 export * from "./inverse/index.js";
+export * from "./composition/index.js";

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

@@ -0,0 +1,23 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { LineIdentifiers } from "../../../../math/geometry/line.js";
+import { PointIdentifiers } from "../../../../math/geometry/point.js";
+type IntersectionIds = {
+    center: PointIdentifiers;
+    lineH: LineIdentifiers;
+    lineV: LineIdentifiers;
+};
+type Identifiers = {
+    isParallel: boolean;
+    angleType: "alternes-internes" | "correspondants" | "alternes-externes" | "autres";
+    arrIntersectionIds: IntersectionIds[];
+    arrAngleIndex: number[];
+    arrAngleForLabel: number[] | undefined;
+};
+type Options = {
+    angleTypes: ("alternes-internes" | "correspondants" | "alternes-externes" | "autres")[];
+    isFakeDisplay: boolean;
+    nbDigits: 0 | 1 | 2;
+};
+export declare const anglesUsingIsParallel: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=anglesUsingIsParallel.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"anglesUsingIsParallel.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/angles/anglesUsingIsParallel.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAmBT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAGL,eAAe,EAChB,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAuItC,KAAK,eAAe,GAAG;IACrB,MAAM,EAAE,gBAAgB,CAAC;IACzB,KAAK,EAAE,eAAe,CAAC;IACvB,KAAK,EAAE,eAAe,CAAC;CACxB,CAAC;AA6HF,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,OAAO,CAAC;IACpB,SAAS,EACL,mBAAmB,GACnB,gBAAgB,GAChB,mBAAmB,GACnB,QAAQ,CAAC;IAGb,kBAAkB,EAAE,eAAe,EAAE,CAAC;IACtC,aAAa,EAAE,MAAM,EAAE,CAAC;IAGxB,gBAAgB,EAAE,MAAM,EAAE,GAAG,SAAS,CAAC;CACxC,CAAC;AAwMF,KAAK,OAAO,GAAG;IACb,UAAU,EAAE,CACR,mBAAmB,GACnB,gBAAgB,GAChB,mBAAmB,GACnB,QAAQ,CACX,EAAE,CAAC;IACJ,aAAa,EAAE,OAAO,CAAC;IACvB,QAAQ,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;CACrB,CAAC;AA2NF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAkBhE,CAAC"}