math-exercises 2.2.47 → 2.2.49

package/lib/exercises/math/geometry/parametric/extractVectorFromParametricLine.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractVectorFromParametricLine = void 0;
+const exercise_1 = require("../../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const parametricLine_1 = require("../../../../math/geometry/parametricLine");
+const spacePoint_1 = require("../../../../math/geometry/spacePoint");
+const spaceVector_1 = require("../../../../math/geometry/spaceVector");
+const spaceVectorParser_1 = require("../../../../tree/parsers/spaceVectorParser");
+const doWhile_1 = require("../../../../utils/doWhile");
+const getPropositions = (n, { answer, startPoint, vector }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    const lineVector = spaceVector_1.SpaceVectorConstructor.fromScalars(vector);
+    while (propositions.length < n) {
+        const vector = (0, doWhile_1.doWhile)(() => spaceVector_1.SpaceVectorConstructor.random("A"), (v) => lineVector.isColinear(v));
+        (0, exercise_1.tryToAddWrongProp)(propositions, vector.toInlineCoordsTex());
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const vector = spaceVector_1.SpaceVectorConstructor.fromScalars(identifiers.vector);
+    return vector.toInlineCoordsTex();
+};
+const getInstruction = (identifiers) => {
+    const line = new parametricLine_1.ParametricLine(spacePoint_1.SpacePointConstructor.fromScalars(identifiers.startPoint), spaceVector_1.SpaceVectorConstructor.fromScalars(identifiers.vector));
+    return `Soit $d$ la droite d'équation paramétrique : 
+  
+$$
+${line.toTex()}
+$$
+
+où $t\\in \\mathbb{R}$. 
+
+Donner les coordonnées d'un vecteur directeur de la droite $d$.
+  `;
+};
+// const getHint: GetHint<Identifiers> = (identifiers) => {
+//   return `Il suffit de remplacer $t$ par une valeur afin d'obtenir les coordonnées d'un point de la droite.`;
+// };
+// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {
+//   const line = new ParametricLine(
+//     SpacePointConstructor.fromScalars(identifiers.startPoint),
+//     SpaceVectorConstructor.fromScalars(identifiers.vector),
+//   );
+//   const detailedEquations = line.toDetailedEvaluation(new NumberNode(0));
+//   const point = line.getPointCoords(new NumberNode(0));
+//   return `Pour obtenir les coordonnées d'un point appartenant à la droite, il suffit de remplacer $t$ par n'importe quelle valeur dans les trois équations. Par simplicité, prenons $t = 0$. On obtient alors :
+// $$
+// \\left\\{\\begin{matrix}
+// x=${detailedEquations[0].toTex()} \\\\
+// y=${detailedEquations[1].toTex()} \\\\
+// z=${detailedEquations[2].toTex()}
+// \\end{matrix}
+// \\right.
+// $$
+// On en déduit que le point de coordonnées $\\left(${point
+//     .map((e) => e.toTex())
+//     .join(";")}\\right)$ appartient à la droite $d$.`;
+// };
+const getKeys = (identifiers) => {
+    return ["semicolon"];
+};
+const isAnswerValid = (ans, { answer, startPoint, vector }) => {
+    try {
+        const v = spaceVector_1.SpaceVectorConstructor.fromScalars(vector);
+        const vecAnswer = (0, spaceVectorParser_1.spaceVectorParser)(ans);
+        if (!vecAnswer)
+            return false;
+        return v.isColinear(vecAnswer);
+    }
+    catch (err) {
+        return false;
+    }
+};
+const getExtractVectorFromParametricLineQuestion = () => {
+    const startPoint = spacePoint_1.SpacePointConstructor.random("A");
+    const vector = spaceVector_1.SpaceVectorConstructor.random("B");
+    const identifiers = {
+        startPoint: startPoint.getEvaluatedCoords(),
+        vector: vector.getEvaluatedCoords(),
+    };
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        // hint: getHint(identifiers),
+        // correction: getCorrection(identifiers),
+    };
+    return question;
+};
+exports.extractVectorFromParametricLine = {
+    id: "extractVectorFromParametricLine",
+    connector: "=",
+    label: "Trouver un vecteur directeur d'une droite à partir de son équation paramétrique",
+    isSingleStep: true,
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getExtractVectorFromParametricLineQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    // getHint,
+    // getCorrection,
+    getAnswer,
+};

package/lib/exercises/math/geometry/parametric/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./pointFromParametricLine";
+export * from "./extractPointFromParametricLine";
+export * from "./extractVectorFromParametricLine";
+//# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/geometry/parametric/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/parametric/index.ts"],"names":[],"mappings":"AAAA,cAAc,2BAA2B,CAAC;AAC1C,cAAc,kCAAkC,CAAC;AACjD,cAAc,mCAAmC,CAAC"}

package/lib/exercises/math/geometry/parametric/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./pointFromParametricLine"), exports);
+__exportStar(require("./extractPointFromParametricLine"), exports);
+__exportStar(require("./extractVectorFromParametricLine"), exports);

package/lib/exercises/math/geometry/parametric/pointFromParametricLine.d.ts

@@ -0,0 +1,12 @@
+import { Exercise } from "../../../../exercises/exercise";
+type Identifiers = {
+    startPoint: number[];
+    vector: number[];
+    askedPointCoords: number[];
+    askedPointName: string;
+    isOnLine: boolean;
+    coeff?: number;
+};
+export declare const pointFromParametricLine: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=pointFromParametricLine.d.ts.map

package/lib/exercises/math/geometry/parametric/pointFromParametricLine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pointFromParametricLine.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/parametric/pointFromParametricLine.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,0BAA0B,CAAC;AAiBlC,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAC3B,cAAc,EAAE,MAAM,CAAC;IACvB,QAAQ,EAAE,OAAO,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAqFF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAkBzD,CAAC"}

package/lib/exercises/math/geometry/parametric/pointFromParametricLine.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pointFromParametricLine = void 0;
+const exercise_1 = require("../../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const parametricLine_1 = require("../../../../math/geometry/parametricLine");
+const spacePoint_1 = require("../../../../math/geometry/spacePoint");
+const spaceVector_1 = require("../../../../math/geometry/spaceVector");
+const randint_1 = require("../../../../math/utils/random/randint");
+const coinFlip_1 = require("../../../../utils/alea/coinFlip");
+const randomLetter_1 = require("../../../../utils/strings/randomLetter");
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer, "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "Oui", "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "Non", "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "On ne peut pas savoir", "raw");
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    return identifiers.isOnLine ? "Oui" : "Non";
+};
+const getInstruction = (identifiers) => {
+    const point = spacePoint_1.SpacePointConstructor.fromScalars(identifiers.askedPointCoords, identifiers.askedPointName);
+    const line = new parametricLine_1.ParametricLine(point, spaceVector_1.SpaceVectorConstructor.fromScalars(identifiers.vector));
+    return `Soit $d$ la droite d'équation paramétrique : 
+  
+$$
+${line.toTex()}
+$$
+
+où $t\\in \\mathbb{R}$. 
+
+Le point $${point.toTexWithCoords()}$ appartient-il à $d$ ?
+  `;
+};
+// const getHint: GetHint<Identifiers> = (identifiers) => {};
+// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    throw Error("VEA not implemented");
+};
+const getPointFromParametricLineQuestion = () => {
+    const startPoint = spacePoint_1.SpacePointConstructor.random("A");
+    const vector = spaceVector_1.SpaceVectorConstructor.random("B");
+    const isOnLine = (0, coinFlip_1.coinFlip)();
+    const askedPointName = (0, randomLetter_1.randomLetter)(true, ["O"]);
+    let askedPoint;
+    let coeff;
+    if (isOnLine) {
+        coeff = (0, randint_1.randint)(-10, 10);
+        const res = vector.times(coeff.toTree());
+        askedPoint = res.getEndPoint(startPoint);
+    }
+    else {
+        askedPoint = spacePoint_1.SpacePointConstructor.random(askedPointName);
+    }
+    // const askedPoint = SpacePointConstructor.random(askedPointName);
+    const identifiers = {
+        startPoint: startPoint.getEvaluatedCoords(),
+        vector: vector.getEvaluatedCoords(),
+        askedPointCoords: askedPoint.getEvaluatedCoords(),
+        askedPointName,
+        isOnLine,
+    };
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        // hint: getHint(identifiers),
+        // correction: getCorrection(identifiers),
+    };
+    return question;
+};
+exports.pointFromParametricLine = {
+    id: "pointFromParametricLine",
+    connector: "=",
+    label: "Vérifier si un point appartient à une droite d'équation paramétrique donnée",
+    isSingleStep: true,
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getPointFromParametricLineQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    // getHint,
+    // getCorrection,
+    getAnswer,
+    getKeys,
+    answerType: "QCU",
+};

