math-exercises 3.0.200 → 3.0.201

package/lib/exercises/math/spaceGeometry/basis/spaceVectorLinearCombinationFromCoords.js

@@ -0,0 +1,233 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, propWhile, GeneratorOptionTarget, GeneratorOptionType, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { SpacePoint, SpacePointConstructor, } from "../../../../math/geometry/spacePoint.js";
+import { SpaceVector } from "../../../../math/geometry/spaceVector.js";
+import { nodeBySubstitutingVar } from "../../../../math/utils/functions/functionComposition.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { opposite } from "../../../../tree/nodes/functions/oppositeNode.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 { VariableNode } from "../../../../tree/nodes/variables/variableNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { NodeComparator } from "../../../../tree/utilities/nodeComparator.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { randomMany } from "../../../../utils/alea/random.js";
+import { zip } from "../../../../utils/arrays/arrayZip.js";
+import { permute } from "../../../../utils/arrays/permutations.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const getHydrated = (identifiers) => {
+    const { spacePointIdsVecs, nodeIdsLinearCombination } = identifiers;
+    const [vecU, vecV] = zip(["u", "v"], spacePointIdsVecs).map(([name, pointIds]) => {
+        const spacePoint = SpacePointConstructor.fromIdentifiers(pointIds);
+        return new SpaceVector(name, spacePoint.x, spacePoint.y, spacePoint.z);
+    });
+    const nodeLinearCombination = NodeConstructor.fromIdentifiers(nodeIdsLinearCombination);
+    const vecLinearCombination = (() => {
+        const [nodeX, nodeY, nodeZ] = ["x", "y", "z"].map((axis) => nodeBySubstitutingVar(nodeBySubstitutingVar(nodeLinearCombination, vecU[axis], new VariableNode(vecU.toTex())), vecV[axis], new VariableNode(vecV.toTex())));
+        return new SpaceVector("w", nodeX, nodeY, nodeZ);
+    })();
+    const vecLinearCombinationSimplified = new SpaceVector(vecLinearCombination.name, vecLinearCombination.x.simplify(), vecLinearCombination.y.simplify(), vecLinearCombination.z.simplify());
+    return {
+        vecU,
+        vecV,
+        nodeLinearCombination,
+        vecLinearCombination,
+        vecLinearCombinationSimplified,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { vecU, vecV, nodeLinearCombination } = getHydrated(identifiers);
+    return `Soient deux vecteurs $\\overrightarrow{u}$ et $\\overrightarrow{v}$ tels que : 
+
+$$
+\\overrightarrow{u} = ${vecU.toCoordsTex()}
+$$
+
+$$
+\\overrightarrow{v} = ${vecV.toCoordsTex()}
+$$
+  
+Déterminer les coordonnées (en ligne) du vecteur :
+
+$$
+${nodeLinearCombination.toTex()}
+$$
+
+`;
+};
+const getAnswer = (identifiers) => {
+    const { vecLinearCombinationSimplified } = getHydrated(identifiers);
+    return vecLinearCombinationSimplified.toInlineCoordsTex();
+};
+const getHint = () => {
+    const nodeVarK = new VariableNode("k");
+    return `Soit $k$ un nombre réel et $\\overrightarrow{u}$ le vecteur de coordonnées : 
+  
+$$
+\\overrightarrow{u} = ${new SpaceVector("hintVector1", new VariableNode(`u_{x}`), new VariableNode(`u_{y}`), new VariableNode(`u_{z}`)).toCoordsTex()}
+$$
+
+alors
+
+$$
+k\\overrightarrow{u} = ${new SpaceVector("hintVector2", multiply(nodeVarK, new VariableNode(`u_{x}`)), multiply(nodeVarK, new VariableNode(`u_{y}`)), multiply(nodeVarK, new VariableNode(`u_{z}`))).toCoordsTex()}
+$$
+
+`;
+};
+const getCorrection = (identifiers) => {
+    const { vecU, vecV, nodeLinearCombination, vecLinearCombination, vecLinearCombinationSimplified, } = getHydrated(identifiers);
+    const texLinearCombinationPretty = `\\begin{pmatrix}${vecLinearCombination.x.toTex({ forceTimesSign: true, forceNoSimplification: true })} \\\\ ${vecLinearCombination.y.toTex({
+        forceTimesSign: true,
+        forceNoSimplification: true,
+    })} \\\\ ${vecLinearCombination.z.toTex({
+        forceTimesSign: true,
+        forceNoSimplification: true,
+    })} \\end{pmatrix}`;
+    return `${alignTex([
+        [
+            `${nodeLinearCombination.toTex()}`,
+            "=",
+            `${nodeBySubstitutingVar(nodeBySubstitutingVar(nodeLinearCombination, new VariableNode(vecU.toCoordsTex()), //forgive me father
+            new VariableNode(vecU.toTex())), new VariableNode(vecV.toCoordsTex()), //forgive me father
+            new VariableNode(vecV.toTex())).toTex()}`,
+        ],
+        ["", "=", texLinearCombinationPretty],
+        ["", "=", vecLinearCombinationSimplified.toCoordsTex()],
+    ])}
+
+`;
+};
+const getPropositions = (n, { answer, ...identifiers }, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const isAllowRationalFactors = opts.isAllowRationalFactors;
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const { vecLinearCombinationSimplified } = getHydrated(identifiers);
+    const arrNodeAnswer = [
+        vecLinearCombinationSimplified.x,
+        vecLinearCombinationSimplified.y,
+        vecLinearCombinationSimplified.z,
+    ];
+    permute(arrNodeAnswer).forEach((arrNodeAnswerWrong) => {
+        const [nodeX, nodeY, nodeZ] = arrNodeAnswerWrong;
+        const spacePointWrong = new SpacePoint("MWrong", nodeX, nodeY, nodeZ);
+        tryToAddWrongProp(propositions, spacePointWrong.toCoords());
+    });
+    propWhile(propositions, n, () => {
+        const identifiersWrong = createRandomIdentifiers(isAllowRationalFactors);
+        tryToAddWrongProp(propositions, getAnswer(identifiersWrong));
+    });
+    return shuffleProps(propositions, n);
+};
+const getKeys = () => {
+    return ["semicolon"];
+};
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
+    const { vecLinearCombinationSimplified } = getHydrated(identifiers);
+    const arrNodeAnswer = [
+        vecLinearCombinationSimplified.x,
+        vecLinearCombinationSimplified.y,
+        vecLinearCombinationSimplified.z,
+    ];
+    function matchGroups(regex, input) {
+        const match = regex.exec(input);
+        return match?.groups || undefined;
+    }
+    try {
+        const arrNodeAns = (() => {
+            const arrKey = [...Array(3).keys()]
+                .map((i) => i + 1)
+                .map((v) => `str${v}`);
+            //TODO: input is column of coords
+            // const strRegex = `^\\\\begin\\{pmatrix\\}\\(${arrKey
+            //   .map((strKey) => `(?<${strKey}>.*(?!\\w$))`)
+            //   .join("\\\\\\w")}\\\\end\\{pmatrix\\}\\)$`;
+            const strRegex = `^\\\\left\\(${arrKey
+                .map((strKey) => `(?<${strKey}>.*(?!;$))`)
+                .join(";")}\\\\right\\)$`;
+            const regex = new RegExp(strRegex);
+            const ansParts = matchGroups(regex, ans);
+            if (ansParts === undefined) {
+                throw new Error("Parsing error: ans is not a tuple");
+            }
+            const arrNode = Object.entries(ansParts).map(([_key, str]) => parseAlgebraic(str));
+            return arrNode;
+        })();
+        return zip(arrNodeAns, arrNodeAnswer).every(([nodeAns, nodeAnswer]) => NodeComparator.isEqualViaSub(nodeAns, nodeAnswer));
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const createRandomIdentifiers = (isAllowRationalFactors) => {
+    const [nodeFactor1, nodeFactor2] = randomMany([
+        (-2).toTree(),
+        (-1).toTree(),
+        (2).toTree(),
+        (3).toTree(),
+        ...(isAllowRationalFactors ? [opposite(frac(1, 2)), frac(1, 2)] : []),
+    ], 2);
+    const funcRand1 = () => randint(-3, 4, coinFlip() ? [0] : []).toTree();
+    const funcRand2 = () => randint(-6, 7, coinFlip() ? [0] : []).toTree();
+    const funcRand3 = () => randint(-9, 10, coinFlip() ? [0] : []).toTree();
+    const [vecU, vecV] = zip(["u", "v"], [
+        [funcRand1, funcRand2, funcRand3],
+        [funcRand3, funcRand2, funcRand1],
+    ]).map(([name, [funcRandX, funcRandY, funcRandZ]]) => new SpaceVector(name, funcRandX(), funcRandY(), funcRandZ()));
+    const nodeLinearCombination = add(multiply(nodeFactor1, new VariableNode(vecU.toTex())), multiply(nodeFactor2, new VariableNode(vecV.toTex())));
+    const identifiers = {
+        spacePointIdsVecs: [vecU, vecV].map((vec) => new SpacePoint(vec.name, vec.x, vec.y, vec.z).toIdentifiers()),
+        nodeIdsLinearCombination: nodeLinearCombination.toIdentifiers(),
+    };
+    return identifiers;
+};
+const getSpaceVectorLinearCombinationFromCoordsQuestion = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const isAllowRationalFactors = opts.isAllowRationalFactors;
+    const identifiers = createRandomIdentifiers(isAllowRationalFactors);
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers, _opts) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+const optsDefault = {
+    isAllowRationalFactors: false,
+};
+const options = [
+    {
+        id: "isAllowRationalFactors",
+        label: "Permettre des facteurs rationnels",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.checkbox,
+        defaultValue: optsDefault.isAllowRationalFactors,
+    },
+];
+export const spaceVectorLinearCombinationFromCoords = {
+    id: "spaceVectorLinearCombinationFromCoords",
+    label: "Les coordonnées de deux vecteurs $\\overrightarrow{u}$ et $\\overrightarrow{v}$ étant données, calculer les coordonnes de $a\\overrightarrow{u}+b\\overrightarrow{v}$",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getSpaceVectorLinearCombinationFromCoordsQuestion(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/spaceGeometry/collinearity/checkAlignedSpacePointsFromCoords.d.ts

@@ -0,0 +1,11 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { SpacePointIdentifiers } from "../../../../math/geometry/spacePoint.js";
+type Identifiers = {
+    spacePointIds: SpacePointIdentifiers[];
+};
+type Options = {
+    isAllowRationalCoeffs: boolean;
+};
+export declare const checkSpacePointCollinearity: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=checkAlignedSpacePointsFromCoords.d.ts.map

package/lib/exercises/math/spaceGeometry/collinearity/checkAlignedSpacePointsFromCoords.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkAlignedSpacePointsFromCoords.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/collinearity/checkAlignedSpacePointsFromCoords.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAGL,qBAAqB,EACtB,MAAM,mCAAmC,CAAC;AAiD3C,KAAK,WAAW,GAAG;IACjB,aAAa,EAAE,qBAAqB,EAAE,CAAC;CACxC,CAAC;AAuNF,KAAK,OAAO,GAAG;IACb,qBAAqB,EAAE,OAAO,CAAC;CAChC,CAAC;AAcF,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAmBtE,CAAC"}

package/lib/exercises/math/spaceGeometry/collinearity/checkAlignedSpacePointsFromCoords.js

@@ -0,0 +1,192 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, GeneratorOptionTarget, GeneratorOptionType, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { SpacePoint, SpacePointConstructor, } from "../../../../math/geometry/spacePoint.js";
+import { SpaceVector } from "../../../../math/geometry/spaceVector.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { opposite } from "../../../../tree/nodes/functions/oppositeNode.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 { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { probaLawFlip } from "../../../../utils/alea/probaLawFlip.js";
+import { random, randomMany } from "../../../../utils/alea/random.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { zip } from "../../../../utils/arrays/arrayZip.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const spaceVectorFromPointsRaw = (spacePointStart, spacePointEnd) => {
+    return new SpaceVector(`${spacePointStart.name}${spacePointEnd.name}`, substract(spacePointEnd.x, spacePointStart.x), substract(spacePointEnd.y, spacePointStart.y), substract(spacePointEnd.z, spacePointStart.z));
+};
+const vectorialProductRaw = (v1, v2) => {
+    return new SpaceVector(`vectorialProductRaw`, substract(multiply(v1.y, v2.z), multiply(v1.z, v2.y)), substract(multiply(v1.z, v2.x), multiply(v1.x, v2.z)), substract(multiply(v1.x, v2.y), multiply(v1.y, v2.x)));
+};
+const simplifySpaceVector = (vec, opts = {}) => {
+    return new SpaceVector(vec.name, vec.x.simplify(opts), vec.y.simplify(opts), vec.z.simplify(opts));
+};
+const getHydrated = (identifiers) => {
+    const { spacePointIds } = identifiers;
+    const [A, B, C] = spacePointIds.map((pointIds) => SpacePointConstructor.fromIdentifiers(pointIds));
+    const vecAB = spaceVectorFromPointsRaw(A, B);
+    const vecABSimplified = simplifySpaceVector(vecAB);
+    const vecAC = spaceVectorFromPointsRaw(A, C);
+    const vecACSimplified = simplifySpaceVector(vecAC);
+    const vecABVProdAC = vectorialProductRaw(vecABSimplified, vecACSimplified);
+    const vecABVProdACSimplified = simplifySpaceVector(vecABVProdAC);
+    const isCollinear = vecABVProdACSimplified.equals(new SpaceVector("0", (0).toTree(), (0).toTree(), (0).toTree()));
+    return {
+        A,
+        B,
+        C,
+        vecAB,
+        vecABSimplified,
+        vecAC,
+        vecACSimplified,
+        vecABVProdAC,
+        vecABVProdACSimplified,
+        isCollinear,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { A, B, C } = getHydrated(identifiers);
+    return `Soient trois points $A$, $B$ et $C$ tels que : 
+
+${alignTex([A, B, C].map((spacePoint) => [spacePoint.name, "=", spacePoint.toCoords()]))}
+  
+Les points $A$, $B$ et $C$ sont-ils alignés ?`;
+};
+const getAnswer = (identifiers) => {
+    const { isCollinear } = getHydrated(identifiers);
+    return isCollinear ? "Oui" : "Non";
+};
+const getHint = () => {
+    return `$A$, $B$ et $C$ sont alignés si et seulement si $\\overrightarrow{AB}$ et $\\overrightarrow{AC}$ sont colinéaires.
+Pour montrer que $\\overrightarrow{AB}$ et $\\overrightarrow{AC}$ sont colinéaires, on peut, entre autres : 
+- montrer par le calcul que $\\overrightarrow{AB} \\wedge \\overrightarrow{AC} = \\overrightarrow{0}$
+- trouver un réel $k$ tel que $\\overrightarrow{AB} = k \\overrightarrow{AC}$`;
+};
+const getCorrection = (identifiers) => {
+    const { vecAB, vecAC, vecABSimplified, vecACSimplified, vecABVProdAC, vecABVProdACSimplified, isCollinear, } = getHydrated(identifiers);
+    return `On calcule : 
+
+${alignTex([
+        [vecAB, vecABSimplified],
+        [vecAC, vecACSimplified],
+    ].map(([vec, vecSimplified]) => [
+        vec.toTex(),
+        "=",
+        vec.toCoordsTex(),
+        "=",
+        vecSimplified.toCoordsTex(),
+    ]))}
+
+${alignTex([
+        [
+            "\\overrightarrow{AB} \\wedge \\overrightarrow{AC}",
+            "=",
+            vecABVProdAC.toCoordsTex(),
+        ],
+        ["", "=", vecABVProdACSimplified.toCoordsTex()],
+    ])}
+
+${isCollinear
+        ? "Les points $A$,$B$ et $C$ sont donc alignés."
+        : "Les points $A$,$B$ et $C$ ne sont donc pas alignés."}`;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer, "raw");
+    tryToAddWrongProp(propositions, "Oui", "raw");
+    tryToAddWrongProp(propositions, "Non", "raw");
+    tryToAddWrongProp(propositions, "On ne peut pas savoir", "raw");
+    return shuffleProps(propositions, n);
+};
+const createRandomIdentifiers = (isAllowRationalCoeffs) => {
+    const funcRandCoeff = () => isAllowRationalCoeffs
+        ? frac(randint(-7, 8), probaLawFlip([
+            [1, 0.6],
+            [2, 0.3],
+            [3, 0.1],
+        ])).simplify()
+        : randint(-7, 8).toTree();
+    const A = new SpacePoint("A", funcRandCoeff(), funcRandCoeff(), funcRandCoeff());
+    const [nodeFactor1, nodeFactor2] = randomMany([
+        (-2).toTree(),
+        (-1).toTree(),
+        (2).toTree(),
+        (3).toTree(),
+        ...(isAllowRationalCoeffs ? [opposite(frac(1, 2)), frac(1, 2)] : []),
+    ], 2);
+    const funcRand1 = () => randint(-3, 4, coinFlip() ? [0] : []).toTree();
+    const funcRand2 = () => randint(-6, 7, coinFlip() ? [0] : []).toTree();
+    const funcRand3 = () => randint(-9, 10, coinFlip() ? [0] : []).toTree();
+    const [vecU] = zip(["u"], [shuffle([funcRand1, funcRand2, funcRand3])]).map(([name, [funcRandX, funcRandY, funcRandZ]]) => new SpaceVector(name, funcRandX(), funcRandY(), funcRandZ()));
+    const [P1, P2] = zip([nodeFactor1, nodeFactor2], [vecU, vecU]).map(([nodeFactor, vec]) => vec.times(nodeFactor).getEndPoint(A));
+    const funcOffset1 = () => randint(-3, 4, coinFlip() ? [0] : []).toTree();
+    const funcOffset2 = () => randint(-6, 7, coinFlip() ? [0] : []).toTree();
+    const funcOffset3 = () => randint(-9, 10, coinFlip() ? [0] : []).toTree();
+    const funcOffset = random([funcOffset1, funcOffset2, funcOffset3]);
+    const isCollinear = coinFlip();
+    const [B, C] = zip(["B", "C"], zip(shuffle([P1, P2]), shuffle([!isCollinear, false]))).map(([name, [spacePointSrc, isBroken]]) => {
+        const [funcOffsetX, funcOffsetY, funcOffsetZ] = isBroken
+            ? shuffle([
+                (node) => add(node, funcOffset()).simplify(),
+                (node) => node,
+                (node) => node,
+            ])
+            : [
+                (node) => node,
+                (node) => node,
+                (node) => node,
+            ];
+        return new SpacePoint(name, funcOffsetX(spacePointSrc.x), funcOffsetY(spacePointSrc.y), funcOffsetZ(spacePointSrc.z));
+    });
+    const identifiers = {
+        spacePointIds: [A, B, C].map((spacePoint) => spacePoint.toIdentifiers()),
+    };
+    return identifiers;
+};
+const getCheckSpacePointCollinearityQuestion = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const isAllowRationalCoeffs = opts.isAllowRationalCoeffs;
+    const identifiers = createRandomIdentifiers(isAllowRationalCoeffs);
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers, _opts) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+const optsDefault = {
+    isAllowRationalCoeffs: false,
+};
+const options = [
+    {
+        id: "isAllowRationalCoeffs",
+        label: "Permettre des coefficients rationnels",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.checkbox,
+        defaultValue: optsDefault.isAllowRationalCoeffs,
+    },
+];
+export const checkSpacePointCollinearity = {
+    id: "checkSpacePointCollinearity",
+    label: "Déterminer si $3$ points de coordonnées données sont alignés",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getCheckSpacePointCollinearityQuestion(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

package/lib/exercises/math/spaceGeometry/collinearity/checkAlignedSpacePointsFromVecPathsFromCubeOuterPoints.d.ts

@@ -0,0 +1,15 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { SpacePointIdentifiers } from "../../../../math/geometry/spacePoint.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+/**
+  END CUBE STUFF
+*/
+type Identifiers = {
+    spacePointIdsCubeOrigin: SpacePointIdentifiers;
+    spacePointIdsCubeVecsEndPoint: SpacePointIdentifiers[];
+    spacePointIdsWrtBaseVecs: SpacePointIdentifiers[];
+    nodeIdsVecEquation: NodeIdentifiers[];
+};
+export declare const checkAlignedSpacePointsFromVecPathsFromCubeOuterPoints: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=checkAlignedSpacePointsFromVecPathsFromCubeOuterPoints.d.ts.map

package/lib/exercises/math/spaceGeometry/collinearity/checkAlignedSpacePointsFromVecPathsFromCubeOuterPoints.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkAlignedSpacePointsFromVecPathsFromCubeOuterPoints.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/collinearity/checkAlignedSpacePointsFromVecPathsFromCubeOuterPoints.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAGL,qBAAqB,EACtB,MAAM,mCAAmC,CAAC;AAO3C,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAkS7C;;EAEE;AAEF,KAAK,WAAW,GAAG;IACjB,uBAAuB,EAAE,qBAAqB,CAAC;IAC/C,6BAA6B,EAAE,qBAAqB,EAAE,CAAC;IACvD,wBAAwB,EAAE,qBAAqB,EAAE,CAAC;IAClD,kBAAkB,EAAE,eAAe,EAAE,CAAC;CACvC,CAAC;AAofF,eAAO,MAAM,sDAAsD,EAAE,QAAQ,CAAC,WAAW,CAwBtF,CAAC"}