math-exercises 2.2.48 → 2.2.50

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 askedPoint = spacePoint_1.SpacePointConstructor.fromScalars(identifiers.askedPointCoords, identifiers.askedPointName);
+    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}$. 
+
+Le point $${askedPoint.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/geometry/volumes/coneVolume.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"coneVolume.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/volumes/coneVolume.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAMlC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAwGF,eAAO,MAAM,UAAU,EAAE,QAAQ,CAAC,WAAW,CAa5C,CAAC"}
+{"version":3,"file":"coneVolume.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/volumes/coneVolume.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAOlC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAoGF,eAAO,MAAM,UAAU,EAAE,QAAQ,CAAC,WAAW,CAa5C,CAAC"}

package/lib/exercises/math/geometry/volumes/coneVolume.js

@@ -6,6 +6,7 @@ const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQ
 const randint_1 = require("../../../../math/utils/random/randint");
 const geogebraConstructor_1 = require("../../../../geogebra/geogebraConstructor");
 const round_1 = require("../../../../math/utils/round");
+const numberParser_1 = require("../../../../tree/parsers/numberParser");
 const getConeVolumeQuestion = () => {
     let radius, height;
     do {
@@ -77,9 +78,10 @@ const getPropositions = (n, { answer, radius, height }) => {
     return (0, exercise_1.shuffleProps)(propositions, n);
 };
 const isAnswerValid = (ans, { answer, radius, height }) => {
-    const validanswer = (0, round_1.round)((1 / 3) * Math.PI * Math.pow(radius, 2) * height, 2).toTree();
-    const latexs = validanswer.toAllValidTexs();
-    return latexs.includes(ans);
+    const parsed = (0, numberParser_1.numberParser)(ans);
+    if (!parsed)
+        return false;
+    return parsed === answer;
 };
 exports.coneVolume = {
     id: "coneVolume",

package/lib/exercises/math/probaStat/probaFromTableWithContext.js

@@ -42,9 +42,9 @@ const getProbaFromTableWithContextQuestion = () => {
         case "singleEvent":
             [event, proba] = (0, random_1.random)([
                 ["une fille", [aTotal, total]],
-                ["une élève qui porte des lunettes", [bTotal, total]],
+                ["un élève qui porte des lunettes", [bTotal, total]],
                 ["un garçon", [aBarreTotal, total]],
-                ["une élève qui ne porte pas de lunettes", [bBarreTotal, total]],
+                ["un élève qui ne porte pas de lunettes", [bBarreTotal, total]],
             ]);
             break;
         case "intersection":

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/exercises/math/squareRoots/squareRootIdentities.js

@@ -16,12 +16,12 @@ const shuffle_1 = require("../../../utils/alea/shuffle");
 const getAnswer = (type, firstTerm, secondTerm) => {
     switch (type) {
         case 1: //(a+b)^2
-            return new addNode_1.AddNode(new powerNode_1.SquareNode(firstTerm), new addNode_1.AddNode(new powerNode_1.SquareNode(secondTerm), new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(2), new multiplyNode_1.MultiplyNode(firstTerm, secondTerm)))).simplify({ keepPowers: false });
+            return new addNode_1.AddNode(new powerNode_1.SquareNode(firstTerm), new addNode_1.AddNode(new powerNode_1.SquareNode(secondTerm), new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(2), new multiplyNode_1.MultiplyNode(firstTerm, secondTerm)))).simplify({ keepPowers: false, forbidFactorize: true });
         case 2:
-            return new addNode_1.AddNode(new powerNode_1.SquareNode(firstTerm), new substractNode_1.SubstractNode(new powerNode_1.SquareNode(secondTerm), new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(2), new multiplyNode_1.MultiplyNode(firstTerm, secondTerm)))).simplify({ keepPowers: false });
+            return new addNode_1.AddNode(new powerNode_1.SquareNode(firstTerm), new substractNode_1.SubstractNode(new powerNode_1.SquareNode(secondTerm), new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(2), new multiplyNode_1.MultiplyNode(firstTerm, secondTerm)))).simplify({ keepPowers: false, forbidFactorize: true });
         case 3:
         default:
-            return new substractNode_1.SubstractNode(new powerNode_1.SquareNode(firstTerm), new powerNode_1.SquareNode(secondTerm)).simplify({ keepPowers: false });
+            return new substractNode_1.SubstractNode(new powerNode_1.SquareNode(firstTerm), new powerNode_1.SquareNode(secondTerm)).simplify({ keepPowers: false, forbidFactorize: true });
     }
 };
 //(x sqrt(a) +- [y || y*sqrt(b)])^2

package/lib/exercises/vea/numberVEA.d.ts

@@ -0,0 +1,2 @@
+export declare const numberVEA: (studentAns: string, answer: string) => boolean;
+//# sourceMappingURL=numberVEA.d.ts.map

package/lib/exercises/vea/numberVEA.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"numberVEA.d.ts","sourceRoot":"","sources":["../../../src/exercises/vea/numberVEA.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,SAAS,eAAgB,MAAM,UAAU,MAAM,YAI3D,CAAC"}

package/lib/exercises/vea/numberVEA.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.numberVEA = void 0;
+const numberParser_1 = require("../../tree/parsers/numberParser");
+const numberVEA = (studentAns, answer) => {
+    const parsed = (0, numberParser_1.numberParser)(studentAns);
+    if (!parsed)
+        return false;
+    return parsed === answer;
+};
+exports.numberVEA = numberVEA;

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;
@@ -390,7 +390,9 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
     randomUnitIndex: number;
     randomUnitInstructionIndex: number;
     randomLength: number;