package/lib/exercises/math/percent/reciprocalPercentage.js

@@ -34,7 +34,7 @@ $$
 On transforme ce coefficient multiplicateur en taux d'évolution : 
 
 $$
-(${recipCm.frenchify()}-1)\\times 100 = ${(0, round_1.round)(ans, 2).frenchify()}
+(${recipCm.frenchify()}-1)\\times 100 = ${(0, round_1.round)(ans, 2).frenchify()}\\%
 $$
 
 Ainsi, le taux d'évolution permettant de revenir au prix initial est de $${answer}$.

package/lib/exercises/math/sequences/arithmetic/arithmeticFindExplicitFormula.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"arithmeticFindExplicitFormula.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/arithmetic/arithmeticFindExplicitFormula.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AASlC,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAsEF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,CAe/D,CAAC"}
+{"version":3,"file":"arithmeticFindExplicitFormula.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/arithmetic/arithmeticFindExplicitFormula.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,0BAA0B,CAAC;AASlC,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAiIF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,CAoB/D,CAAC"}

package/lib/exercises/math/sequences/arithmetic/arithmeticFindExplicitFormula.js

@@ -8,34 +8,61 @@ const randint_1 = require("../../../../math/utils/random/randint");
 const equalNode_1 = require("../../../../tree/nodes/equations/equalNode");
 const variableNode_1 = require("../../../../tree/nodes/variables/variableNode");
 const shuffle_1 = require("../../../../utils/alea/shuffle");
