math-exercises 3.0.201 → 3.0.202

package/lib/exercises/math/spaceGeometry/planes/index.d.ts

@@ -2,5 +2,6 @@ export * from "./checkIsPointBelongingToPlane.js";
 export * from "./planeEquationFromNormalVectorAndContainedPoint.js";
 export * from "./findNormalVectorFromPlaneEquation.js";
 export * from "./planeEquationFromOrthogonalLineAndContainedPoint.js";
+export * from "./findNormalVectorFromPlanePointsCoords.js";
 export * from "./planePlaneRelativePositions.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/spaceGeometry/planes/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/planes/index.ts"],"names":[],"mappings":"AAAA,cAAc,mCAAmC,CAAC;AAClD,cAAc,qDAAqD,CAAC;AACpE,cAAc,wCAAwC,CAAC;AACvD,cAAc,uDAAuD,CAAC;AAEtE,cAAc,kCAAkC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/planes/index.ts"],"names":[],"mappings":"AAAA,cAAc,mCAAmC,CAAC;AAClD,cAAc,qDAAqD,CAAC;AACpE,cAAc,wCAAwC,CAAC;AACvD,cAAc,uDAAuD,CAAC;AACtE,cAAc,4CAA4C,CAAC;AAC3D,cAAc,kCAAkC,CAAC"}

package/lib/exercises/math/spaceGeometry/planes/index.js

@@ -2,5 +2,5 @@ export * from "./checkIsPointBelongingToPlane.js";
 export * from "./planeEquationFromNormalVectorAndContainedPoint.js";
 export * from "./findNormalVectorFromPlaneEquation.js";
 export * from "./planeEquationFromOrthogonalLineAndContainedPoint.js";
-// export * from "./findNormalVectorFromPlanePointsCoords.js";
+export * from "./findNormalVectorFromPlanePointsCoords.js";
 export * from "./planePlaneRelativePositions.js";

package/lib/exercises/math/spaceGeometry/planes/planePlaneRelativePositions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"planePlaneRelativePositions.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/planes/planePlaneRelativePositions.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EAGL,qBAAqB,EACtB,MAAM,mCAAmC,CAAC;AAC3C,OAAO,EAGL,sBAAsB,EACvB,MAAM,oCAAoC,CAAC;AAS5C,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAkH7C,KAAK,QAAQ,GAAG;IACd,sBAAsB,EAAE,qBAAqB,CAAC;IAC9C,oBAAoB,EAAE,sBAAsB,CAAC;IAC7C,oBAAoB,EAAE,eAAe,CAAC;IACtC,kBAAkB,EAAE,MAAM,CAAC;IAC3B,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,QAAQ,CAAC;IAChB,KAAK,EAAE,QAAQ,CAAC;CACjB,CAAC;AAsiBF,KAAK,OAAO,GAAG;IACb,iBAAiB,EAAE,MAAM,CAAC;IAC1B,iBAAiB,EAAE,MAAM,CAAC;CAC3B,CAAC;AA8BF,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAoBtE,CAAC"}
+{"version":3,"file":"planePlaneRelativePositions.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/planes/planePlaneRelativePositions.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EAGL,qBAAqB,EACtB,MAAM,mCAAmC,CAAC;AAC3C,OAAO,EAGL,sBAAsB,EACvB,MAAM,oCAAoC,CAAC;AAS5C,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAkH7C,KAAK,QAAQ,GAAG;IACd,sBAAsB,EAAE,qBAAqB,CAAC;IAC9C,oBAAoB,EAAE,sBAAsB,CAAC;IAC7C,oBAAoB,EAAE,eAAe,CAAC;IACtC,kBAAkB,EAAE,MAAM,CAAC;IAC3B,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,QAAQ,CAAC;IAChB,KAAK,EAAE,QAAQ,CAAC;CACjB,CAAC;AA4hBF,KAAK,OAAO,GAAG;IACb,iBAAiB,EAAE,MAAM,CAAC;IAC1B,iBAAiB,EAAE,MAAM,CAAC;CAC3B,CAAC;AA8BF,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAoBtE,CAAC"}

package/lib/exercises/math/spaceGeometry/planes/planePlaneRelativePositions.js