-}, {}> | import("./exercises/exercise").Exercise<{
+}, {
+    units: string[];
+}> | import("./exercises/exercise").Exercise<{
     randomUnitIndex: number;
     randomUnitInstructionIndex: number;
     randomMass: number;
@@ -731,6 +733,9 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
     type: number;
 }, {}> | import("./exercises/exercise").Exercise<{
     coeffs: number[];
+}, {}> | import("./exercises/exercise").Exercise<{
+    trinomCoeffs: number[];
+    isAskingPositive: boolean;
 }, {}> | import("./exercises/exercise").Exercise<{
     a: number;
     k: number;
@@ -1061,6 +1066,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,46 @@
+"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);
+        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) {

package/lib/math/polynomials/affine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"affine.d.ts","sourceRoot":"","sources":["../../../src/math/polynomials/affine.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAG3C,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAElC,8BAAsB,iBAAiB;IACrC,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM;IAG3C,MAAM,CAAC,MAAM,CACX,KAAK,CAAC,EAAE;QAAE,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,EAC3D,KAAK,CAAC,EAAE;QAAE,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,GAC1D,MAAM;IAcT,MAAM,CAAC,gBAAgB,CACrB,EAAE,EAAE,MAAM,EACV,KAAK,CAAC,EAAE;QAAE,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,EAC3D,KAAK,CAAC,EAAE;QAAE,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,GAC1D,MAAM,EAAE;CAWZ;AAED,qBAAa,MAAO,SAAQ,UAAU;IACpC,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,QAAQ,EAAE,MAAM,CAAC;gBAEL,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,QAAQ,GAAE,MAAY;IAOxD,OAAO,IAAI,MAAM;IAIjB,MAAM,IAAI,MAAM;IAShB,KAAK,CAAC,CAAC,EAAE,MAAM;IAIf,QAAQ,IAAI,MAAM;IAIlB,iBAAiB,IAAI,MAAM;CAG5B"}
+{"version":3,"file":"affine.d.ts","sourceRoot":"","sources":["../../../src/math/polynomials/affine.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAG3C,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAElC,8BAAsB,iBAAiB;IACrC,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM;IAG3C,MAAM,CAAC,MAAM,CACX,KAAK,CAAC,EAAE;QAAE,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,EAC3D,KAAK,CAAC,EAAE;QAAE,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,GAC1D,MAAM;IAcT,MAAM,CAAC,gBAAgB,CACrB,EAAE,EAAE,MAAM,EACV,KAAK,CAAC,EAAE;QAAE,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,EAC3D,KAAK,CAAC,EAAE;QAAE,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,GAC1D,MAAM,EAAE;CAWZ;AAED,qBAAa,MAAO,SAAQ,UAAU;IACpC,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,QAAQ,EAAE,MAAM,CAAC;gBAEL,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,QAAQ,GAAE,MAAY;IAOxD,OAAO,IAAI,MAAM;IAIjB,MAAM,IAAI,MAAM;IAMhB,KAAK,CAAC,CAAC,EAAE,MAAM;IAIf,QAAQ,IAAI,MAAM;IAIlB,iBAAiB,IAAI,MAAM;CAG5B"}

package/lib/math/polynomials/affine.js

@@ -38,7 +38,9 @@ class Affine extends polynomial_1.Polynomial {
         return new rational_1.Rational(-this.b, this.a).simplify();
     }
     square() {
-        return new trinom_1.Trinom(this.a ** 2, 2 * this.a * this.b, this.b ** 2, this.variable);
+        return new trinom_1.Trinom(this.a ** 2, 2 * this.a * this.b, this.b ** 2, {
+            variable: this.variable,
+        });
     }
     times(n) {
         return new Affine(this.a * n, this.b * n);

package/lib/math/polynomials/generalTrinom.d.ts

@@ -0,0 +1,52 @@
+import { AddNode } from "../../tree/nodes/operators/addNode";
+import { AlgebraicNode } from "../../tree/nodes/algebraicNode";
+import { NodeType } from "../../tree/nodes/node";
+export declare abstract class GeneralTrinomConstructor {
+    static random(aOpts?: {
+        min?: number;
+        max?: number;
+        excludes?: number[];
+    }, bOpts?: {
+        min?: number;
+        max?: number;
+        excludes?: number[];
+    }, cOpts?: {
+        min?: number;
+        max?: number;
+        excludes?: number[];
+    }): GeneralTrinom;
+    static randomCanonical(aOpts?: {
+        min?: number;
+        max?: number;
+        excludes?: number[];
+        from?: number[];
+    }, alphaOpts?: {
+        min?: number;
+        max?: number;
+        excludes?: number[];
+    }, betaOpts?: {
+        min?: number;
+        max?: number;
+        excludes?: number[];
+    }): GeneralTrinom;
+    static randomNiceRoots(nbOfRoots?: number): GeneralTrinom;
+    static fromCoeffs(coeffs: number[]): GeneralTrinom;
+}
+type TrinomOptions = {
+    variable: string;
+};
+export declare class GeneralTrinom {
+    a: AlgebraicNode;
+    b: AlgebraicNode;
+    c: AlgebraicNode;
+    variable: string;
+    type: NodeType;
+    constructor(a: AlgebraicNode | number, b: AlgebraicNode | number, c: AlgebraicNode | number, opts?: TrinomOptions);
+    getDelta(): AlgebraicNode;
+    getRoots(): AlgebraicNode[];
+    toTree(): AddNode;
+    toTex(): string;
+    getCoeffs(): number[];
+}
+export {};
+//# sourceMappingURL=generalTrinom.d.ts.map