math-exercises 3.0.157 → 3.0.158

package/lib/exercises/math/trigonometry/triangle/trigonometrySohcahtoaUse.js

@@ -0,0 +1,386 @@
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { blueMain, red } from "../../../../geogebra/colors.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { RightTriangleConstructor } from "../../../../math/geometry/triangles/rightTriangle.js";
+import { TriangleConstructor, } from "../../../../math/geometry/triangles/triangle.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { VariableNode } from "../../../../tree/nodes/variables/variableNode.js";
+import { random, randomMany } from "../../../../utils/alea/random.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { getAllPicks } from "../../../../utils/arrays/getAllPicks.js";
+const trigoFuncsDict = {
+    sin: {
+        id: "sin",
+        strFrench: "sinus",
+        funcTex: (content) => `\\sin(${content})`,
+        funcIndexesSegment: (indexPoint) => {
+            switch (indexPoint) {
+                case 1:
+                    return [1, 0];
+                case 2:
+                    return [2, 0];
+                default:
+                    throw new Error("Unsupported indexPoint: " + indexPoint);
+            }
+        },
+        texEqFrac: "\\sin(\\text{angle}) = \\frac{\\text{opposé}}{\\text{hypoténuse}}",
+    },
+    cos: {
+        id: "cos",
+        strFrench: "cosinus",
+        funcTex: (content) => `\\cos(${content})`,
+        funcIndexesSegment: (indexPoint) => {
+            switch (indexPoint) {
+                case 1:
+                    return [2, 0];
+                case 2:
+                    return [1, 0];
+                default:
+                    throw new Error("Unsupported indexPoint: " + indexPoint);
+            }
+        },
+        texEqFrac: "\\cos(\\text{angle}) = \\frac{\\text{adjacent}}{\\text{hypoténuse}}",
+    },
+    tan: {
+        id: "tan",
+        strFrench: "tangente",
+        funcTex: (content) => `\\tan(${content})`,
+        funcIndexesSegment: (indexPoint) => {
+            switch (indexPoint) {
+                case 1:
+                    return [1, 2];
+                case 2:
+                    return [2, 1];
+                default:
+                    throw new Error("Unsupported indexPoint: " + indexPoint);
+            }
+        },
+        texEqFrac: "\\tan(\\text{angle}) = \\frac{\\text{opposé}}{\\text{adjacent}}",
+    },
+};
+const getTrigoFuncEntryForTargetAngle = (indexTarget, indexesGivenSegments) => {
+    return Object.entries(trigoFuncsDict).find(([_, trigoFunc]) => {
+        const indexesSegment = trigoFunc.funcIndexesSegment(indexTarget);
+        return ([...new Set([...indexesSegment, ...indexesGivenSegments])].length === 2);
+    });
+};
+const getTrigoFuncEntryForTargetSide = (indexTarget, indexGivenSegment, indexGivenAngle) => {
+    return Object.entries(trigoFuncsDict).find(([_, trigoFunc]) => {
+        const indexesSegment = trigoFunc.funcIndexesSegment(indexGivenAngle);
+        return ([...new Set([...indexesSegment, ...[indexTarget, indexGivenSegment]])]
+            .length === 2);
+    });
+};
+const getTrigoFuncAndIndexesSegmentDict = (targetType, indexTarget, indexesGivenSegments, indexGivenAngle) => {
+    let trigoFunc;
+    let indexesSegment;
+    switch (targetType) {
+        case "angle":
+            {
+                [, trigoFunc] = getTrigoFuncEntryForTargetAngle(indexTarget, indexesGivenSegments);
+                indexesSegment = trigoFunc.funcIndexesSegment(indexTarget);
+            }
+            break;
+        case "segment":
+            {
+                [, trigoFunc] = getTrigoFuncEntryForTargetSide(indexTarget, indexesGivenSegments[0], indexGivenAngle);
+                indexesSegment = trigoFunc.funcIndexesSegment(indexGivenAngle);
+            }
+            break;
+    }
+    return { trigoFunc, indexesSegment };
+};
+const getInstruction = (identifiers) => {
+    const { targetType, indexTarget, triangleIdentifiers, indexesGivenSegments, indexGivenAngle, } = identifiers;
+    const triangle = TriangleConstructor.fromIdentifiers(triangleIdentifiers);
+    switch (identifiers.questionType) {
+        case "frac":
+            {
+                switch (targetType) {
+                    case "angle": {
+                        const texAngle = `\\widehat{${triangle.points[indexTarget].toTex()}}`;
+                        return `Dans le triangle $${triangle.name}$ ci-dessous, on connaît la longueur $${triangle.sides[indexesGivenSegments[0]].toInsideName()}$ et la longueur $${triangle.sides[indexesGivenSegments[1]].toInsideName()}$. Quel rapport trigonométrique doit-on utiliser pour calculer la mesure de $${texAngle}$ ?`;
+                    }
+                    case "segment": {
+                        return `Dans le triangle $${triangle.name}$ ci-dessous, on connaît la longueur $${triangle.sides[indexesGivenSegments[0]].toInsideName()}$ et la mesure de l'angle $\\widehat{${triangle.points[indexGivenAngle].toTex()}}$. Quel rapport trigonométrique doit-on utiliser pour calculer la longueur $${triangle.sides[indexTarget].toInsideName()}$ ?`;
+                    }
+                }
+            }
+            break;
+        case "func": {
+            switch (targetType) {
+                case "angle": {
+                    const texAngle = `\\widehat{${triangle.points[indexTarget].toTex()}}`;
+                    return `Dans le triangle $${triangle.name}$ ci-dessous, on connaît la longueur $${triangle.sides[indexesGivenSegments[0]].toInsideName()}$ et la longueur $${triangle.sides[indexesGivenSegments[1]].toInsideName()}$. Quelle fonction trigonométrique doit-on utiliser pour calculer la mesure de $${texAngle}$ ?`;
+                }
+                case "segment": {
+                    return `Dans le triangle $${triangle.name}$ ci-dessous, on connaît la longueur $${triangle.sides[indexesGivenSegments[0]].toInsideName()}$ et la mesure de l'angle $\\widehat{${triangle.points[indexGivenAngle].toTex()}}$. Quelle fonction trigonométrique doit-on utiliser pour calculer la longueur $${triangle.sides[indexTarget].toInsideName()}$ ?`;
+                }
+            }
+        }
+    }
+};
+const getAnswerNode = (identifiers) => {
+    const { targetType, indexTarget, indexGivenAngle, indexesGivenSegments, triangleIdentifiers, } = identifiers;
+    const triangle = TriangleConstructor.fromIdentifiers(triangleIdentifiers);
+    let indexesSegment;
+    switch (targetType) {
+        case "angle":
+            {
+                const [, trigoFunc] = getTrigoFuncEntryForTargetAngle(indexTarget, indexesGivenSegments);
+                indexesSegment = trigoFunc.funcIndexesSegment(indexTarget);
+            }
+            break;
+        case "segment":
+            {
+                const [, trigoFunc] = getTrigoFuncEntryForTargetSide(indexTarget, indexesGivenSegments[0], indexGivenAngle);
+                indexesSegment = trigoFunc.funcIndexesSegment(indexGivenAngle);
+            }
+            break;
+    }
+    const [nodeNum, nodeDen] = indexesSegment.map((indexSegment) => new VariableNode(`${triangle.sides[indexSegment].toInsideName()}`));
+    const fractionNode = frac(nodeNum, nodeDen);
+    return fractionNode;
+};
+const getAnswer = (identifiers) => {
+    switch (identifiers.questionType) {
+        case "frac": {
+            return getAnswerNode(identifiers).toTex();
+        }
+        case "func": {
+            const { targetType, indexTarget, indexGivenAngle, indexesGivenSegments } = identifiers;
+            const { trigoFunc } = getTrigoFuncAndIndexesSegmentDict(targetType, indexTarget, indexesGivenSegments, indexGivenAngle);
+            const nameTrigoFunc = trigoFunc.id;
+            const tex = `\\text{${nameTrigoFunc}}`;
+            return tex;
+        }
+    }
+};
+const getHint = () => {
+    return `Identifie le côté opposé, le côté adjacent et l'hypoténuse du triangle. Puis cherche la bonne formule de trigonométrie, en te rappelant de : 
+  
+$$
+\\text{SOHCAHTOA}
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { targetType, indexTarget, indexGivenAngle, indexesGivenSegments, triangleIdentifiers, } = identifiers;
+    const triangle = RightTriangleConstructor.fromIdentifiers(triangleIdentifiers);
+    const { trigoFunc, indexesSegment } = getTrigoFuncAndIndexesSegmentDict(targetType, indexTarget, indexesGivenSegments, indexGivenAngle);
+    const [segmentNum, segmentDen] = indexesSegment.map((i) => triangle.sides[i]);
+    const [nameNum, nameDen] = [segmentNum, segmentDen].map((segment) => `${segment.pointA.name}${segment.pointB.name}`);
+    const texAngle = `\\widehat{${triangle.points[indexGivenAngle ?? indexTarget].toTex()}}`;
+    return `On a :
+  
+$$
+${trigoFunc.funcTex(texAngle)} = \\frac{${nameNum}}{${nameDen}}
+$$
+
+${(() => {
+        switch (identifiers.questionType) {
+            case "frac": {
+                return `Le rapport recherché est $${`\\frac{${nameNum}}{${nameDen}}`}$.`;
+            }
+            case "func": {
+                return `La fonction recherchée est la fonction ${trigoFunc.strFrench}.`;
+            }
+        }
+    })()}`;
+};
+const getGGBOptions = (identifiers) => {
+    const { targetType, indexTarget, indexGivenAngle, indexesGivenSegments, triangleIdentifiers, } = identifiers;
+    const triangle = RightTriangleConstructor.fromIdentifiers(triangleIdentifiers);
+    switch (targetType) {
+        case "angle":
+            {
+                //target
+                triangle.highlightAngle(indexTarget, {
+                    color: blueMain,
+                    showValue: false,
+                });
+                //given
+                indexesGivenSegments.forEach((indexSegment) => {
+                    triangle.highlightSide(indexSegment, { color: red });
+                });
+            }
+            break;
+        case "segment":
+            {
+                //target
+                triangle.highlightSide(indexTarget, {
+                    color: blueMain,
+                });
+                //given
+                if (indexGivenAngle) {
+                    triangle.highlightAngle(indexGivenAngle, {
+                        color: red,
+                        showValue: false,
+                    });
+                }
+                indexesGivenSegments.forEach((indexSegment) => {
+                    triangle.highlightSide(indexSegment, { color: red });
+                });
+            }
+            break;
+    }
+    const ggb = new GeogebraConstructor({
+        commands: triangle.commands,
+        hideAxes: true,
+        hideGrid: true,
+    });
+    return ggb.getOptions({
+        coords: triangle.generateCoords(),
+    });
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    switch (identifiers.questionType) {
+        case "frac": {
+            const { triangleIdentifiers } = identifiers;
+            const propositions = [];
+            const triangle = RightTriangleConstructor.fromIdentifiers(triangleIdentifiers);
+            addValidProp(propositions, answer);
+            getAllPicks([0, 1, 2])
+                .filter((arrSegment) => arrSegment.length === 2)
+                .forEach((indexesSegment) => {
+                const [nodeNum, nodeDen] = indexesSegment.map((indexSegment) => new VariableNode(`${triangle.sides[indexSegment].toInsideName()}`));
+                const fractionNode1 = frac(nodeNum, nodeDen);
+                tryToAddWrongProp(propositions, fractionNode1.toTex());
+                const fractionNode2 = frac(nodeDen, nodeNum);
+                tryToAddWrongProp(propositions, fractionNode2.toTex());
+            });
+            return shuffleProps(propositions, n);
+        }
+        case "func": {
+            const propositions = [];
+            ["sin", "cos", "tan"].forEach((nameTrigoFunc) => {
+                const tex = `\\text{${nameTrigoFunc}}`;
+                if (tex === answer) {
+                    addValidProp(propositions, tex);
+                }
+                else {
+                    tryToAddWrongProp(propositions, tex);
+                }
+            });
+            return shuffle(propositions);
+        }
+    }
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+const getKeys = (identifiers) => {
+    switch (identifiers.questionType) {
+        case "frac": {
+            const { triangleIdentifiers } = identifiers;
+            const triangle = RightTriangleConstructor.fromIdentifiers(triangleIdentifiers);
+            return [
+                ...triangle.sides.map((side) => {
+                    const strLength = side.toInsideName();
+                    return {
+                        id: "custom",
+                        label: strLength,
+                        labelType: "tex",
+                        mathfieldInstructions: {
+                            method: "write",
+                            content: strLength,
+                        },
+                    };
+                }),
+            ];
+        }
+        case "func": {
+            return ["sin", "cos", "tan"];
+        }
+    }
+};
+const getTrigonometrySohcahtoaUseQuestion = (optsIn) => {
+    const targetTypes = optsIn?.targetTypes ?? optsDefault.targetTypes;
+    const opts = Object.assign(optsIn, { targetTypes });
+    const triangle = RightTriangleConstructor.randomNiceSides({
+        randomName: true,
+    });
+    const targetType = random(targetTypes);
+    const indexTarget = randint(1, 3);
+    let indexGivenAngle;
+    const indexesGivenSegments = [];
+    switch (targetType) {
+        case "angle":
+            {
+                indexesGivenSegments.push(...randomMany([0, 1, 2], 2));
+            }
+            break;
+        case "segment":
+            {
+                indexGivenAngle = randint(1, 3);
+                indexesGivenSegments.push(3 - indexTarget);
+            }
+            break;
+    }
+    const identifiers = {
+        questionType: opts.questionType,
+        targetType,
+        indexTarget,
+        indexGivenAngle,
+        indexesGivenSegments,
+        triangleIdentifiers: triangle.toIdentifiers(),
+    };
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    return {
+        instruction: getInstruction(identifiers, opts),
+        answer: getAnswer(identifiers, opts),
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+        keys: getKeys(identifiers, opts),
+        ggbOptions: getGGBOptions(identifiers, opts),
+        answerFormat: "tex",
+        identifiers,
+        options: opts,
+    };
+};
+const optsDefault = {
+    targetTypes: ["angle", "segment"],
+};
+const options = [
+    {
+        id: "targetType",
+        label: "Mesure recherchée",
+        type: GeneratorOptionType.multiselect,
+        target: GeneratorOptionTarget.generation,
+        values: ["angle", "segment"],
+        defaultValue: optsDefault.targetTypes,
+    },
+];
+export const trigonometrySohcahtoaUseFrac = {
+    id: "trigonometrySohcahtoaUseFrac",
+    label: "Utiliser le bon rapport trigonométrique pour calculer la mesure d'un angle ou d'un segment",
+    isSingleStep: false,
+    generator: (nb, opts) => getDistinctQuestions(() => getTrigonometrySohcahtoaUseQuestion(Object.assign({}, { questionType: "frac" }, opts)), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    hasGeogebra: true,
+    subject: "Mathématiques",
+    hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
+};
+export const trigonometrySohcahtoaUseFunc = {
+    id: "trigonometrySohcahtoaUseFunc",
+    label: "Utiliser la bonne fonction trigonométrique pour calculer la mesure d'un angle ou d'un segment",
+    isSingleStep: false,
+    generator: (nb, opts) => getDistinctQuestions(() => getTrigonometrySohcahtoaUseQuestion(Object.assign({}, { questionType: "func" }, opts)), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    hasGeogebra: true,
+    subject: "Mathématiques",
+    hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
+    answerType: "QCU",
+};

package/lib/exercises/pc/mathExosInPC.d.ts

@@ -25,6 +25,6 @@ export * from "../math/derivation/derivative/polynomial/usualderivative.js";
 export { thirdDegreeDerivative } from "../math/derivation/derivative/polynomial/thirdDegreeDerivative.js";
 export { firstDegreeDerivative } from "../math/derivation/derivative/polynomial/firstDegreeDerivative.js";
 export { secondDegreeDerivative } from "../math/derivation/derivative/polynomial/secondDegreeDerivative.js";
-export * from "../math/trigonometry/trigonometrySideCalcul.js";
-export * from "../math/trigonometry/trigonometryAngleCalcul.js";
+export * from "../math/trigonometry/triangle/trigonometrySideCalcul.js";
+export * from "../math/trigonometry/triangle/trigonometryAngleCalcul.js";
 //# sourceMappingURL=mathExosInPC.d.ts.map

package/lib/exercises/pc/mathExosInPC.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mathExosInPC.d.ts","sourceRoot":"","sources":["../../../src/exercises/pc/mathExosInPC.ts"],"names":[],"mappings":"AAAA,yBAAyB;AACzB,cAAc,mCAAmC,CAAC;AAClD,cAAc,wDAAwD,CAAC;AACvE,OAAO,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAC;AACvE,cAAc,uCAAuC,CAAC;AACtD,cAAc,gDAAgD,CAAC;AAC/D,OAAO,EAAE,qBAAqB,EAAE,MAAM,sDAAsD,CAAC;AAC7F,OAAO,EAAE,mBAAmB,EAAE,MAAM,iDAAiD,CAAC;AACtF,OAAO,EAAE,kBAAkB,EAAE,MAAM,iDAAiD,CAAC;AACrF,cAAc,sDAAsD,CAAC;AACrE,cAAc,sDAAsD,CAAC;AACrE,cAAc,sDAAsD,CAAC;AACrE,cAAc,sDAAsD,CAAC;AACrE,cAAc,kEAAkE,CAAC;AACjF,cAAc,+DAA+D,CAAC;AAC9E,cAAc,gDAAgD,CAAC;AAC/D,cAAc,sDAAsD,CAAC;AACrE,cAAc,mCAAmC,CAAC;AAClD,cAAc,yCAAyC,CAAC;AACxD,cAAc,qDAAqD,CAAC;AACpE,cAAc,0CAA0C,CAAC;AACzD,cAAc,2DAA2D,CAAC;AAC1E,cAAc,uDAAuD,CAAC;AACtE,cAAc,6DAA6D,CAAC;AAC5E,OAAO,EAAE,qBAAqB,EAAE,MAAM,mEAAmE,CAAC;AAC1G,OAAO,EAAE,qBAAqB,EAAE,MAAM,mEAAmE,CAAC;AAC1G,OAAO,EAAE,sBAAsB,EAAE,MAAM,oEAAoE,CAAC;AAC5G,cAAc,gDAAgD,CAAC;AAC/D,cAAc,iDAAiD,CAAC"}
+{"version":3,"file":"mathExosInPC.d.ts","sourceRoot":"","sources":["../../../src/exercises/pc/mathExosInPC.ts"],"names":[],"mappings":"AAAA,yBAAyB;AACzB,cAAc,mCAAmC,CAAC;AAClD,cAAc,wDAAwD,CAAC;AACvE,OAAO,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAC;AACvE,cAAc,uCAAuC,CAAC;AACtD,cAAc,gDAAgD,CAAC;AAC/D,OAAO,EAAE,qBAAqB,EAAE,MAAM,sDAAsD,CAAC;AAC7F,OAAO,EAAE,mBAAmB,EAAE,MAAM,iDAAiD,CAAC;AACtF,OAAO,EAAE,kBAAkB,EAAE,MAAM,iDAAiD,CAAC;AACrF,cAAc,sDAAsD,CAAC;AACrE,cAAc,sDAAsD,CAAC;AACrE,cAAc,sDAAsD,CAAC;AACrE,cAAc,sDAAsD,CAAC;AACrE,cAAc,kEAAkE,CAAC;AACjF,cAAc,+DAA+D,CAAC;AAC9E,cAAc,gDAAgD,CAAC;AAC/D,cAAc,sDAAsD,CAAC;AACrE,cAAc,mCAAmC,CAAC;AAClD,cAAc,yCAAyC,CAAC;AACxD,cAAc,qDAAqD,CAAC;AACpE,cAAc,0CAA0C,CAAC;AACzD,cAAc,2DAA2D,CAAC;AAC1E,cAAc,uDAAuD,CAAC;AACtE,cAAc,6DAA6D,CAAC;AAC5E,OAAO,EAAE,qBAAqB,EAAE,MAAM,mEAAmE,CAAC;AAC1G,OAAO,EAAE,qBAAqB,EAAE,MAAM,mEAAmE,CAAC;AAC1G,OAAO,EAAE,sBAAsB,EAAE,MAAM,oEAAoE,CAAC;AAC5G,cAAc,yDAAyD,CAAC;AACxE,cAAc,0DAA0D,CAAC"}

package/lib/exercises/pc/mathExosInPC.js

@@ -25,5 +25,5 @@ export * from "../math/derivation/derivative/polynomial/usualderivative.js";
 export { thirdDegreeDerivative } from "../math/derivation/derivative/polynomial/thirdDegreeDerivative.js";
 export { firstDegreeDerivative } from "../math/derivation/derivative/polynomial/firstDegreeDerivative.js";
 export { secondDegreeDerivative } from "../math/derivation/derivative/polynomial/secondDegreeDerivative.js";
-export * from "../math/trigonometry/trigonometrySideCalcul.js";
-export * from "../math/trigonometry/trigonometryAngleCalcul.js";
+export * from "../math/trigonometry/triangle/trigonometrySideCalcul.js";
+export * from "../math/trigonometry/triangle/trigonometryAngleCalcul.js";

package/lib/index.d.ts

@@ -957,6 +957,17 @@ declare const mathExercises: (Exercise<{
     coeffs: number[];
     x: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
+    aIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    bIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    faIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    fbIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    fxIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    aIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    bIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+}, {
+    functionType: string[];
+}> | Exercise<{
     abscisse: number;
     trinome: number[];
 }, Record<string, string | boolean | string[]>> | Exercise<{
@@ -2535,7 +2546,9 @@ declare const mathExercises: (Exercise<{
     pAB?: number;
     pA_B?: number;
     pB_A?: number;
-}, Record<string, string | boolean | string[]>> | Exercise<{
+}, {
+    probaType: string[];
+}> | Exercise<{
     A: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
     B: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
     AC: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
@@ -2654,6 +2667,16 @@ declare const mathExercises: (Exercise<{
     pA: number;
     pB: number;
     pUnion: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    pAIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    pBIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    pABIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    pAIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    pBIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    pAIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    pBIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     questionType: string;
     value?: string;
@@ -2901,7 +2924,9 @@ declare const mathExercises: (Exercise<{
     firstValue: number;
     reason: number;
     nbTerms: number;
-}, Record<string, string | boolean | string[]>> | Exercise<{
+}, {
+    firstTermRank: string;
+}> | Exercise<{
     firstValue: number;
     reason: number;
     firstRank: number;
@@ -3176,6 +3201,14 @@ declare const mathExercises: (Exercise<{
     a: number;
     k: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
     isSquareInside: boolean;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    angleValue: number;
+    angleIdentifiers: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    point: string;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    degree: number;
+    multipleOf2PiToAdd: number;
+    nodeIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     valueIndex: number;
     isCos: boolean;
@@ -3184,23 +3217,13 @@ declare const mathExercises: (Exercise<{
     isCos: boolean;
     angleIdentifiers: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
 }, Record<string, string | boolean | string[]>> | Exercise<{
-    randAngle: number;
-    randTrigo: number;
-    triangleIdentifiers: import("./math/geometry/triangles/triangle.js").TriangleIdentifiers;
-}, Record<string, string | boolean | string[]>> | Exercise<{
-    randAngle: number;
-    hiddenSide: number;
-    triangleIdentifiers: import("./math/geometry/triangles/triangle.js").TriangleIdentifiers;
-}, Record<string, string | boolean | string[]>> | Exercise<{
-    sideAsked: number;
-    givenSide: number;
-    givenAngle: number;
-    triangleIdentifiers: import("./math/geometry/triangles/triangle.js").TriangleIdentifiers;
-}, Record<string, string | boolean | string[]>> | Exercise<{
-    angleValue: number;
-    angleIdentifiers: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
-    point: string;
+    aIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    bIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
 }, Record<string, string | boolean | string[]>> | Exercise<{
+    pointIndex: number;
+}, {
+    solutionInterval: string;
+}> | Exercise<{
     trigFunction: string;
     trigValue: number;
     angleInDegrees: number;
@@ -3215,8 +3238,11 @@ declare const mathExercises: (Exercise<{
     degree: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     degree: number;
-    multipleOf2PiToAdd: number;
-    nodeIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    leftBoundPiMultiple: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    isCos: boolean;
+    value: number;
+    associateType: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     degree: number;
     radianNodeIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
@@ -3226,24 +3252,34 @@ declare const mathExercises: (Exercise<{
     thetaInDegree: number | undefined;
     thetaInRadNodeIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers | undefined;
     isThetaInDegree: boolean;
-}, Record<string, string | boolean | string[]>> | Exercise<{
-    degree: number;
-    leftBoundPiMultiple: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     givenValue: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
     isCosGiven: boolean;
 }, Record<string, string | boolean | string[]>> | Exercise<{
-    nameTrigoFunc: string;
+    randAngle: number;
+    randTrigo: number;
+    triangleIdentifiers: import("./math/geometry/triangles/triangle.js").TriangleIdentifiers;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    randAngle: number;
+    hiddenSide: number;
+    triangleIdentifiers: import("./math/geometry/triangles/triangle.js").TriangleIdentifiers;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    sideAsked: number;
+    givenSide: number;
+    givenAngle: number;
+    triangleIdentifiers: import("./math/geometry/triangles/triangle.js").TriangleIdentifiers;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    sideType: string;
     indexPoint: number;
     triangleIdentifiers: import("./math/geometry/triangles/triangle.js").TriangleIdentifiers;
 }, {
-    acceptedInputType: string;
+    sideTypes: string[];
 }> | Exercise<{
-    sideType: string;
+    nameTrigoFunc: string;
     indexPoint: number;
     triangleIdentifiers: import("./math/geometry/triangles/triangle.js").TriangleIdentifiers;
 }, {
-    sideTypes: string[];
+    acceptedInputType: string;
 }> | Exercise<{
     questionType: "frac" | "func";
     targetType: string;

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,KAAK,aAAa,MAAM,2BAA2B,CAAC;AAE3D,OAAO,4BAA4B,CAAC;AACpC,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAE,cAAc,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,KAAK,aAAa,MAAM,2BAA2B,CAAC;AAE3D,OAAO,4BAA4B,CAAC;AACpC,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAE,cAAc,EAAE,CAAC"}

package/lib/math/geometry/segment.d.ts

@@ -30,7 +30,7 @@ export declare class Segment {
     toIdentifiers(): SegmentIdentifiers;
     getMidpoint(): Point;
     getLength(): number;
-    getLengthNode(): AlgebraicNode;
+    getLengthNode(): AlgebraicNode | import("../../tree/nodes/operators/multiplyNode.js").MultiplyNode | import("../../tree/nodes/functions/sqrtNode.js").SqrtNode;
     toTex(): string;
     toInsideName(): string;
     toLengthTex(): string;

package/lib/math/geometry/vector.d.ts

@@ -1,5 +1,6 @@
 import { AlgebraicNode } from "../../tree/nodes/algebraicNode.js";
 import { NodeIdentifiers } from "../../tree/nodes/nodeConstructor.js";
+import { AddNode } from "../../tree/nodes/operators/addNode.js";
 import { Point } from "./point.js";
 import { Segment } from "./segment.js";
 export declare abstract class VectorConstructor {
@@ -34,7 +35,7 @@ export declare class Vector {
     determinant(v: Vector): AlgebraicNode;
     times(k: AlgebraicNode, name?: string): Vector;
     opposite(): Vector;
-    scalarProduct(v: Vector): AlgebraicNode;
+    scalarProduct(v: Vector): AddNode;
     scalarProductNumber(v: Vector): number;
     toUnited(): Vector;
     toPrimeColinear(name?: string): Vector;

package/lib/math/geometry/vector.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vector.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/vector.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAGlE,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAoB7C,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAEvC,8BAAsB,iBAAiB;IACrC,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,GAAG,MAAM;IAOpD,MAAM,CAAC,aAAa,CAAC,MAAM,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,GAAG,MAAM;IAOvD,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,UAAQ,GAAG,MAAM;IAOtD,MAAM,CAAC,WAAW,CAAC,OAAO,EAAE,OAAO;IAGnC,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,iBAAiB;CAOtD;AAED,MAAM,MAAM,iBAAiB,GAAG;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,eAAe,CAAC;IACnB,CAAC,EAAE,eAAe,CAAC;CACpB,CAAC;AAEF,qBAAa,MAAM;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;gBACL,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE,aAAa;IAO5D,QAAQ;IAIR,KAAK,IAAI,MAAM;IAIf,aAAa,IAAI,iBAAiB;IAOlC,eAAe,IAAI,MAAM;IAMzB,QAAQ,IAAI,MAAM;IAIlB,oBAAoB,IAAI,MAAM;IAG9B,aAAa;IAGb,iBAAiB,IAAI,MAAM;IAM3B,UAAU,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO;IAK9B,sBAAsB,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO;IAI1C,kBAAkB,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO;IAItC,WAAW,CAAC,CAAC,EAAE,MAAM,GAAG,aAAa;IAIrC,KAAK,CAAC,CAAC,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,MAAM;IAOrC,QAAQ;IAGR,aAAa,CAAC,CAAC,EAAE,MAAM;IAIvB,mBAAmB,CAAC,CAAC,EAAE,MAAM;IAO7B,QAAQ;IAGR,eAAe,CAAC,IAAI,CAAC,EAAE,MAAM;IAwB7B,GAAG,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM;IAWtB,SAAS,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM;IAG5B,OAAO,IAAI,aAAa;IAUxB,WAAW,CAAC,UAAU,EAAE,KAAK,EAAE,IAAI,CAAC,EAAE,MAAM;IAO5C,MAAM,CAAC,CAAC,EAAE,MAAM;IAIhB,YAAY;IAMZ,YAAY;IAOZ,aAAa;IAIb,MAAM;IAGN,aAAa;IAKb,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM;CAqBnC"}
+{"version":3,"file":"vector.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/vector.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAGlE,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAK7C,OAAO,EAAE,OAAO,EAAO,MAAM,uCAAuC,CAAC;AAerE,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAEvC,8BAAsB,iBAAiB;IACrC,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,GAAG,MAAM;IAOpD,MAAM,CAAC,aAAa,CAAC,MAAM,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,GAAG,MAAM;IAOvD,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,UAAQ,GAAG,MAAM;IAOtD,MAAM,CAAC,WAAW,CAAC,OAAO,EAAE,OAAO;IAGnC,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,iBAAiB;CAOtD;AAED,MAAM,MAAM,iBAAiB,GAAG;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,eAAe,CAAC;IACnB,CAAC,EAAE,eAAe,CAAC;CACpB,CAAC;AAEF,qBAAa,MAAM;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;gBACL,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE,aAAa;IAO5D,QAAQ;IAIR,KAAK,IAAI,MAAM;IAIf,aAAa,IAAI,iBAAiB;IAOlC,eAAe,IAAI,MAAM;IAMzB,QAAQ,IAAI,MAAM;IAIlB,oBAAoB,IAAI,MAAM;IAG9B,aAAa;IAGb,iBAAiB,IAAI,MAAM;IAM3B,UAAU,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO;IAK9B,sBAAsB,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO;IAI1C,kBAAkB,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO;IAItC,WAAW,CAAC,CAAC,EAAE,MAAM,GAAG,aAAa;IAIrC,KAAK,CAAC,CAAC,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,MAAM;IAOrC,QAAQ;IAGR,aAAa,CAAC,CAAC,EAAE,MAAM;IAIvB,mBAAmB,CAAC,CAAC,EAAE,MAAM;IAO7B,QAAQ;IAGR,eAAe,CAAC,IAAI,CAAC,EAAE,MAAM;IAwB7B,GAAG,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM;IAWtB,SAAS,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM;IAG5B,OAAO,IAAI,aAAa;IAUxB,WAAW,CAAC,UAAU,EAAE,KAAK,EAAE,IAAI,CAAC,EAAE,MAAM;IAO5C,MAAM,CAAC,CAAC,EAAE,MAAM;IAIhB,YAAY;IAMZ,YAAY;IAOZ,aAAa;IAIb,MAAM;IAGN,aAAa;IAKb,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM;CAqBnC"}

package/lib/math/geometry/vector.js

@@ -93,7 +93,7 @@ export class Vector {
         return this.times((-1).toTree());
     }
     scalarProduct(v) {
-        return add(multiply(this.x, v.x), multiply(this.y, v.y)).simplify();
+        return add(multiply(this.x, v.x), multiply(this.y, v.y));
     }
     scalarProductNumber(v) {
         const xEv = this.x.evaluate();

package/lib/math/numbers/reals/real.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"real.d.ts","sourceRoot":"","sources":["../../../../src/math/numbers/reals/real.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAClE,OAAO,EAAE,QAAQ,EAAE,MAAM,wCAAwC,CAAC;AASlE,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAClD,8BAAsB,eAAe;IACnC,MAAM,CAAC,MAAM;CAUd;AACD,qBAAa,IAAK,YAAW,MAAM;IACjC,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,UAAU,CAAC;gBACL,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM;IAKtC,MAAM,CAAC,CAAC,EAAE,MAAM;IAGhB,MAAM,IAAI,aAAa;CAIxB;AAED,8BAAsB,qBAAqB;IACzC;;OAEG;IACH,MAAM,CAAC,kBAAkB,CAAC,EACxB,kBAA0B,EAC1B,SAAc,GACf;;;KAAA,GAAG,UAAU;IAed,MAAM,CAAC,kBAAkB,CAAC,GAAG,GAAE,MAAW,GAAG,UAAU;CAIxD;AAED,qBAAa,UAAW,SAAQ,IAAI;IAClC,OAAO,EAAE,MAAM,CAAC;gBACJ,OAAO,EAAE,MAAM;IAK3B,cAAc;IAMd,mBAAmB,IAAI,CAAC,MAAM,EAAE,MAAM,CAAC;IAkBvC,sDAAsD;IACtD,aAAa,IAAI,MAAM;IAMvB,QAAQ,IAAI,MAAM;IA+BlB,KAAK,IAAI,MAAM;IAIf,MAAM;CAGP"}
+{"version":3,"file":"real.d.ts","sourceRoot":"","sources":["../../../../src/math/numbers/reals/real.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAClE,OAAO,EAAE,QAAQ,EAAE,MAAM,wCAAwC,CAAC;AASlE,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAClD,8BAAsB,eAAe;IACnC,MAAM,CAAC,MAAM;CAUd;AACD,qBAAa,IAAK,YAAW,MAAM;IACjC,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,UAAU,CAAC;gBACL,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM;IAKtC,MAAM,CAAC,CAAC,EAAE,MAAM;IAGhB,MAAM,IAAI,aAAa;CAIxB;AAED,8BAAsB,qBAAqB;IACzC;;OAEG;IACH,MAAM,CAAC,kBAAkB,CAAC,EACxB,kBAA0B,EAC1B,SAAc,GACf;;;KAAA,GAAG,UAAU;IAed,MAAM,CAAC,kBAAkB,CAAC,GAAG,GAAE,MAAW,GAAG,UAAU;CAIxD;AAED,qBAAa,UAAW,SAAQ,IAAI;IAClC,OAAO,EAAE,MAAM,CAAC;gBACJ,OAAO,EAAE,MAAM;IAK3B,cAAc;IAOd,mBAAmB,IAAI,CAAC,MAAM,EAAE,MAAM,CAAC;IAkBvC,sDAAsD;IACtD,aAAa,IAAI,MAAM;IAMvB,QAAQ,IAAI,MAAM;IA+BlB,KAAK,IAAI,MAAM;IAIf,MAAM;CAGP"}

package/lib/math/numbers/reals/real.js

@@ -73,6 +73,8 @@ export class SquareRoot extends Real {
     isSimplifiable() {
         if (this.operand === 0 || this.operand === 1)
             return true;
+        if (Math.floor(this.operand) !== this.operand)
+            return false;
         const [a] = this.getSimplifiedCoeffs();
         return a !== 1;
     }