@@ -327,35 +327,21 @@ const getPropositions = (_n, { answer }) => {
 };
 const createRandomIdentifiers = (opts) => {
     const { typeDataForPlane1, typeDataForPlane2 } = opts;
-    const funcRand1 = () => randint(-3, 4, coinFlip() ? [0] : []).toTree();
-    const funcRand2 = () => randint(-6, 7, coinFlip() ? [0] : []).toTree();
-    const funcRand3 = () => randint(-9, 10, coinFlip() ? [0] : []).toTree();
-    function createRandomOrthogonalVector(vecSrc) {
-        const [nodeX, nodeY, nodeZ] = [vecSrc.x, vecSrc.y, vecSrc.z];
-        const nodeZero = (0).toTree();
-        const vec1 = new SpaceVector("v1", opposite(nodeY), nodeX, nodeZero);
-        const vec2 = new SpaceVector("v2", nodeZero, opposite(nodeZ), nodeY);
-        const vec3 = new SpaceVector("v3", opposite(nodeZ), nodeZero, nodeX);
-        const [factor1, factor2, factor3] = shuffle(random([
-            [coinFlip(), false, false],
-            [coinFlip(), coinFlip(), false],
-        ])).map((isCanBeZero) => randint(-3, 4, isCanBeZero ? [] : [0]).toTree());
-        return vec1
-            .times(factor1)
-            .add(vec2.times(factor2))
-            .add(vec3.times(factor3));
-    }
+    const funcRand1 = (isCanBeZero) => randint(-3, 4, isCanBeZero ? [] : [0]).toTree();
+    const funcRand2 = (isCanBeZero) => randint(-6, 7, isCanBeZero ? [] : [0]).toTree();
+    const funcRand3 = (isCanBeZero) => randint(-9, 10, isCanBeZero ? [] : [0]).toTree();
     //create vecR, vecS, vecT (base)
     const vecR = (() => {
-        const [funcRandX, funcRandY, funcRandZ] = shuffle([
-            funcRand1,
-            funcRand2,
-            funcRand3,
-        ]);
-        return new SpaceVector("r", funcRandX(), funcRandY(), funcRandZ());
+        const arrIsCanBeZero = shuffle(random([
+            [coinFlip(), false, false],
+            [coinFlip(), coinFlip(), false],
+        ]));
+        const arrFuncRand = shuffle([funcRand1, funcRand2, funcRand3]);
+        const [nodeX, nodeY, nodeZ] = zip(arrIsCanBeZero, arrFuncRand).map(([isCanBeZero, funcRand]) => funcRand(isCanBeZero));
+        return new SpaceVector("r", nodeX, nodeY, nodeZ);
     })();
     const vecS = (() => {
-        const vecRaw = createRandomOrthogonalVector(vecR);
+        const vecRaw = vecR.getRandomOrthogonalVectorNonZero();
         return new SpaceVector("s", vecRaw.x, vecRaw.y, vecRaw.z);
     })();
     const [vecU, vecV] = (() => {

package/lib/exercises/math/spaceGeometry/scalarProduct/angleFromScalarProductFromSpacePointCoords.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"angleFromScalarProductFromSpacePointCoords.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/scalarProduct/angleFromScalarProductFromSpacePointCoords.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EAGL,qBAAqB,EACtB,MAAM,mCAAmC,CAAC;AAiD3C,KAAK,WAAW,GAAG;IACjB,aAAa,EAAE,qBAAqB,EAAE,CAAC;CACxC,CAAC;AA+QF,eAAO,MAAM,0CAA0C,EAAE,QAAQ,CAAC,WAAW,CAoB1E,CAAC"}
+{"version":3,"file":"angleFromScalarProductFromSpacePointCoords.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/scalarProduct/angleFromScalarProductFromSpacePointCoords.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EAGL,qBAAqB,EACtB,MAAM,mCAAmC,CAAC;AAmD3C,KAAK,WAAW,GAAG;IACjB,aAAa,EAAE,qBAAqB,EAAE,CAAC;CACxC,CAAC;AAuSF,eAAO,MAAM,0CAA0C,EAAE,QAAQ,CAAC,WAAW,CAoB1E,CAAC"}

package/lib/exercises/math/spaceGeometry/scalarProduct/angleFromScalarProductFromSpacePointCoords.js

@@ -15,6 +15,8 @@ import { square } from "../../../../tree/nodes/operators/powerNode.js";
 import { substract } from "../../../../tree/nodes/operators/substractNode.js";
 import { VariableNode } from "../../../../tree/nodes/variables/variableNode.js";
 import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { random } from "../../../../utils/alea/random.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
 import { zip } from "../../../../utils/arrays/arrayZip.js";
 import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
 import { alignTex } from "../../../../utils/latex/alignTex.js";
@@ -176,13 +178,31 @@ const isAnswerValid = (ans, { answer }) => {
     }
 };
 const createRandomIdentifiers = () => {
-    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"], [
+    const funcRand1 = (isCanBeZero) => randint(-3, 4, isCanBeZero ? [] : [0]).toTree();
+    const funcRand2 = (isCanBeZero) => randint(-6, 7, isCanBeZero ? [] : [0]).toTree();
+    const funcRand3 = (isCanBeZero) => randint(-9, 10, isCanBeZero ? [] : [0]).toTree();
+    const [vec1, vec2] = zip(["u", "v"], [
         [funcRand1, funcRand2, funcRand3],
         [funcRand3, funcRand2, funcRand1],
-    ]).map(([name, [funcRandX, funcRandY, funcRandZ]]) => new SpaceVector(name, funcRandX(), funcRandY(), funcRandZ()));
+    ]).map(([name, arrFuncRand]) => {
+        const arrIsCanBeZero = shuffle(random([
+            [coinFlip(), false, false],
+            [coinFlip(), coinFlip(), false],
+        ]));
+        const [nodeX, nodeY, nodeZ] = zip(arrIsCanBeZero, arrFuncRand).map(([isCanBeZero, funcRand]) => funcRand(isCanBeZero));
+        return new SpaceVector(name, nodeX, nodeY, nodeZ);
+    });
+    const vecU = vec1;
+    const vecV = (() => {
+        const isVec2EqualsVec1 = vec2.equals(vec1);
+        if (isVec2EqualsVec1) {
+            const vec1Orth = vec1.getRandomOrthogonalVectorNonZero();
+            return vec2.add(vec1Orth);
+        }
+        else {
+            return vec2;
+        }
+    })();
     const A = new SpacePoint("A", randint(-5, 6).toTree(), randint(-5, 6).toTree(), randint(-5, 6).toTree());
     const [B, C] = [
         ["B", vecU],

package/lib/exercises/math/spaceGeometry/scalarProduct/index.d.ts

@@ -1,5 +1,6 @@
 export * from "./scalarProductFromCubeOuterPoints.js";
 export * from "./scalarProductFromSpacePointCoords.js";
+export * from "./angleFromScalarProductFromSpacePointCoords.js";
 export * from "./checkIsOrthogonalSpaceVecsFromCoords.js";
 export * from "./checkIsSpaceVecOrthogonalToPlaneFromCoords.js";
 export * from "./checkIsOrthogonalLinesFromParametricReps.js";

package/lib/exercises/math/spaceGeometry/scalarProduct/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/scalarProduct/index.ts"],"names":[],"mappings":"AAAA,cAAc,uCAAuC,CAAC;AACtD,cAAc,wCAAwC,CAAC;AAEvD,cAAc,2CAA2C,CAAC;AAC1D,cAAc,iDAAiD,CAAC;AAChE,cAAc,+CAA+C,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/scalarProduct/index.ts"],"names":[],"mappings":"AAAA,cAAc,uCAAuC,CAAC;AACtD,cAAc,wCAAwC,CAAC;AACvD,cAAc,iDAAiD,CAAC;AAChE,cAAc,2CAA2C,CAAC;AAC1D,cAAc,iDAAiD,CAAC;AAChE,cAAc,+CAA+C,CAAC"}

package/lib/exercises/math/spaceGeometry/scalarProduct/index.js

@@ -1,6 +1,6 @@
 export * from "./scalarProductFromCubeOuterPoints.js";
 export * from "./scalarProductFromSpacePointCoords.js";
-// export * from "./angleFromScalarProductFromSpacePointCoords.js";
+export * from "./angleFromScalarProductFromSpacePointCoords.js";
 export * from "./checkIsOrthogonalSpaceVecsFromCoords.js";
 export * from "./checkIsSpaceVecOrthogonalToPlaneFromCoords.js";
 export * from "./checkIsOrthogonalLinesFromParametricReps.js";

package/lib/exercises/math/spaceGeometry/vectors/findLinearDecompositionWrtCoplanarUVFromCoords.js

@@ -69,8 +69,8 @@ $$
 \\overrightarrow{w} = a \\overrightarrow{u} + b \\overrightarrow{v}
 $$
 
-Cela donne un système de $2$ équations: une pour chaque composante du vecteur \\overrightarrow{w}.
-Résout ce système, autrement dit détermine $a$ et $b$.
+Cela donne un système de $2$ équations: une pour chaque composante du vecteur $\\overrightarrow{w}$.
+Résous ce système, autrement dit détermine $a$ et $b$.
 
 Les coordonnées de $\\overrightarrow{w}$ dans la base $(\\overrightarrow{u};\\overrightarrow{v})$.`;
 };

package/lib/exercises/math/trigonometry/functions/equationCosOnRandomInterval.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"equationCosOnRandomInterval.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/trigonometry/functions/equationCosOnRandomInterval.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAmBrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,mBAAmB,EAAE,MAAM,CAAC;CAC7B,CAAC;AAkIF,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,WAAW,CAc7D,CAAC"}
+{"version":3,"file":"equationCosOnRandomInterval.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/trigonometry/functions/equationCosOnRandomInterval.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAsBrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,mBAAmB,EAAE,MAAM,CAAC;CAC7B,CAAC;AA+OF,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,WAAW,CAe7D,CAAC"}

package/lib/exercises/math/trigonometry/functions/equationCosOnRandomInterval.js

@@ -6,7 +6,7 @@ import { EquationSolutionNode } from "../../../../tree/nodes/equations/equationS
 import { CosNode } from "../../../../tree/nodes/functions/cosNode.js";
 import { PiNode } from "../../../../tree/nodes/numbers/piNode.js";
 import { AddNode } from "../../../../tree/nodes/operators/addNode.js";
-import { MultiplyNode } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { multiply, MultiplyNode, } from "../../../../tree/nodes/operators/multiplyNode.js";
 import { ClosureType } from "../../../../tree/nodes/sets/closure.js";
 import { DiscreteSetNode } from "../../../../tree/nodes/sets/discreteSetNode.js";
 import { IntervalNode } from "../../../../tree/nodes/sets/intervalNode.js";
@@ -16,7 +16,10 @@ const getPropositions = (n, { answer, degree, leftBoundPiMultiple }) => {
     addValidProp(propositions, answer);
     //distracteur avec une solution manquante
     if (degree !== 0 && degree !== 180) {
-        const answerNode = getAnswerNode({ degree, leftBoundPiMultiple });
+        const answerNode = getAnswerStuff({
+            degree,
+            leftBoundPiMultiple,
+        }).nodeEquationSolution;
         const newSet = answerNode.solutionsSet.toDeleteRandomElement();
         tryToAddWrongProp(propositions, new EquationSolutionNode(newSet).toTex());
     }
@@ -27,7 +30,7 @@ const getPropositions = (n, { answer, degree, leftBoundPiMultiple }) => {
     });
     return shuffleProps(propositions, n);
 };
-const getAnswerNode = (identifiers) => {
+const getAnswerStuff = (identifiers) => {
     const coeff = identifiers.leftBoundPiMultiple;
     /**
      * Si l'intervalle est centré autour d'un multiple de 2pi (coeff impair) (genre ]3pi, 5pi]) on ajoute (coeff+1)/2 tours
@@ -38,20 +41,82 @@ const getAnswerNode = (identifiers) => {
         .find((v) => v.degree === identifiers.degree)
         .cos.evaluate({});
     const values = (Math.abs(coeff % 2) === 1 ? mainTrigoValues : trigoValuesOnZeroTwoPIOF).filter((v) => v.cos.evaluate({}) === cos);
-    if (values.length === 1) {
-        const value = values[0];
-        const newValue = new AddNode(value.angle, new MultiplyNode((turnsToAdd * 2).toTree(), PiNode)).simplify();
-        return new EquationSolutionNode(new DiscreteSetNode([newValue]));
-    }
-    else {
-        const newValues = values.map((v) => {
-            return new AddNode(v.angle, new MultiplyNode((turnsToAdd * 2).toTree(), PiNode)).simplify();
-        });
-        return new EquationSolutionNode(new DiscreteSetNode(newValues.sort((a, b) => a.evaluate({}) - b.evaluate({}))));
-    }
+    const [nodeEquationSolutionOn02Pi, nodeEquationSolution] = (() => {
+        if (values.length === 1) {
+            const value = values[0];
+            const newValue = new AddNode(value.angle, new MultiplyNode((turnsToAdd * 2).toTree(), PiNode)).simplify();
+            return [
+                new EquationSolutionNode(new DiscreteSetNode([value.angle])),
+                new EquationSolutionNode(new DiscreteSetNode([newValue])),
+            ];
+        }
+        else {
+            const newValues = values.map((v) => {
+                return new AddNode(v.angle, new MultiplyNode((turnsToAdd * 2).toTree(), PiNode)).simplify();
+            });
+            return [
+                new EquationSolutionNode(new DiscreteSetNode(values.map((value) => value.angle))),
+                new EquationSolutionNode(new DiscreteSetNode(newValues.sort((a, b) => a.evaluate({}) - b.evaluate({})))),
+            ];
+        }
+    })();
+    return {
+        nodeEquationSolutionOn02Pi,
+        nodeEquationSolution,
+        turnsToAdd,
+    };
 };
 const getAnswer = (identifiers) => {
-    return getAnswerNode(identifiers).toTex();
+    return getAnswerStuff(identifiers).nodeEquationSolution.toTex();
+};
+const getHint = (identifiers) => {
+    const { leftBoundPiMultiple } = identifiers;
+    const interval02Pi = new IntervalNode(multiply(0, PiNode).simplify(), multiply(2, PiNode).simplify(), ClosureType.OF);
+    const intervalMinusPiPi = new IntervalNode(multiply(-1, PiNode).simplify(), multiply(+1, PiNode).simplify(), ClosureType.OF);
+    const intervalEasier = leftBoundPiMultiple % 2 === 0 ? interval02Pi : intervalMinusPiPi;
+    return `Commence par résoudre l'équation sur $${intervalEasier.toTex()}$.
+
+Ensuite, puisque la fonction $\\cos$ est $${multiply(2, PiNode).toTex()}$-périodique, ajoute ou ôte $${multiply(2, PiNode).toTex()}$ à tes solutions autant de fois que nécessaire jusqu'à être dans l'intervalle de l'énoncé.`;
+};
+const getCorrection = (identifiers) => {
+    const { degree, leftBoundPiMultiple } = identifiers;
+    const value = mainPositiveTrigovalues.find((v) => v.degree === degree);
+    const offsetFactor2Pi = Math.ceil(leftBoundPiMultiple / 2);
+    const interval02Pi = new IntervalNode(multiply(0, PiNode).simplify(), multiply(2, PiNode).simplify(), ClosureType.OF);
+    const intervalMinusPiPi = new IntervalNode(multiply(-1, PiNode).simplify(), multiply(+1, PiNode).simplify(), ClosureType.OF);
+    const intervalEasier = leftBoundPiMultiple % 2 === 0 ? interval02Pi : intervalMinusPiPi;
+    const leftBound = new MultiplyNode(leftBoundPiMultiple.toTree(), PiNode).simplify();
+    const rightBound = new MultiplyNode((leftBoundPiMultiple + 2).toTree(), PiNode).simplify();
+    const interval = new IntervalNode(leftBound, rightBound, ClosureType.OF);
+    const { nodeEquationSolutionOn02Pi, nodeEquationSolution } = getAnswerStuff(identifiers);
+    return `Sur l'intervalle $${intervalEasier.toTex()}$, la solution de 
+  
+$$
+${new CosNode("x".toTree()).toTex()}=${value.cos.toTex()}
+$$
+
+est : 
+
+$$
+${nodeEquationSolutionOn02Pi.toTex()}
+$$
+
+${(() => {
+        if (intervalEasier.toTex() !== interval.toTex()) {
+            return `Pour avoir la solution sur l'intervalle $${interval.toTex()}$, on ajoute $${offsetFactor2Pi.frenchify()}$ fois $${multiply(2, PiNode).toTex()}$.
+
+La solution est donc : 
+
+$$
+${nodeEquationSolution.toTex()}
+$$
+
+`;
+        }
+        else {
+            return ``;
+        }
+    })()}`;
 };
 const getInstruction = ({ degree, leftBoundPiMultiple, }) => {
     const value = mainPositiveTrigovalues.find((v) => v.degree === degree);
@@ -64,17 +129,14 @@ $$
 ${new CosNode("x".toTree()).toTex()}=${value.cos.toTex()}
 $$`;
 };
-// const getHint: GetHint<Identifiers> = (identifiers) => {
-//   return "";
-// };
-// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {
-//   return "";
-// };
 const getKeys = () => {
     return ["x", "S", "equal", "lbrace", "semicolon", "rbrace", "pi"];
 };
 const isAnswerValid = (ans, { degree, leftBoundPiMultiple }) => {
-    const answerNode = getAnswerNode({ degree, leftBoundPiMultiple });
+    const answerNode = getAnswerStuff({
+        degree,
+        leftBoundPiMultiple,
+    }).nodeEquationSolution;
     return answerNode.toAllValidTexs().includes(ans);
 };
 const getEquationCosOnRandomIntervalQuestion = () => {
@@ -91,8 +153,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
         keys: getKeys(identifiers),
         answerFormat: "tex",
         identifiers,
-        // hint: getHint(identifiers),
-        // correction: getCorrection(identifiers),
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -108,4 +170,5 @@ export const equationCosOnRandomInterval = {
     isAnswerValid,
     subject: "Mathématiques",
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

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

@@ -18,7 +18,7 @@ export * from "../math/functions/affines/affineExpressionReading.js";
 export * from "../math/geometry/thales/thales.js";
 export * from "../math/geometry/thales/thalesCalcul.js";
 export * from "../math/equaDiff/equaDiffCheckSolutionFirstOrder.js";
-export * from "../math/equaDiff/equaDiffGeneralForme.js";
+export * from "../math/equaDiff/exponentialDifferentialEquation.js";
 export * from "../math/equaDiff/exponentialDifferentialEquationWithIC.js";
 export * from "../math/derivation/tangent/derivativeNumberReading.js";
 export * from "../math/derivation/derivative/polynomial/usualderivative.js";

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,yDAAyD,CAAC;AACxE,cAAc,0DAA0D,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,qDAAqD,CAAC;AACpE,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

@@ -18,7 +18,7 @@ export * from "../math/functions/affines/affineExpressionReading.js";
 export * from "../math/geometry/thales/thales.js";
 export * from "../math/geometry/thales/thalesCalcul.js";
 export * from "../math/equaDiff/equaDiffCheckSolutionFirstOrder.js";
-export * from "../math/equaDiff/equaDiffGeneralForme.js";
+export * from "../math/equaDiff/exponentialDifferentialEquation.js";
 export * from "../math/equaDiff/exponentialDifferentialEquationWithIC.js";
 export * from "../math/derivation/tangent/derivativeNumberReading.js";
 export * from "../math/derivation/derivative/polynomial/usualderivative.js";

package/lib/index.d.ts

@@ -1005,6 +1005,11 @@ declare const mathExercises: (Exercise<{
 }, Record<string, string | boolean | string[]>> | Exercise<{
     nodeIdsU: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
     nodeIdsV: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    nodeIdsLambda: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    nodeIdsU: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    nodeIdsV: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    nodeIdsRewriteUsing: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     affineA: number;
     affineB: number;
@@ -1130,6 +1135,10 @@ declare const mathExercises: (Exercise<{
     x: number;
     k: number;
     nodeIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    nodeIdsSlope: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    nodeIdsF: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    nodeIdsAbscissa: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
 }, Record<string, string | boolean | string[]>> | Exercise<{
     pofIds: import("./math/utils/polynomial/polynomialInterpolationUtils.js").PointOfFunctionIdentifiers[];
     cubicSplineIds: {
@@ -1197,6 +1206,11 @@ declare const mathExercises: (Exercise<{
     coeffsF: number[];
 }, {
     typeF: string;
+}> | Exercise<{
+    coeffsF: number[];
+    isFOverExp: boolean;
+}, {
+    typeF: string;
 }> | Exercise<{
     nodeIdsF: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
     typeF: string;
@@ -1261,6 +1275,13 @@ declare const mathExercises: (Exercise<{
 }, Record<string, string | boolean | string[]>> | Exercise<{
     nodeIdsF: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
 }, Record<string, string | boolean | string[]>> | Exercise<{
+    nodeIdsF: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    pofIds: import("./math/utils/polynomial/polynomialInterpolationUtils.js").PointOfFunctionIdentifiers[];
+    boundPHigh: number;
+    typeF: string;
+}, {
+    typeF: string;
+}> | Exercise<{
     nodeIdsF: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
     nodeIdsValueFunction: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
     typeF: string;
@@ -4297,6 +4318,9 @@ declare const mathExercises: (Exercise<{
 }, {
     typeDataForParallelLine: string;
 }> | Exercise<{
+    spacePointIdsPlanePoints: import("./math/geometry/spacePoint.js").SpacePointIdentifiers[];
+    spaceVectorIdsProposed: import("./math/geometry/spaceVector.js").SpaceVectorIdentifiers[];
+}, Record<string, string | boolean | string[]>> | Exercise<{
     idsP1: {
         spacePointIdsContained: import("./math/geometry/spacePoint.js").SpacePointIdentifiers;
         spaceVectorIdsNormal: import("./math/geometry/spaceVector.js").SpaceVectorIdentifiers;
@@ -4406,6 +4430,8 @@ declare const mathExercises: (Exercise<{
     isIncludeMidpoints: boolean;
 }> | Exercise<{
     spacePointIds: import("./math/geometry/spacePoint.js").SpacePointIdentifiers[];
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    spacePointIds: import("./math/geometry/spacePoint.js").SpacePointIdentifiers[];
 }, Record<string, string | boolean | string[]>> | Exercise<{
     spacePointIdsForVecs: import("./math/geometry/spacePoint.js").SpacePointIdentifiers[];
 }, Record<string, string | boolean | string[]>> | Exercise<{
@@ -4415,6 +4441,18 @@ declare const mathExercises: (Exercise<{
     spacePointIdsForAB: import("./math/geometry/spacePoint.js").SpacePointIdentifiers[];
     spacePointIdsForUV: import("./math/geometry/spacePoint.js").SpacePointIdentifiers[];
 }, Record<string, string | boolean | string[]>> | Exercise<{
+    idsP: {
+        spacePointIdsContained: import("./math/geometry/spacePoint.js").SpacePointIdentifiers;
+        spaceVectorIdsNormal: import("./math/geometry/spaceVector.js").SpaceVectorIdentifiers;
+        nodeIdsPlaneEquation: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+        typeDefinitionData: string;
+        texName: string;
+    };
+    spacePointIdsA: import("./math/geometry/spacePoint.js").SpacePointIdentifiers;
+    spacePointIdsProposed: import("./math/geometry/spacePoint.js").SpacePointIdentifiers[];
+}, {
+    typeDataForPlane: string;
+}> | Exercise<{
     spacePointIds: import("./math/geometry/spacePoint.js").SpacePointIdentifiers;
     spaceVectorIds: import("./math/geometry/spaceVector.js").SpaceVectorIdentifiers;
     randInstr: number;
@@ -4976,6 +5014,15 @@ declare const mathExercises: (Exercise<{
 }, Record<string, string | boolean | string[]>> | Exercise<{
     cloudPointsIdentifiers: import("./math/geometry/CloudPoints.js").CloudPointsIdentifiers;
     evolutionType: string;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    pointIds: import("./math/geometry/point.js").PointIdentifiers[];
+    strGroupBy: string;
+    isTransposed: boolean;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    pointIds: import("./math/geometry/point.js").PointIdentifiers[];
+    strGroupBy: string;
+    isTransposed: boolean;
+    nodeIdsDataClasses: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
 }, Record<string, string | boolean | string[]>> | Exercise<{
     pointIds: import("./math/geometry/point.js").PointIdentifiers[];
     strGroupBy: string;
@@ -5532,6 +5579,14 @@ declare const mathExercises: (Exercise<{
 }, {
     typeSignBoundLow: string;
     typeSignBoundHigh: string;
+}> | Exercise<{
+    nodeIdsF: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    nodeIdsG: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    nodeIdsBounds: [import("./tree/nodes/nodeConstructor.js").NodeIdentifiers, import("./tree/nodes/nodeConstructor.js").NodeIdentifiers];
+}, {
+    typeCrossingCurves: string;
+    typeSignBoundLow: string;
+    typeSignBoundHigh: string;
 }> | Exercise<{
     nodeIdsF: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
     nodeIdsBounds: [import("./tree/nodes/nodeConstructor.js").NodeIdentifiers, import("./tree/nodes/nodeConstructor.js").NodeIdentifiers];

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAA+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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAA+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/spaceVector.d.ts

@@ -39,5 +39,7 @@ export declare class SpaceVector {
     getNorm(): AlgebraicNode;
     getEndPoint(startPoint: SpacePoint, name?: string): SpacePoint;
     equals(v: SpaceVector): boolean;
+    static createRandomOrthogonalVector(vecSrc: SpaceVector): SpaceVector;
+    getRandomOrthogonalVectorNonZero(): SpaceVector;
 }
 //# sourceMappingURL=spaceVector.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"spaceVector.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/spaceVector.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAElE,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAW7C,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAE7C,MAAM,MAAM,sBAAsB,GAAG;IACnC,EAAE,EAAE,aAAa,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,eAAe,CAAC;IACnB,CAAC,EAAE,eAAe,CAAC;IACnB,CAAC,EAAE,eAAe,CAAC;CACpB,CAAC;AAEF,8BAAsB,sBAAsB;IAC1C,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,sBAAsB;IAS1D,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,UAAU,EAAE,GAAG,EAAE,UAAU,GAAG,WAAW;IAQnE,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,UAAQ,GAAG,WAAW;IAe3D,MAAM,CAAC,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,SAAS,UAAQ,GAAG,WAAW,EAAE;IAc1E,MAAM,CAAC,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE,IAAI,CAAC,EAAE,MAAM;CAWhD;AAED,qBAAa,WAAW;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;gBAEf,IAAI,EAAE,MAAM,EACZ,CAAC,EAAE,aAAa,EAChB,CAAC,EAAE,aAAa,EAChB,CAAC,EAAE,aAAa;IASlB,aAAa,IAAI,sBAAsB;IAUvC,SAAS;IAGT,kBAAkB;IAGlB,KAAK,IAAI,MAAM;IAIf,WAAW,IAAI,MAAM;IAGrB,iBAAiB,IAAI,MAAM;IAK3B,eAAe,IAAI,MAAM;IAMzB,eAAe,CAAC,CAAC,EAAE,WAAW,GAAG,WAAW;IAiB5C,UAAU,CAAC,CAAC,EAAE,WAAW,GAAG,OAAO;IAMnC,UAAU,IAAI,OAAO;IAGrB,WAAW,IAAI,aAAa;IAI5B,KAAK,CAAC,CAAC,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,MAAM;IAQrC,aAAa,CAAC,EAAE,EAAE,WAAW,GAAG,aAAa;IAQ7C,GAAG,CAAC,CAAC,EAAE,WAAW,GAAG,WAAW;IAShC,OAAO,IAAI,aAAa;IAYxB,WAAW,CAAC,UAAU,EAAE,UAAU,EAAE,IAAI,CAAC,EAAE,MAAM;IAQjD,MAAM,CAAC,CAAC,EAAE,WAAW;CAGtB"}
+{"version":3,"file":"spaceVector.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/spaceVector.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAGlE,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAe7C,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAE7C,MAAM,MAAM,sBAAsB,GAAG;IACnC,EAAE,EAAE,aAAa,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,eAAe,CAAC;IACnB,CAAC,EAAE,eAAe,CAAC;IACnB,CAAC,EAAE,eAAe,CAAC;CACpB,CAAC;AAEF,8BAAsB,sBAAsB;IAC1C,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,sBAAsB;IAS1D,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,UAAU,EAAE,GAAG,EAAE,UAAU,GAAG,WAAW;IAQnE,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,UAAQ,GAAG,WAAW;IAe3D,MAAM,CAAC,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,SAAS,UAAQ,GAAG,WAAW,EAAE;IAc1E,MAAM,CAAC,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE,IAAI,CAAC,EAAE,MAAM;CAWhD;AAED,qBAAa,WAAW;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;gBAEf,IAAI,EAAE,MAAM,EACZ,CAAC,EAAE,aAAa,EAChB,CAAC,EAAE,aAAa,EAChB,CAAC,EAAE,aAAa;IASlB,aAAa,IAAI,sBAAsB;IAUvC,SAAS;IAGT,kBAAkB;IAGlB,KAAK,IAAI,MAAM;IAIf,WAAW,IAAI,MAAM;IAGrB,iBAAiB,IAAI,MAAM;IAK3B,eAAe,IAAI,MAAM;IAMzB,eAAe,CAAC,CAAC,EAAE,WAAW,GAAG,WAAW;IAiB5C,UAAU,CAAC,CAAC,EAAE,WAAW,GAAG,OAAO;IAMnC,UAAU,IAAI,OAAO;IAGrB,WAAW,IAAI,aAAa;IAI5B,KAAK,CAAC,CAAC,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,MAAM;IAQrC,aAAa,CAAC,EAAE,EAAE,WAAW,GAAG,aAAa;IAQ7C,GAAG,CAAC,CAAC,EAAE,WAAW,GAAG,WAAW;IAShC,OAAO,IAAI,aAAa;IAYxB,WAAW,CAAC,UAAU,EAAE,UAAU,EAAE,IAAI,CAAC,EAAE,MAAM;IAQjD,MAAM,CAAC,CAAC,EAAE,WAAW;IAIrB,MAAM,CAAC,4BAA4B,CAAC,MAAM,EAAE,WAAW;IA+BvD,gCAAgC;CAoBjC"}

package/lib/math/geometry/spaceVector.js

@@ -1,3 +1,4 @@
+import { opposite } from "../../tree/nodes/functions/oppositeNode.js";
 import { SqrtNode } from "../../tree/nodes/functions/sqrtNode.js";
 import { NodeConstructor, } from "../../tree/nodes/nodeConstructor.js";
 import { NumberNode } from "../../tree/nodes/numbers/numberNode.js";
@@ -5,6 +6,10 @@ import { add, AddNode } from "../../tree/nodes/operators/addNode.js";
 import { multiply, MultiplyNode, } from "../../tree/nodes/operators/multiplyNode.js";
 import { SquareNode } from "../../tree/nodes/operators/powerNode.js";
 import { SubstractNode } from "../../tree/nodes/operators/substractNode.js";
+import { NodeComparator } from "../../tree/utilities/nodeComparator.js";
+import { coinFlip } from "../../utils/alea/coinFlip.js";
+import { random } from "../../utils/alea/random.js";
+import { shuffle } from "../../utils/alea/shuffle.js";
 import { zip } from "../../utils/arrays/arrayZip.js";
 import { randint } from "../utils/random/randint.js";
 import { SpacePoint } from "./spacePoint.js";
@@ -125,4 +130,39 @@ export class SpaceVector {
     equals(v) {
         return this.x.equals(v.x) && this.y.equals(v.y) && this.z.equals(v.z);
     }
+    static createRandomOrthogonalVector(vecSrc) {
+        const isVecSrcZero = [vecSrc.x, vecSrc.y, vecSrc.z].every((node) => NodeComparator.isEqualViaSub(node, (0).toTree()));
+        if (isVecSrcZero) {
+            throw new Error("vecSrc is zero");
+        }
+        const [nodeX, nodeY, nodeZ] = [vecSrc.x, vecSrc.y, vecSrc.z];
+        const nodeZero = (0).toTree();
+        const vec1 = new SpaceVector("v1", opposite(nodeY), nodeX, nodeZero);
+        const vec2 = new SpaceVector("v2", nodeZero, opposite(nodeZ), nodeY);
+        const vec3 = new SpaceVector("v3", opposite(nodeZ), nodeZero, nodeX);
+        const arrIsCanBeZero = shuffle(random([
+            [coinFlip(), false, false],
+            [coinFlip(), coinFlip(), false],
+        ]));
+        const [factor1, factor2, factor3] = arrIsCanBeZero.map((isCanBeZero) => randint(-3, 4, isCanBeZero ? [] : [0]).toTree());
+        return vec1
+            .times(factor1)
+            .add(vec2.times(factor2))
+            .add(vec3.times(factor3));
+    }
+    getRandomOrthogonalVectorNonZero() {
+        function isVectorZero(vec) {
+            return [vec.x, vec.y, vec.z].every((node) => NodeComparator.isEqualViaSub(node, (0).toTree()));
+        }
+        let vecOrth;
+        let counter = -1;
+        do {
+            vecOrth = SpaceVector.createRandomOrthogonalVector(this);
+            counter++;
+        } while (isVectorZero(vecOrth) && counter < 100);
+        if (counter === 100) {
+            throw new Error("while looped too much");
+        }
+        return vecOrth;
+    }
 }

package/lib/math/utils/polynomial/polynomialUtils.d.ts

@@ -1,5 +1,5 @@
 import { Point } from "../../../math/geometry/point.js";
-import { AlgebraicNode } from "../../../tree/nodes/algebraicNode.js";
+import { AlgebraicNode, SimplifyOptions } from "../../../tree/nodes/algebraicNode.js";
 import { VariableNode } from "../../../tree/nodes/variables/variableNode.js";
 /**
  *
@@ -26,7 +26,7 @@ export declare function createNodeFPolynomialFromCoeffs(arrNodeCoeff: AlgebraicN
  * @param arrPoint
  * @returns coeffN x^N + ... + coeff2 x^2 + coeff1 x^1 + coeff0
  */
-export declare function createNodeFTrinomFromPoints(nodeA: AlgebraicNode, arrPoint: Point[]): AlgebraicNode | import("../../../tree/nodes/operators/multiplyNode.js").MultiplyNode;
+export declare function createNodeFTrinomFromPoints(nodeA: AlgebraicNode, arrPoint: Point[], isShouldSimplify?: boolean, simplifyOptionsPass1?: SimplifyOptions, simplifyOptionsPass2?: SimplifyOptions): AlgebraicNode | import("../../../tree/nodes/operators/multiplyNode.js").MultiplyNode;
 /**
  *
  * @param arrNodeCoeff

package/lib/math/utils/polynomial/polynomialUtils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"polynomialUtils.d.ts","sourceRoot":"","sources":["../../../../src/math/utils/polynomial/polynomialUtils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,8BAA8B,CAAC;AACrD,OAAO,EACL,aAAa,EAEd,MAAM,mCAAmC,CAAC;AAQ3C,OAAO,EAAE,YAAY,EAAE,MAAM,4CAA4C,CAAC;AAO1E;;;;;GAKG;AACH,wBAAgB,8BAA8B,CAC5C,KAAK,EAAE,aAAa,EACpB,WAAW,EAAE,aAAa,EAAE,iBAO7B;AAED;;;;GAIG;AACH,wBAAgB,+BAA+B,CAAC,cAAc,EAAE,aAAa,mBA4B5E;AAED;;;;GAIG;AACH,wBAAgB,+BAA+B,CAC7C,YAAY,EAAE,aAAa,EAAE,EAC7B,wBAAwB,GAAE,OAAc,qFA8CzC;AAED;;;;;GAKG;AACH,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,aAAa,EACpB,QAAQ,EAAE,KAAK,EAAE,qFA6BlB;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,YAAY,EAAE,aAAa,EAAE,uEAGpE;AAaD,eAAO,MAAM,+BAA+B,GAC1C,gBAAgB,aAAa,EAC7B,OAAM;IAAE,OAAO,EAAE,YAAY,CAAC;IAAC,cAAc,EAAE,OAAO,CAAA;CAGrD,WAoGF,CAAC;AAEF,eAAO,MAAM,yCAAyC,GACpD,gBAAgB,aAAa;;;CA+C9B,CAAC;AAEF,wBAAgB,8BAA8B,CAC5C,cAAc,EAAE,aAAa,EAC7B,KAAK,EAAE,aAAa,iBAQrB"}
+{"version":3,"file":"polynomialUtils.d.ts","sourceRoot":"","sources":["../../../../src/math/utils/polynomial/polynomialUtils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,8BAA8B,CAAC;AACrD,OAAO,EACL,aAAa,EACb,eAAe,EAChB,MAAM,mCAAmC,CAAC;AAQ3C,OAAO,EAAE,YAAY,EAAE,MAAM,4CAA4C,CAAC;AAO1E;;;;;GAKG;AACH,wBAAgB,8BAA8B,CAC5C,KAAK,EAAE,aAAa,EACpB,WAAW,EAAE,aAAa,EAAE,iBAO7B;AAED;;;;GAIG;AACH,wBAAgB,+BAA+B,CAAC,cAAc,EAAE,aAAa,mBA4B5E;AAED;;;;GAIG;AACH,wBAAgB,+BAA+B,CAC7C,YAAY,EAAE,aAAa,EAAE,EAC7B,wBAAwB,GAAE,OAAc,qFA8CzC;AAED;;;;;GAKG;AACH,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,aAAa,EACpB,QAAQ,EAAE,KAAK,EAAE,EACjB,gBAAgB,GAAE,OAAe,EACjC,oBAAoB,GAAE,eAAoB,EAC1C,oBAAoB,GAAE,eAAoB,qFAmC3C;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,YAAY,EAAE,aAAa,EAAE,uEAGpE;AAaD,eAAO,MAAM,+BAA+B,GAC1C,gBAAgB,aAAa,EAC7B,OAAM;IAAE,OAAO,EAAE,YAAY,CAAC;IAAC,cAAc,EAAE,OAAO,CAAA;CAGrD,WAoGF,CAAC;AAEF,eAAO,MAAM,yCAAyC,GACpD,gBAAgB,aAAa;;;CA+C9B,CAAC;AAEF,wBAAgB,8BAA8B,CAC5C,cAAc,EAAE,aAAa,EAC7B,KAAK,EAAE,aAAa,iBAQrB"}