-const getArithmeticFindExplicitFormula = () => {
-    const firstRank = 0;
-    const firstValue = (0, randint_1.randint)(-10, 10);
-    const reason = (0, randint_1.randint)(-10, 10, [0]);
-    const formula = new polynomial_1.Polynomial([firstValue, reason], "n");
-    const answer = "u_n=" + formula.toTex();
-    const question = {
-        instruction: `$(u_n)$ est une suite arithmétique de premier terme $u_{${firstRank}} = ${firstValue}$ et de raison $r = ${reason}$. $\\\\$ Donner l'expression de $u_n$ en fonction de $n$.`,
-        answer,
-        keys: ["un", "equal", "n"],
-        answerFormat: "tex",
-        identifiers: { firstValue, reason },
-        hint: `Utilise la formule générale d'une suite arithmétique : 
+const getInstruction = (identifiers, opts) => {
+    const firstRank = opts?.firstTermRankOne ? 1 : 0;
+    return `$(u_n)$ est une suite arithmétique de premier terme $u_{${firstRank}} = ${identifiers.firstValue}$ et de raison $r = ${identifiers.reason}$. 
+  
+Donner l'expression de $u_n$ en fonction de $n$.`;
+};
+const getHint = (identifiers, opts) => {
+    const firstRank = opts?.firstTermRankOne ? 1 : 0;
+    return `Utilise la formule générale d'une suite arithmétique : 
     
-$u_n = u_0 + n \\times r $,
+$$
+${firstRank === 0 ? "u_n = u_0 + n \\times r" : "u_n = u_1 + (n-1) \\times r"}
+$$
 
-où $u_0$ est le premier terme et $r$ la raison.`,
-        correction: `La formule générale d'une suite arithmétique est :
+où $u_${firstRank}$ est le premier terme et $r$ la raison.`;
+};
+const getCorrection = (identifiers, opts) => {
+    const firstRank = opts?.firstTermRankOne ? 1 : 0;
+    const answer = getAnswer(identifiers, opts);
+    return `La formule générale d'une suite arithmétique est :
     
-$u_n = u_0 + n \\times r $, 
+$$
+${firstRank === 0 ? "u_n = u_0 + n \\times r " : "u_n = u_1 + (n-1) \\times r "}
+$$
 
-où $u_0$ est le premier terme et $r$ la raison.
+où $u_${firstRank}$ est le premier terme et $r$ la raison.
     
-Ici, puisque $u_0 = ${firstValue}$ et $r = ${reason}$, on a : 
+Ici, puisque $u_${firstRank} = ${identifiers.firstValue}$ et $r = ${identifiers.reason}$, on a : 
 
-$${answer}$
+$$
+${answer}
+$$
 
-`,
+`;
+};
+const getAnswer = (identifiers, opts) => {
+    const { firstValue, reason } = identifiers;
+    const formula = opts?.firstTermRankOne
+        ? new polynomial_1.Polynomial([firstValue - reason, reason], "n")
+        : new polynomial_1.Polynomial([firstValue, reason], "n");
+    const answer = "u_n=" + formula.toTex();
+    return answer;
+};
+const getArithmeticFindExplicitFormula = (opts) => {
+    const firstValue = (0, randint_1.randint)(-10, 10);
+    const reason = (0, randint_1.randint)(-10, 10, [0]);
+    const identifiers = { firstValue, reason };
+    const question = {
+        instruction: getInstruction(identifiers, opts),
+        answer: getAnswer(identifiers, opts),
+        keys: ["un", "equal", "n"],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
     };
     return question;
 };
@@ -50,14 +77,24 @@ const getPropositions = (n, { answer, firstValue, reason }) => {
     }
     return (0, shuffle_1.shuffle)(propositions);
 };
-const isAnswerValid = (ans, { reason, firstValue }) => {
-    const formula = new polynomial_1.Polynomial([firstValue, reason], "n");
+const isAnswerValid = (ans, { reason, firstValue }, opts) => {
+    const formula = opts?.firstTermRankOne
+        ? new polynomial_1.Polynomial([firstValue - reason, reason], "n")
+        : new polynomial_1.Polynomial([firstValue, reason], "n");
     const equal = new equalNode_1.EqualNode(new variableNode_1.VariableNode("u_n"), formula.toTree(), {
         allowRawRightChildAsSolution: true,
     });
     const texs = equal.toAllValidTexs();
     return texs.includes(ans);
 };
+const options = [
+    {
+        id: "firstTermRankOne",
+        label: "Utiliser $u_1$ comme premier terme",
+        target: exercise_1.GeneratorOptionTarget.generation,
+        type: exercise_1.GeneratorOptionType.checkbox,
+    },
+];
 exports.arithmeticFindExplicitFormula = {
     id: "arithmeticFindExplicitFormula",
     connector: "=",
@@ -65,11 +102,16 @@ exports.arithmeticFindExplicitFormula = {
     levels: ["1reESM", "1reSpé", "1reTech", "1rePro", "TermTech", "TermPro"],
     sections: ["Suites"],
     isSingleStep: false,
-    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getArithmeticFindExplicitFormula, nb),
+    generator: (nb, opts) => (0, getDistinctQuestions_1.getDistinctQuestions)(() => getArithmeticFindExplicitFormula(opts), nb),
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
     hasHintAndCorrection: true,
+    options,
+    getAnswer,
+    getCorrection,
+    getHint,
+    getInstruction,
 };

package/lib/index.d.ts

@@ -47,7 +47,7 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
     rational: [number, number];
     rational2: [number, number];
 }, {
-    allowNonIrreductible: boolean;
+    allowNonIrreductible?: boolean | undefined;
 }> | import("./exercises/exercise").Exercise<{
     num: number;
     denum: number;
@@ -1061,6 +1061,19 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
 }, {}> | import("./exercises/exercise").Exercise<{
     type: number;
     commands: string[];
+}, {}> | import("./exercises/exercise").Exercise<{
+    startPoint: number[];
+    vector: number[];
+    askedPointCoords: number[];
+    askedPointName: string;
+    isOnLine: boolean;
+    coeff?: number | undefined;
+}, {}> | import("./exercises/exercise").Exercise<{
+    startPoint: number[];
+    vector: number[];
+}, {}> | import("./exercises/exercise").Exercise<{
+    startPoint: number[];
+    vector: number[];
 }, {}> | import("./exercises/exercise").Exercise<{
     coeffs: number[];
     to: string;

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,yBAAyB,CAAC;AAEjC,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,yBAAyB,CAAC;AAEjC,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,CAAC"}

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

@@ -0,0 +1,15 @@
+import { AlgebraicNode } from "../../tree/nodes/algebraicNode";
+import { SpacePoint } from "./spacePoint";
+import { SpaceVector } from "./spaceVector";
+export declare class ParametricLine {
+    startPoint: SpacePoint;
+    vector: SpaceVector;
+    equations: AlgebraicNode[];
+    constructor(startPoint: SpacePoint, vector: SpaceVector);
+    toDetailedEvaluation(t: AlgebraicNode): AlgebraicNode[];
+    getPointCoords(t: AlgebraicNode): AlgebraicNode[];
+    getPoint(t: AlgebraicNode): SpacePoint;
+    hasPoint(p: SpacePoint): boolean;
+    toTex(): string;
+}
+//# sourceMappingURL=parametricLine.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"parametricLine.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/parametricLine.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAI/D,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,WAAW,EAA0B,MAAM,eAAe,CAAC;AAEpE,qBAAa,cAAc;IACzB,UAAU,EAAE,UAAU,CAAC;IACvB,MAAM,EAAE,WAAW,CAAC;IACpB,SAAS,EAAE,aAAa,EAAE,CAAC;gBACf,UAAU,EAAE,UAAU,EAAE,MAAM,EAAE,WAAW;IAavD,oBAAoB,CAAC,CAAC,EAAE,aAAa;IAIrC,cAAc,CAAC,CAAC,EAAE,aAAa;IAG/B,QAAQ,CAAC,CAAC,EAAE,aAAa;IAKzB,QAAQ,CAAC,CAAC,EAAE,UAAU;IAYtB,KAAK;CAUN"}

package/lib/math/geometry/parametricLine.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParametricLine = void 0;
+const addNode_1 = require("../../tree/nodes/operators/addNode");
+const multiplyNode_1 = require("../../tree/nodes/operators/multiplyNode");
+const variableNode_1 = require("../../tree/nodes/variables/variableNode");
+const spacePoint_1 = require("./spacePoint");
+const spaceVector_1 = require("./spaceVector");
+class ParametricLine {
+    constructor(startPoint, vector) {
+        this.startPoint = startPoint;
+        this.vector = vector;
+        const pointCoords = this.startPoint.getCoords();
+        const vectorCoords = this.vector.getCoords();
+        this.equations = [0, 1, 2].map((i) => new addNode_1.AddNode(pointCoords[i], new multiplyNode_1.MultiplyNode(vectorCoords[i], new variableNode_1.VariableNode("t"))).simplify({ forbidFactorize: true }));
+    }
+    toDetailedEvaluation(t) {
+        return this.equations.map((e) => e.toDetailedEvaluation({ t: t }));
+    }
+    getPointCoords(t) {
+        return this.toDetailedEvaluation(t).map((e) => e.simplify());
+    }
+    getPoint(t) {
+        const pointCoords = this.toDetailedEvaluation(t).map((e) => e.simplify());
+        return new spacePoint_1.SpacePoint("A", pointCoords[0], pointCoords[1], pointCoords[2]);
+    }
+    hasPoint(p) {
+        if (p.equals(this.startPoint))
+            return true;
+        const secondPoint = this.vector.getEndPoint(this.startPoint);
+        const vector1 = spaceVector_1.SpaceVectorConstructor.fromPoints(this.startPoint, p);
+        const vector2 = spaceVector_1.SpaceVectorConstructor.fromPoints(this.startPoint, secondPoint);
+        console.log(vector1.toInlineCoordsTex(), vector2.toInlineCoordsTex());
+        return vector1.isColinear(vector2);
+    }
+    toTex() {
+        return `
+\\left\\{\\begin{matrix}
+x=${this.equations[0].toTex()} \\\\
+y=${this.equations[1].toTex()} \\\\
+z=${this.equations[2].toTex()} 
+\\end{matrix}
+\\right.
+`;
+    }
+}
+exports.ParametricLine = ParametricLine;

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

@@ -7,6 +7,7 @@ type AleaBound = {
 export declare abstract class SpacePointConstructor {
     static random(name: string, xOpts?: AleaBound, yOpts?: AleaBound, zOpts?: AleaBound): SpacePoint;
     static randomDifferent(names: string[]): SpacePoint[];
+    static fromScalars(arr: number[], name?: string): SpacePoint;
 }
 export declare class SpacePoint {
     name: string;
@@ -14,6 +15,8 @@ export declare class SpacePoint {
     y: AlgebraicNode;
     z: AlgebraicNode;
     constructor(name: string, x: AlgebraicNode, y: AlgebraicNode, z: AlgebraicNode);
+    getCoords(): AlgebraicNode[];
+    getEvaluatedCoords(): number[];
     toTex(): string;
     toTexWithCoords(): string;
     toCoords(): string;

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

@@ -1 +1 @@
-{"version":3,"file":"spacePoint.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/spacePoint.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAI/D,KAAK,SAAS,GAAG;IAAE,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC;AACrE,8BAAsB,qBAAqB;IACzC,MAAM,CAAC,MAAM,CACX,IAAI,EAAE,MAAM,EACZ,KAAK,CAAC,EAAE,SAAS,EACjB,KAAK,CAAC,EAAE,SAAS,EACjB,KAAK,CAAC,EAAE,SAAS,GAChB,UAAU;IAyBb,MAAM,CAAC,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE;CA4BvC;AAED,qBAAa,UAAU;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,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;IAQlB,KAAK,IAAI,MAAM;IAIf,eAAe,IAAI,MAAM;IAKzB,QAAQ,IAAI,MAAM;IAIlB,QAAQ,CAAC,CAAC,EAAE,UAAU,EAAE,IAAI,SAAM,GAAG,UAAU;IAkB/C,UAAU,CAAC,CAAC,EAAE,UAAU,GAAG,MAAM;IAIjC,MAAM,CAAC,CAAC,EAAE,UAAU,GAAG,OAAO;IAG9B,SAAS,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,UAAU;IAOtC,YAAY;CAKb"}
+{"version":3,"file":"spacePoint.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/spacePoint.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAI/D,KAAK,SAAS,GAAG;IAAE,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC;AACrE,8BAAsB,qBAAqB;IACzC,MAAM,CAAC,MAAM,CACX,IAAI,EAAE,MAAM,EACZ,KAAK,CAAC,EAAE,SAAS,EACjB,KAAK,CAAC,EAAE,SAAS,EACjB,KAAK,CAAC,EAAE,SAAS,GAChB,UAAU;IAyBb,MAAM,CAAC,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE;IA4BtC,MAAM,CAAC,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE,IAAI,GAAE,MAAY;CAWrD;AAED,qBAAa,UAAU;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,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;IAQlB,SAAS;IAGT,kBAAkB;IAIlB,KAAK,IAAI,MAAM;IAIf,eAAe,IAAI,MAAM;IAKzB,QAAQ,IAAI,MAAM;IAIlB,QAAQ,CAAC,CAAC,EAAE,UAAU,EAAE,IAAI,SAAM,GAAG,UAAU;IAkB/C,UAAU,CAAC,CAAC,EAAE,UAAU,GAAG,MAAM;IAIjC,MAAM,CAAC,CAAC,EAAE,UAAU,GAAG,OAAO;IAG9B,SAAS,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,UAAU;IAOtC,YAAY;CAKb"}

package/lib/math/geometry/spacePoint.js

@@ -27,6 +27,12 @@ class SpacePointConstructor {
         }
         return res;
     }
+    static fromScalars(arr, name = "A") {
+        if (arr.length !== 3) {
+            throw new Error("array must have 3 elements");
+        }
+        return new SpacePoint(name, new numberNode_1.NumberNode(arr[0]), new numberNode_1.NumberNode(arr[1]), new numberNode_1.NumberNode(arr[2]));
+    }
 }
 exports.SpacePointConstructor = SpacePointConstructor;
 class SpacePoint {
@@ -36,6 +42,12 @@ class SpacePoint {
         this.y = y;
         this.z = z;
     }
+    getCoords() {
+        return [this.x, this.y, this.z];
+    }
+    getEvaluatedCoords() {
+        return this.getCoords().map((e) => e.evaluate({}));
+    }
     toTex() {
         return `${this.name}`;
     }

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

@@ -5,6 +5,7 @@ export declare abstract class SpaceVectorConstructor {
     static fromPoints(origin: SpacePoint, end: SpacePoint): SpaceVector;
     static random(name: string, allowNull?: boolean): SpaceVector;
     static randomDifferents(names: string[], allowNull?: boolean): SpaceVector[];
+    static fromScalars(arr: number[]): SpaceVector;
 }
 export declare class SpaceVector {
     name: string;
@@ -13,11 +14,15 @@ export declare class SpaceVector {
     y: AlgebraicNode;
     z: AlgebraicNode;
     constructor(name: string, x: AlgebraicNode, y: AlgebraicNode, z: AlgebraicNode);
+    getCoords(): AlgebraicNode[];
+    getEvaluatedCoords(): number[];
     toTex(): string;
     toCoordsTex(): string;
     toInlineCoordsTex(): string;
     toTexWithCoords(): string;
+    vetorialProduct(v: SpaceVector): SpaceVector;
     isColinear(v: SpaceVector): boolean;
+    isCoplanar(v: SpaceVector): boolean;
     determinant(v: SpaceVector): AlgebraicNode;
     times(k: AlgebraicNode, name?: string): SpaceVector;
     scalarProduct(v: SpaceVector): Node;

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,gCAAgC,CAAC;AAE/D,OAAO,EAAE,IAAI,EAAY,MAAM,uBAAuB,CAAC;AAQvD,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE1C,8BAAsB,sBAAsB;IAC1C,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,UAAU,EAAE,GAAG,EAAE,UAAU,GAAG,WAAW;IAQnE,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,UAAO,GAAG,WAAW;IAY1D,MAAM,CAAC,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,SAAS,UAAO,GAAG,WAAW,EAAE;CAW1E;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,KAAK,IAAI,MAAM;IAIf,WAAW,IAAI,MAAM;IAGrB,iBAAiB,IAAI,MAAM;IAK3B,eAAe,IAAI,MAAM;IAMzB,UAAU,CAAC,CAAC,EAAE,WAAW,GAAG,OAAO;IAGnC,WAAW,CAAC,CAAC,EAAE,WAAW,GAAG,aAAa;IAI1C,KAAK,CAAC,CAAC,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,MAAM;IAQrC,aAAa,CAAC,CAAC,EAAE,WAAW,GAAG,IAAI;IAInC,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,gCAAgC,CAAC;AAE/D,OAAO,EAAE,IAAI,EAAY,MAAM,uBAAuB,CAAC;AASvD,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE1C,8BAAsB,sBAAsB;IAC1C,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,UAAU,EAAE,GAAG,EAAE,UAAU,GAAG,WAAW;IAQnE,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,UAAO,GAAG,WAAW;IAY1D,MAAM,CAAC,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,SAAS,UAAO,GAAG,WAAW,EAAE;IAWzE,MAAM,CAAC,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE;CAWjC;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;IAQlB,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,CAAC,CAAC,EAAE,WAAW,GAAG,OAAO;IAGnC,WAAW,CAAC,CAAC,EAAE,WAAW,GAAG,aAAa;IAI1C,KAAK,CAAC,CAAC,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,MAAM;IAQrC,aAAa,CAAC,CAAC,EAAE,WAAW,GAAG,IAAI;IAInC,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"}

package/lib/math/geometry/spaceVector.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SpaceVector = exports.SpaceVectorConstructor = void 0;
 const sqrtNode_1 = require("../../tree/nodes/functions/sqrtNode");
+const numberNode_1 = require("../../tree/nodes/numbers/numberNode");
 const addNode_1 = require("../../tree/nodes/operators/addNode");
 const multiplyNode_1 = require("../../tree/nodes/operators/multiplyNode");
 const powerNode_1 = require("../../tree/nodes/operators/powerNode");
@@ -34,6 +35,12 @@ class SpaceVectorConstructor {
         }
         return res;
     }
+    static fromScalars(arr) {
+        if (arr.length !== 3) {
+            throw new Error("array must have 3 elements");
+        }
+        return new SpaceVector("P", new numberNode_1.NumberNode(arr[0]), new numberNode_1.NumberNode(arr[1]), new numberNode_1.NumberNode(arr[2]));
+    }
 }
 exports.SpaceVectorConstructor = SpaceVectorConstructor;
 class SpaceVector {
@@ -44,6 +51,12 @@ class SpaceVector {
         this.y = y;
         this.z = z;
     }
+    getCoords() {
+        return [this.x, this.y, this.z];
+    }
+    getEvaluatedCoords() {
+        return this.getCoords().map((e) => e.evaluate({}));
+    }
     toTex() {
         return `\\overrightarrow{${this.name}}`;
     }
@@ -58,7 +71,14 @@ class SpaceVector {
     toTexWithCoords() {
         return `\\overrightarrow{${this.name}}\\begin{pmatrix}${this.x.toTex()} \\\\ ${this.y.toTex()} \\\\ ${this.z.toTex()} \\end{pmatrix}`;
     }
+    vetorialProduct(v) {
+        return new SpaceVector(`w`, new substractNode_1.SubstractNode(new multiplyNode_1.MultiplyNode(this.y, v.z), new multiplyNode_1.MultiplyNode(this.z, v.y)).simplify(), new substractNode_1.SubstractNode(new multiplyNode_1.MultiplyNode(this.z, v.x), new multiplyNode_1.MultiplyNode(this.x, v.z)).simplify(), new substractNode_1.SubstractNode(new multiplyNode_1.MultiplyNode(this.x, v.y), new multiplyNode_1.MultiplyNode(this.y, v.x)).simplify());
+    }
     isColinear(v) {
+        const vectorialProduct = this.vetorialProduct(v);
+        return vectorialProduct.equals(new SpaceVector("0", (0).toTree(), (0).toTree(), (0).toTree()));
+    }
+    isCoplanar(v) {
         throw Error("unimplemented");
     }
     determinant(v) {