math-exercises 3.0.134 → 3.0.135

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

@@ -0,0 +1,13 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    uov: NodeIdentifiers;
+    items: Item[];
+};
+type Item = {
+    tex: string;
+    isValid: boolean;
+};
+export declare const functionDecompositionFindPossibleUVs: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=functionDecompositionFindPossibleUVs.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"functionDecompositionFindPossibleUVs.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/composition/functionDecompositionFindPossibleUVs.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAQrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAO7C,KAAK,WAAW,GAAG;IACjB,GAAG,EAAE,eAAe,CAAC;IACrB,KAAK,EAAE,IAAI,EAAE,CAAC;CACf,CAAC;AAEF,KAAK,IAAI,GAAG;IACV,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,OAAO,CAAC;CAClB,CAAC;AAqQF,eAAO,MAAM,oCAAoC,EAAE,QAAQ,CAAC,WAAW,CAqBtE,CAAC"}

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

@@ -0,0 +1,223 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { isEquivalentNodes } from "../../../../math/utils/functions/functionComparison.js";
+import { nodeBySubstitutingVar } from "../../../../math/utils/functions/functionComposition.js";
+import { functionDecompositions } from "../../../../math/utils/functions/functionDecomposition.js";
+import { realize } from "../../../../math/utils/latex/realize.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { probaLawFlip } from "../../../../utils/alea/probaLawFlip.js";
+import { random } from "../../../../utils/alea/random.js";
+import { permute } from "../../../../utils/arrays/permutations.js";
+const getInstruction = (identifiers) => {
+    const { uov } = identifiers;
+    const nodeUOV = NodeConstructor.fromIdentifiers(uov);
+    return `Parmi les propositions, quelles sont les fonctions $u$ et $v$ telles que, pour tout $x$ réel :
+
+$$
+u \\circ v(x)=${nodeUOV.toTex()}
+$$
+
+`;
+};
+const getHint = () => {
+    return `Pour tout $x$ réel on a: 
+  
+$$
+u \\circ v(x) = u(v(x))
+$$
+
+`;
+};
+const getCorrection = (identifiers) => {
+    const { uov } = identifiers;
+    const nodeUOV = NodeConstructor.fromIdentifiers(uov);
+    const decompositions = functionDecompositions(nodeUOV);
+    return `Pour tout réel $x$, voici quelques couples ($u$,$v$) qui conviennent :
+
+${decompositions.map(({ nodeU, nodeV }) => {
+        return `
+
+$$
+u(x) = ${nodeU.toTex()}
+$$
+
+$$
+v(x) = ${nodeV.toTex()}
+$$
+  
+  `;
+    }).join(`
+  
+$\\ $
+  
+`)}`;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const { items } = identifiers;
+    const propositions = [];
+    items.forEach((item) => {
+        if (item.isValid) {
+            addValidProp(propositions, item.tex, "raw");
+        }
+        else {
+            tryToAddWrongProp(propositions, item.tex, "raw");
+        }
+    });
+    return shuffleProps(propositions, n);
+};
+const getFunctionDecompositionFindPossibleUVsQuestion = (_) => {
+    function getRandomDict() {
+        function getRandomNode() {
+            return random([
+                ...[
+                    realize({ a: "I" })(`x+a`),
+                    realize({ a: { custom: () => randint(2, 10).toTree() } })(`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" })(`\\cos(ax)`),
+                ].map((tex) => parseAlgebraic(tex)),
+                //! TODO: simplify({maxSimplificationSteps: 100}) to allow using fracs
+                // frac(randomNodeWithType("I"), "x"),
+                // frac(1, "x"),
+            ]);
+        }
+        let [nodeF1, nodeF2, nodeF3, nodeA, nodeB, nodeU, nodeV, nodeUOV,] = [];
+        do {
+            [nodeF1, nodeF2] = [0, 1].map(() => getRandomNode());
+            nodeF3 = (() => {
+                let outNode;
+                do {
+                    outNode = getRandomNode();
+                } while (outNode.toTex() === nodeF1.toTex() ||
+                    outNode.toTex() === nodeF2.toTex());
+                return outNode;
+            })();
+            [nodeA, nodeB] = [
+                nodeF1,
+                (coinFlip()
+                    ? nodeBySubstitutingVar(nodeF2.simplify(), nodeF3.simplify())
+                    : nodeBySubstitutingVar(nodeF3.simplify(), nodeF2.simplify())).simplify(),
+            ];
+            [nodeU, nodeV] = coinFlip() ? [nodeA, nodeB] : [nodeB, nodeA];
+            nodeUOV = nodeBySubstitutingVar(nodeU.simplify(), nodeV.simplify()).simplify();
+        } while (nodeUOV.toTex().length > 60);
+        const decompositions = functionDecompositions(nodeUOV).filter(({ nodeU, nodeV }) => nodeU.toTex() !== "x" && nodeV.toTex() !== "x");
+        return { decompositions, nodeF1, nodeF2, nodeF3, nodeUOV };
+    }
+    let counter = -1;
+    let isFound = false;
+    let randomDict;
+    while (!isFound && counter < 100) {
+        counter++;
+        randomDict = getRandomDict();
+        if (randomDict.decompositions.length > 0) {
+            isFound = true;
+        }
+    }
+    const { decompositions, nodeF1, nodeF2, nodeF3, nodeUOV } = randomDict;
+    function texForUV(nodeU, nodeV) {
+        return `
+
+$$
+u(x) = ${nodeU.toTex()}
+$$
+
+$$
+v(x) = ${nodeV.toTex()}
+$$
+
+`;
+    }
+    const validItems = decompositions.map(({ nodeU, nodeV }) => {
+        return {
+            tex: texForUV(nodeU, nodeV),
+            isValid: true,
+        };
+    });
+    const checkIsInvalid = (nodeU, nodeV) => {
+        return decompositions.every(({ nodeU: nodeUDec, nodeV: nodeVDec }) => {
+            return !(isEquivalentNodes(nodeU, nodeUDec) && isEquivalentNodes(nodeV, nodeVDec));
+        });
+    };
+    const invalidItems = [
+        //u is v, v is u
+        ...decompositions.map(({ nodeU, nodeV }) => {
+            return {
+                tex: texForUV(nodeV, nodeU),
+                isValid: false,
+            };
+        }),
+        //node mash
+        ...permute([nodeF1, nodeF2, nodeF3])
+            .filter(([node1, node2, node3]) => {
+            return (node1.toTex() !== nodeF1.toTex() &&
+                node2.toTex() !== nodeF2.toTex() &&
+                node3.toTex() !== nodeF3.toTex());
+        })
+            .map(([node1, node2, node3]) => {
+            const nodeU = node1;
+            const nodeV = nodeBySubstitutingVar(node2.simplify(), node3.simplify()).simplify();
+            return { nodeU, nodeV };
+        })
+            .filter(({ nodeU, nodeV }) => {
+            checkIsInvalid(nodeU, nodeV);
+        })
+            .map(({ nodeU, nodeV }) => {
+            return {
+                tex: texForUV(nodeV, nodeU),
+                isValid: false,
+            };
+        }),
+    ];
+    const nbTotal = 4;
+    const nbValidItems = Math.min(validItems.length, probaLawFlip([
+        [1, 0.5],
+        [2, 0.3],
+        [3, 0.15],
+        [4, 0.05],
+    ]));
+    const nbInvalidItems = nbTotal - nbValidItems;
+    const items = [
+        ...validItems.slice(0, nbValidItems),
+        ...invalidItems.slice(0, nbInvalidItems),
+    ];
+    const identifiers = {
+        uov: nodeUOV.toIdentifiers(),
+        items,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const functionDecompositionFindPossibleUVs = {
+    id: "functionDecompositionFindPossibleUVs",
+    label: "Déterminer les fonctions $u$ et $v$ possibles à partir de l'expression de $u \\circ v$",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getFunctionDecompositionFindPossibleUVsQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCM",
+    isQCM: true,
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"functionDecompositionFindUOrV.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/composition/functionDecompositionFindUOrV.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AASrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAgE7C,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,eAAe,EAAE,CAAC;CAC5B,CAAC;AAyOF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,CAqB/D,CAAC"}

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

@@ -0,0 +1,252 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { realize } from "../../../../math/utils/latex/realize.js";
+import { randint } from "../../../../math/utils/random/randint.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, parseLatex } from "../../../../tree/parsers/latexParser.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.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 { isFindU, nodeIds } = identifiers;
+    const [nodeU, nodeV, nodeUOV] = nodeIds.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    if (isFindU) {
+        return `Soient $u$ et $v$ deux fonctions telles que, pour tout $x$ réel :
+  
+$$
+v(x)=${nodeV.toTex()}
+$$
+
+$$
+u \\circ v(x)=${nodeUOV.toTex()}
+$$
+
+Pour tout $x$ réel, donner l'expression de $u(x)$.`;
+    }
+    else {
+        return `Soient $u$ et $v$ deux fonctions telles que, pour tout $x$ réel :
+  
+$$
+u(x)=${nodeU.toTex()}
+$$
+
+$$
+u \\circ v(x)=${nodeUOV.toTex()}
+$$
+
+Pour tout $x$ réel, donner l'expression de $v(x)$.`;
+    }
+};
+const getHint = () => {
+    return `Pour tout $x$ réel on a: 
+  
+$$
+u \\circ v(x) = u(v(x))
+$$
+
+`;
+};
+const getCorrection = (identifiers) => {
+    const { isFindU, nodeIds } = identifiers;
+    const [nodeU, nodeV, nodeUOV] = nodeIds.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    return `Pour tout réel $x$, on a :
+  
+${alignTex([
+        [`u \\circ v(x)`, `=`, `u(v(x))`],
+        [``, `=`, `${nodeUOV.toTex()}`],
+        [
+            ``,
+            `=`,
+            isFindU
+                ? `${nodeU.toTex().replaceAll("x", "v(x)")}`
+                : `u(${nodeV.toTex()})`,
+        ],
+    ])}
+
+On en déduit donc :
+
+$$
+${isFindU ? `u(x) = ${nodeU.toTex()}` : `v(x) = ${nodeV.toTex()}`}
+$$
+
+`;
+};
+const getAnswerNode = (identifiers) => {
+    const { isFindU, nodeIds } = identifiers;
+    const [nodeU, nodeV] = nodeIds.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    return isFindU ? nodeU : nodeV;
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).toTex();
+};
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
+    const nodeAns = parseLatex(ans);
+    const nodeAnswer = getAnswerNode(identifiers);
+    const nodeDiff = substract(nodeAns, nodeAnswer).simplify();
+    return (nodeDiff.evaluate({ x: 1 }) === 0 &&
+        nodeDiff.evaluate({ x: 10 }) === 0 &&
+        nodeDiff.evaluate({ x: 100 }) === 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 getFunctionDecompositionFindUOrVQuestion = (_) => {
+    function getRandomNode() {
+        return random([
+            ...[
+                realize({ a: "I" })(`x+a`),
+                realize({ a: { custom: () => randint(2, 10).toTree() } })(`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" })(`\\cos(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 nodeUOV = nodeBySubstitutingX(nodeU.simplify(), nodeV.simplify().toTex()).simplify();
+    const isFindU = coinFlip();
+    const identifiers = {
+        isFindU,
+        nodeIds: [nodeU, nodeV, nodeUOV].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 functionDecompositionFindUOrV = {
+    id: "functionDecompositionFindUOrV",
+    label: "Déterminer la fonction dont on connaît l'expression de la composée avec une autre fonction",
+    isSingleStep: true,
+    isAnswerValid,
+    generator: (nb, opts) => getDistinctQuestions(() => getFunctionDecompositionFindUOrVQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

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

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

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

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

@@ -1 +1,3 @@
 export * from "./functionComposition.js";
+export * from "./functionDecompositionFindUOrV.js";
+export * from "./functionDecompositionFindPossibleUVs.js";

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

@@ -5,4 +5,5 @@ export * from "./traceVectorMultiple.js";
 export * from "./drawAVectorInGGB.js";
 export * from "./placePointFromPointAndVector.js";
 export * from "./linearVectorCombinationFromGraph.js";
+export * from "./traceVectorCL.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/geometry/vectors/constructions/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,0BAA0B,CAAC;AACzC,cAAc,0BAA0B,CAAC;AACzC,cAAc,uBAAuB,CAAC;AACtC,cAAc,mCAAmC,CAAC;AAClD,cAAc,uCAAuC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/geometry/vectors/constructions/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,0BAA0B,CAAC;AACzC,cAAc,0BAA0B,CAAC;AACzC,cAAc,uBAAuB,CAAC;AACtC,cAAc,mCAAmC,CAAC;AAClD,cAAc,uCAAuC,CAAC;AACtD,cAAc,oBAAoB,CAAC"}

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

@@ -5,3 +5,4 @@ export * from "./traceVectorMultiple.js";
 export * from "./drawAVectorInGGB.js";
 export * from "./placePointFromPointAndVector.js";
 export * from "./linearVectorCombinationFromGraph.js";
+export * from "./traceVectorCL.js";

package/lib/exercises/math/geometry/vectors/constructions/traceVectorCL.d.ts

@@ -0,0 +1,13 @@
+import { Exercise } from "../../../../../exercises/exercise.js";
+import { PointIdentifiers } from "../../../../../math/geometry/point.js";
+type Identifiers = {
+    points: PointIdentifiers[];
+    startPointIndex: number;
+    firstVectorPointsIndexes: number[];
+    secondVectorPointsIndexes: number[];
+    a: number;
+    b: number;
+};
+export declare const traceVectorCL: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=traceVectorCL.d.ts.map

package/lib/exercises/math/geometry/vectors/constructions/traceVectorCL.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"traceVectorCL.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/geometry/vectors/constructions/traceVectorCL.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,6BAA6B,CAAC;AAOrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAMtC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,gBAAgB,EAAE,CAAC;IAC3B,eAAe,EAAE,MAAM,CAAC;IACxB,wBAAwB,EAAE,MAAM,EAAE,CAAC;IACnC,yBAAyB,EAAE,MAAM,EAAE,CAAC;IACpC,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAiQF,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,WAAW,CAe/C,CAAC"}