math-exercises 3.0.158 → 3.0.160

package/lib/exercises/math/geometry/vectors/scalarProduct/alg/scalarProductInOrthonormalBasisIJ.js

@@ -0,0 +1,231 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, propWhile, } from "../../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../../exercises/utils/getDistinctQuestions.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 { multiply } from "../../../../../../tree/nodes/operators/multiplyNode.js";
+import { parseAlgebraic } from "../../../../../../tree/parsers/latexParser.js";
+import { zip } from "../../../../../../utils/arrays/arrayZip.js";
+import { handleVEAError } from "../../../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../../../utils/latex/alignTex.js";
+const getHydratedNodes = (identifiers) => {
+    const { nodeIdsU, nodeIdsV } = identifiers;
+    return {
+        nodesU: nodeIdsU.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds)),
+        nodesV: nodeIdsV.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds)),
+    };
+};
+const getInstruction = (identifiers) => {
+    const { nodesU, nodesV } = getHydratedNodes(identifiers);
+    const [i, j, u, v] = ["i", "j", "u", "v"].map((letter) => `\\overrightarrow{${letter}}`);
+    const [texUI, texVI] = [nodesU[0], nodesV[0]].map((node) => {
+        const v = node.evaluate();
+        if (v === -1) {
+            return "-";
+        }
+        else if (v === 1) {
+            return "";
+        }
+        else {
+            return node.toTex();
+        }
+    });
+    const [texUJ, texVJ] = [nodesU[1], nodesV[1]].map((node) => {
+        const v = node.evaluate();
+        if (v >= 0) {
+            return v === 1 ? "+" : `+ ${node.toTex()}`;
+        }
+        else {
+            return v === -1 ? "-" : node.toTex();
+        }
+    });
+    return `Soient $${i}$ et $${j}$ deux vecteurs formant une base orthonormale du plan.
+  
+Soient $${u}$ et $${v}$ deux vecteurs tels que : 
+  
+$$
+${u} = ${texUI}${i} ${texUJ}${j} 
+$$
+
+$$
+${v} = ${texVI}${i} ${texVJ}${j} 
+$$
+  
+Calculer : 
+
+$$
+${u} \\cdot ${v}
+$$
+
+`;
+};
+const getAnswerNode = (identifiers) => {
+    const { nodesU, nodesV } = getHydratedNodes(identifiers);
+    return zip(nodesU, nodesV)
+        .map(([nodeUX, nodeVX]) => multiply(nodeUX, nodeVX))
+        .reduce((acc, nodeX) => add(acc, nodeX));
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).simplify().toTex();
+};
+const getHint = () => {
+    const [i, j] = ["i", "j"].map((letter) => `\\overrightarrow{${letter}}`);
+    return `Les vecteurs $${i}$ et $${j}$ forment une base orthonormale.
+  
+Autrement dit : 
+
+$$
+${i} \\cdot ${i} = ${j} \\cdot ${j} = 1
+$$
+
+et
+
+$$
+${i} \\cdot ${j} = 0
+$$
+
+`;
+};
+const getCorrection = (identifiers) => {
+    const { nodesU, nodesV } = getHydratedNodes(identifiers);
+    const [i, j, u, v] = ["i", "j", "u", "v"].map((letter) => `\\overrightarrow{${letter}}`);
+    const [texUI, texVI] = [nodesU[0], nodesV[0]].map((node) => {
+        const v = node.evaluate();
+        if (v === -1) {
+            return "-";
+        }
+        else if (v === 1) {
+            return "";
+        }
+        else {
+            return node.toTex();
+        }
+    });
+    const [texUJ, texVJ] = [nodesU[1], nodesV[1]].map((node) => {
+        const v = node.evaluate();
+        if (v >= 0) {
+            return v === 1 ? "+" : `+ ${node.toTex()}`;
+        }
+        else {
+            return v === -1 ? "-" : node.toTex();
+        }
+    });
+    return `On développe : 
+
+${alignTex([
+        ["", `${u} \\cdot ${v}`],
+        ["=", `(${texUI}${i} ${texUJ}${j}) \\cdot (${texVI}${i} ${texVJ}${j})`],
+        [
+            "=",
+            `(${multiply(nodesU[0], nodesV[0]).toTex()})(${i} \\cdot ${i}) + (${multiply(nodesU[1], nodesV[1]).toTex()})(${j} \\cdot ${j}) + 0`,
+        ],
+    ])}
+
+On s'est épargné le calcul des autres produits car 
+
+$$
+${i} \\cdot ${j} = ${j} \\cdot ${i} = 0
+$$
+
+On peut donc calculer le produit scalaire en utilisant les coordonnées dans la base $(${i},${j})$ de la même manière que lorsque l'on travaille dans la base canonique du plan. 
+
+${alignTex([
+        ["", `${u} \\cdot ${v}`],
+        [
+            "=",
+            `${getAnswerNode(identifiers).toTex({
+                forceTimesSign: true,
+                forceNoSimplification: true,
+            })}`,
+        ],
+        ["=", `${getAnswer(identifiers)}`],
+    ])}
+
+`;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const { nodesU, nodesV } = getHydratedNodes(identifiers);
+    //student: (uI + vI) + (uJ + vJ)
+    {
+        const nodeWrong = zip(nodesU, nodesV)
+            .map(([nodeUX, nodeVX]) => add(nodeUX, nodeVX))
+            .reduce((acc, nodeX) => add(acc, nodeX));
+        tryToAddWrongProp(propositions, nodeWrong.simplify().toTex());
+    }
+    //student: (uI * vI) * (uJ * vJ)
+    {
+        const nodeWrong = zip(nodesU, nodesV)
+            .map(([nodeUX, nodeVX]) => multiply(nodeUX, nodeVX))
+            .reduce((acc, nodeX) => multiply(acc, nodeX));
+        tryToAddWrongProp(propositions, nodeWrong.simplify().toTex());
+    }
+    //student: nonsense magic: number("uIuJ") op number("vIvJ")
+    {
+        const nodeMagicU = parseInt(nodesU.reduce((acc, node) => acc + `${node.toTex()}`, "")).toTree();
+        const nodeMagicV = parseInt(nodesV.reduce((acc, node) => acc + `${node.toTex()}`, "")).toTree();
+        tryToAddWrongProp(propositions, add(nodeMagicU, nodeMagicV).simplify().toTex());
+        tryToAddWrongProp(propositions, multiply(nodeMagicU, nodeMagicV).simplify().toTex());
+    }
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, randint(-60, 60).frenchify());
+    });
+    return shuffleProps(propositions, n);
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const parsed = parseAlgebraic(ans);
+        return parsed.simplify().toTex() === answer;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getScalarProductInOrthonormalBasisIJQuestion = () => {
+    function createRandomCoordsNodes() {
+        return [...Array(2).keys()]
+            .map(() => randint(-10, 11, [0]))
+            .map((v) => v.toTree());
+    }
+    const nodesU = createRandomCoordsNodes();
+    const nodesV = createRandomCoordsNodes();
+    const identifiers = {
+        nodeIdsU: nodesU.map((node) => node.toIdentifiers()),
+        nodeIdsV: nodesV.map((node) => node.toIdentifiers()),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    return {
+        answer: getAnswer(identifiers, opts),
+        instruction: getInstruction(identifiers, opts),
+        keys: getKeys(identifiers, opts),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+        options: opts,
+    };
+};
+export const scalarProductInOrthonormalBasisIJ = {
+    id: "scalarProductInOrthonormalBasisIJ",
+    connector: "=",
+    label: "Calculer $\\overrightarrow{u} \\cdot \\overrightarrow{v}$ avec $\\overrightarrow{u}$ et $\\overrightarrow{v}$ décomposés dans une base orthonormée $(\\overrightarrow{i},\\overrightarrow{j})$",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(() => getScalarProductInOrthonormalBasisIJQuestion(), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/geometry/vectors/scalarProduct/alg/scalarProductLamdbaULambdaV.d.ts

@@ -0,0 +1,14 @@
+import { Exercise } from "../../../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    nodeIdsUDotV: NodeIdentifiers;
+    nodeIdsA: NodeIdentifiers;
+    nodeIdsB: NodeIdentifiers;
+};
+type Options = {
+    isSignOnly: boolean;
+};
+export declare const scalarProductLamdbaULambdaV: Exercise<Identifiers, Options>;
+export declare const scalarProductSignUSignV: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=scalarProductLamdbaULambdaV.d.ts.map

package/lib/exercises/math/geometry/vectors/scalarProduct/alg/scalarProductLamdbaULambdaV.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scalarProductLamdbaULambdaV.d.ts","sourceRoot":"","sources":["../../../../../../../src/exercises/math/geometry/vectors/scalarProduct/alg/scalarProductLamdbaULambdaV.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAgB7C,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,eAAe,CAAC;IAC9B,QAAQ,EAAE,eAAe,CAAC;IAC1B,QAAQ,EAAE,eAAe,CAAC;CAC3B,CAAC;AAmSF,KAAK,OAAO,GAAG;IACb,UAAU,EAAE,OAAO,CAAC;CACrB,CAAC;AAMF,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAsBtE,CAAC;AAEF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAsBlE,CAAC"}

package/lib/exercises/math/geometry/vectors/scalarProduct/alg/scalarProductLamdbaULambdaV.js

@@ -0,0 +1,292 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, propWhile, } from "../../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../../../../math/utils/random/randint.js";
+import { NodeConstructor, } from "../../../../../../tree/nodes/nodeConstructor.js";
+import { isNumberNode } from "../../../../../../tree/nodes/numbers/numberNode.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 { parseAlgebraic } from "../../../../../../tree/parsers/latexParser.js";
+import { random } from "../../../../../../utils/alea/random.js";
+import { shuffle } from "../../../../../../utils/alea/shuffle.js";
+import { handleVEAError } from "../../../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../../../utils/latex/alignTex.js";
+const parenthesesIfNeeded = (tex) => {
+    const isShouldParentheses = tex.startsWith("-") || tex.startsWith("+");
+    return isShouldParentheses ? `(${tex})` : tex;
+};
+const getHydratedNodes = (identifiers) => {
+    const { nodeIdsUDotV, nodeIdsA, nodeIdsB } = identifiers;
+    return {
+        nodeUDotV: NodeConstructor.fromIdentifiers(nodeIdsUDotV),
+        nodeA: NodeConstructor.fromIdentifiers(nodeIdsA),
+        nodeB: NodeConstructor.fromIdentifiers(nodeIdsB),
+    };
+};
+const getInstruction = (identifiers) => {
+    const { nodeUDotV, nodeA, nodeB } = getHydratedNodes(identifiers);
+    const texA = nodeA.evaluate() === -1
+        ? "-"
+        : nodeA.evaluate() === 1
+            ? "+"
+            : nodeA.toTex();
+    const texB = nodeB.evaluate() === -1
+        ? "-"
+        : nodeB.evaluate() === 1
+            ? "+"
+            : nodeB.toTex();
+    const u = "\\overrightarrow u";
+    const v = "\\overrightarrow v";
+    return `Soit $${u}$ et $${v}$ deux vecteurs tels que : 
+  
+$$
+${u} \\cdot ${v} = ${nodeUDotV.toTex()}
+$$
+  
+Calculer : 
+
+$$
+${parenthesesIfNeeded(`${texA}${u}`)} \\cdot ${parenthesesIfNeeded(`${texB}${v}`)}
+$$
+
+`;
+};
+const getAnswerNode = (identifiers) => {
+    const { nodeUDotV, nodeA, nodeB } = getHydratedNodes(identifiers);
+    return multiply(multiply(nodeA, nodeB), nodeUDotV);
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).simplify().toTex();
+};
+const getHint = (identifiers) => {
+    const { nodeA, nodeB } = getHydratedNodes(identifiers);
+    const isSignOnly = Math.abs(nodeA.evaluate()) === 1 && Math.abs(nodeB.evaluate()) === 1;
+    if (isSignOnly) {
+        return `Voici un calcul pour te mettre sur la piste : 
+
+${alignTex([
+            [
+                "",
+                "\\overrightarrow{u} \\cdot \\overrightarrow{v} + ((-\\overrightarrow{u}) \\cdot \\overrightarrow{v})",
+            ],
+            [
+                "=",
+                "(\\overrightarrow{u} + (-\\overrightarrow{u})) \\cdot \\overrightarrow{v}",
+            ],
+            ["=", "(\\overrightarrow{0} \\cdot \\overrightarrow{v})"],
+            ["=", "0"],
+        ])}
+
+`;
+    }
+    else {
+        return `Voici un calcul pour te mettre sur la piste : 
+
+${alignTex([
+            [
+                "",
+                "(\\overrightarrow{u} + \\overrightarrow{u}) \\cdot \\overrightarrow{v}",
+            ],
+            [
+                "=",
+                "\\overrightarrow{u} \\cdot \\overrightarrow{v} + \\overrightarrow{u} \\cdot \\overrightarrow{v}",
+            ],
+            ["=", "2 (\\overrightarrow{u} \\cdot \\overrightarrow{v})"],
+        ])}
+
+`;
+    }
+};
+const getCorrection = (identifiers) => {
+    const { nodeA, nodeB } = getHydratedNodes(identifiers);
+    const texA = nodeA.evaluate() === -1
+        ? "-"
+        : nodeA.evaluate() === 1
+            ? "+"
+            : nodeA.toTex();
+    const texB = nodeB.evaluate() === -1
+        ? "-"
+        : nodeB.evaluate() === 1
+            ? "+"
+            : nodeB.toTex();
+    const u = "\\overrightarrow u";
+    const v = "\\overrightarrow v";
+    return `Le produit scalaire vérifie, pour $k$ et $k'$ réels : 
+  
+$$
+(k \\overrightarrow{u}) \\cdot \\overrightarrow{v} = k (\\overrightarrow{u} \\cdot \\overrightarrow{v})
+$$
+
+$$
+\\overrightarrow{u} \\cdot (k' \\overrightarrow{v}) = k' (\\overrightarrow{u} \\cdot \\overrightarrow{v})
+$$
+
+On a donc : 
+
+$$
+${parenthesesIfNeeded(`${texA}${u}`)} \\cdot ${parenthesesIfNeeded(`${texB}${v}`)} = ${multiply(nodeA, nodeB).toTex({
+        forceNoSimplification: true,
+        forceTimesSign: true,
+    })} \\times (\\overrightarrow{u} \\cdot \\overrightarrow{v})  = ${getAnswer(identifiers)}
+$$
+
+`;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const { nodeUDotV, nodeA, nodeB } = getHydratedNodes(identifiers);
+    const isSignOnly = Math.abs(nodeA.evaluate()) === 1 && Math.abs(nodeB.evaluate()) === 1;
+    //student: strange magic: a * firstDigit(uDotV) + b * secondDigit(uDotV)
+    if (isSignOnly) {
+        const uDotV = nodeUDotV.evaluate();
+        if (uDotV.frenchify().length === 2) {
+            const [firstDigit, secondDigit] = uDotV
+                .frenchify()
+                .split("")
+                .map((s) => +s);
+            const nodeWrong = add(multiply(nodeA, firstDigit), multiply(nodeB, secondDigit));
+            tryToAddWrongProp(propositions, nodeWrong.simplify().toTex());
+        }
+    }
+    //student: concatenation
+    if (!isSignOnly) {
+        if (isNumberNode(nodeA) && isNumberNode(nodeB)) {
+            const a = nodeA.evaluate();
+            const b = nodeB.evaluate();
+            if (a > 0 && b > 0) {
+                tryToAddWrongProp(propositions, `${a.frenchify()}${b.frenchify()}`);
+            }
+        }
+    }
+    //student: concatenation times nodeUDotV
+    if (!isSignOnly) {
+        if (isNumberNode(nodeA) && isNumberNode(nodeB)) {
+            const a = nodeA.evaluate();
+            const b = nodeB.evaluate();
+            if (a > 0 && b > 0) {
+                const nodeConcat = parseAlgebraic(`${a.frenchify()}${b.frenchify()}`);
+                const nodeWrong = multiply(nodeConcat, nodeUDotV).simplify();
+                tryToAddWrongProp(propositions, nodeWrong.toTex());
+            }
+        }
+    }
+    //student: au dot bv = (a+b)(u dot v)
+    {
+        const nodeWrong = multiply(add(nodeA, nodeB).simplify(), nodeUDotV).simplify();
+        tryToAddWrongProp(propositions, nodeWrong.toTex());
+    }
+    propWhile(propositions, n + 2, () => {
+        tryToAddWrongProp(propositions, randint(-30, 30).frenchify());
+    });
+    return shuffleProps(propositions, n);
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const parsed = parseAlgebraic(ans);
+        return parsed.simplify().toTex() === answer;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getScalarProductLamdbaULambdaVQuestion = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const { isSignOnly } = opts;
+    function createRandomNodes() {
+        const rand = randint(0, 3);
+        switch (rand) {
+            case 0:
+                {
+                    //les tables de multiplication (entiers naturels)
+                    return [...Array(2).keys()].map(() => randint(2, 10).toTree());
+                }
+                break;
+            case 1:
+                {
+                    //les tables de multiplication (entiers relatifs)
+                    return [...Array(2).keys()].map(() => randint(2, 10).toTree());
+                }
+                break;
+            case 2:
+                {
+                    //fraction simplifiable en un entier
+                    const common = randint(2, 10);
+                    return shuffle([common, common * randint(2, 10)]).map((v, i) => i === 0 ? frac(1, v) : v.toTree());
+                }
+                break;
+            default:
+                throw new Error("Unsupported rand: " + rand);
+        }
+    }
+    const [nodeA, nodeB] = isSignOnly
+        ? random([
+            [1, -1],
+            [-1, 1],
+            [-1, -1],
+        ]).map((v) => v.toTree())
+        : createRandomNodes();
+    const nodeUDotV = isSignOnly
+        ? randint(10, 100).toTree()
+        : random([1, 10, 100]).toTree();
+    const identifiers = {
+        nodeIdsA: nodeA.toIdentifiers(),
+        nodeIdsB: nodeB.toIdentifiers(),
+        nodeIdsUDotV: nodeUDotV.toIdentifiers(),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    return {
+        answer: getAnswer(identifiers, opts),
+        instruction: getInstruction(identifiers, opts),
+        keys: getKeys(identifiers, opts),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+        options: opts,
+    };
+};
+const optsDefault = {
+    isSignOnly: false,
+};
+export const scalarProductLamdbaULambdaV = {
+    id: "scalarProductLamdbaULambdaV",
+    connector: "=",
+    label: "Calculer $(a \\overrightarrow{u}) \\cdot (b \\overrightarrow{v})$ connaissant $\\overrightarrow{u} \\cdot \\overrightarrow{v}$",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(() => getScalarProductLamdbaULambdaVQuestion({ isSignOnly: false }), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};
+export const scalarProductSignUSignV = {
+    id: "scalarProductSignUSignV",
+    connector: "=",
+    label: "Calculer $(\\pm \\overrightarrow{u}) \\cdot (\\pm \\overrightarrow{v})$ connaissant $\\overrightarrow{u} \\cdot \\overrightarrow{v}$",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(() => getScalarProductLamdbaULambdaVQuestion({ isSignOnly: true }), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/geometry/vectors/scalarProduct/orth/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./scalarProductIsOrthogonalVecsBasisIJ.js";
+export * from "./scalarProductIsOrthogonalVecsUsingCoords.js";
+export * from "./scalarProductIsRightTriangleUsingPointCoords.js";
+export * from "./scalarProductIsPointOnPerpendicularBisector.js";
+export * from "./scalarProductIsPointOnCircle.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../src/exercises/math/geometry/vectors/scalarProduct/orth/index.ts"],"names":[],"mappings":"AAAA,cAAc,2CAA2C,CAAC;AAC1D,cAAc,+CAA+C,CAAC;AAC9D,cAAc,mDAAmD,CAAC;AAClE,cAAc,kDAAkD,CAAC;AACjE,cAAc,mCAAmC,CAAC"}

package/lib/exercises/math/geometry/vectors/scalarProduct/orth/index.js

@@ -0,0 +1,5 @@
+export * from "./scalarProductIsOrthogonalVecsBasisIJ.js";
+export * from "./scalarProductIsOrthogonalVecsUsingCoords.js";
+export * from "./scalarProductIsRightTriangleUsingPointCoords.js";
+export * from "./scalarProductIsPointOnPerpendicularBisector.js";
+export * from "./scalarProductIsPointOnCircle.js";

package/lib/exercises/math/geometry/vectors/scalarProduct/orth/scalarProductIsOrthogonalVecsBasisIJ.d.ts

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

package/lib/exercises/math/geometry/vectors/scalarProduct/orth/scalarProductIsOrthogonalVecsBasisIJ.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scalarProductIsOrthogonalVecsBasisIJ.d.ts","sourceRoot":"","sources":["../../../../../../../src/exercises/math/geometry/vectors/scalarProduct/orth/scalarProductIsOrthogonalVecsBasisIJ.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAO7C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,eAAe,EAAE,CAAC;IAC5B,QAAQ,EAAE,eAAe,EAAE,CAAC;CAC7B,CAAC;AAqNF,eAAO,MAAM,oCAAoC,EAAE,QAAQ,CAAC,WAAW,CAsBtE,CAAC"}