math-exercises 2.2.3 → 2.2.5

package/lib/exercises/utils/getAtoms.d.ts

@@ -1,2 +1,2 @@
-export declare const getAtoms: (numberOfPeriodicTableLines?: number) => import("../../pc/molecularChemistry/atome").Atome[];
+export declare const getAtoms: (numberOfPeriodicTableLines?: number) => import("../../pc/constants/molecularChemistry/atome").Atome[];
 //# sourceMappingURL=getAtoms.d.ts.map

package/lib/exercises/utils/getAtoms.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getAtoms.d.ts","sourceRoot":"","sources":["../../../src/exercises/utils/getAtoms.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,QAAQ,gCAAiC,MAAM,wDAQ3D,CAAC"}
+{"version":3,"file":"getAtoms.d.ts","sourceRoot":"","sources":["../../../src/exercises/utils/getAtoms.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,QAAQ,gCAAiC,MAAM,kEAQ3D,CAAC"}

package/lib/exercises/utils/getAtoms.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getAtoms = void 0;
-const atome_1 = require("../../pc/molecularChemistry/atome");
+const atome_1 = require("../../pc/constants/molecularChemistry/atome");
 const lineLastElements = ["He", "Ne", "Ar", "Kr", "Xe", "Rn", "Og"];
 const getAtoms = (numberOfPeriodicTableLines) => {
     if (!numberOfPeriodicTableLines)

package/lib/index.d.ts

@@ -5,6 +5,9 @@ declare global {
         frenchify: () => string;
         toScientific: (decimals?: number) => AlgebraicNode;
     }
+    interface String {
+        toTree: () => AlgebraicNode;
+    }
 }
 /**
  * TODO
@@ -124,6 +127,14 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
 }> | import("./exercises/exercise").Exercise<{
     xValues: number[];
     yValues: number[];
+}> | import("./exercises/exercise").Exercise<{
+    scale: number;
+    isSmallScale: boolean;
+    fakeDistance: number;
+}> | import("./exercises/exercise").Exercise<{
+    scale: number;
+    isSmallScale: boolean;
+    fakeDistance: number;
 }> | import("./exercises/exercise").Exercise<{
     precisionAsked: number;
     decimal: number;
@@ -134,6 +145,9 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
 }> | import("./exercises/exercise").Exercise<{
     nb: string;
     rankAsked: number;
+}> | import("./exercises/exercise").Exercise<{
+    nb: number;
+    rankAsked: number;
 }> | import("./exercises/exercise").Exercise<{
     a: number;
     b: number;
@@ -156,6 +170,12 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
     a: number;
     b: number;
     coeff: number;
+}> | import("./exercises/exercise").Exercise<{
+    coeff: number;
+    affine1: number[];
+    affine2: number[];
+}> | import("./exercises/exercise").Exercise<{
+    coeffs: number[];
 }> | import("./exercises/exercise").Exercise<{
     randNbr: number;
 }> | import("./exercises/exercise").Exercise<{
@@ -221,6 +241,12 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
 }> | import("./exercises/exercise").Exercise<{
     affinesCoeffs: number[][];
     operation: string;
+}> | import("./exercises/exercise").Exercise<{
+    a: number;
+    b: number;
+}> | import("./exercises/exercise").Exercise<{
+    a: number;
+    bOperand: number;
 }> | import("./exercises/exercise").Exercise<{
     b: number;
     c: number;
@@ -240,38 +266,6 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
     a: number;
     b: number;
     c: number;
-    /**
-     * TODO
-     * Décimal : permettre facilement -0.xxx
-     * Tree shaking export
-     *
-     * VEA:
-     *  -> -3x est bien transofmré en -3*x, x*(-3) mais pas en -x*3
-     *      ->> faire le meme delire que pour les power mais pour les opposite ?
-     *          c'est à dire créer toutes les permuts en déplacant le moins qquepart
-     *  -> faire des nodes pour les Ensembles de nombre
-     *
-     * !-> choses pour lesquelles la v1 ne marchera pas :
-     *  !-- fractions non réduites
-     *  !-- nbs décimaux avec des 0
-     *  !-- nb quelconque de moins, genre -3*-4 ou -x/-y
-     * !-> pour ces choses là il faut obligatoirement parser la rpéonse élève ?
-     *
-     * Passer les sqrtNode en tree-iable
-     *
-     *
-     *
-     * !!!à fix :
-     * ! fraction réductible
-     * ! 0,20 au lieu de 0,2
-     * ! moins partout dans fraction
-     * !puissances négatives vers inverse fraction
-     * ! simplification du ln
-     * ! meileure gestion des [] : le clavier devriat pouvoir produire des left/right ;
-     *      !aussi en tapant [ puis diviser, le crochet passe en numérateur
-     * ! espace tous les 3 chiffres dans un nb (le clavier doit le fournir aussi!)
-    
-    */
     d: number;
 }> | import("./exercises/exercise").Exercise<{
     k: number;
@@ -549,6 +543,11 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
     trinomial: number[];
     leftbound: number;
     rightbound: number;
+}> | import("./exercises/exercise").Exercise<{
+    xA: number;
+    xB: number;
+    yA: number;
+    yB: number;
 }> | import("./exercises/exercise").Exercise<{
     rand: boolean;
     poly1: number[];
@@ -673,6 +672,12 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
     quadrinomial: number[];
     leftbound: number;
     rightbound: number;
+}> | import("./exercises/exercise").Exercise<{
+    a: number;
+    b: number;
+    type: number;
+}> | import("./exercises/exercise").Exercise<{
+    coeffs: number[];
 }> | import("./exercises/exercise").Exercise<{
     a: number;
     k: number;
@@ -1190,6 +1195,12 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
     rank2: number;
     reason: number;
     value1: number;
+}> | import("./exercises/exercise").Exercise<{
+    rank1: number;
+    value1: number;
+    rank2: number;
+    value2: number;
+    rankAsked: number;
 }> | import("./exercises/exercise").Exercise<{
     firstValue: number;
     reason: number;
@@ -1248,43 +1259,15 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
     type: number;
     nb: string;
 }> | import("./exercises/exercise").Exercise<{
+    x: number;
+    y: number;
+    z: number;
+}> | import("./exercises/exercise").Exercise<{}> | import("./exercises/exercise").Exercise<{}> | import("./exercises/exercise").Exercise<{
     sqrtOperand: number;
 }> | import("./exercises/exercise").Exercise<{
     k: number;
 }> | import("./exercises/exercise").Exercise<{
     type: number;
-    /**
-     * TODO
-     * Décimal : permettre facilement -0.xxx
-     * Tree shaking export
-     *
-     * VEA:
-     *  -> -3x est bien transofmré en -3*x, x*(-3) mais pas en -x*3
-     *      ->> faire le meme delire que pour les power mais pour les opposite ?
-     *          c'est à dire créer toutes les permuts en déplacant le moins qquepart
-     *  -> faire des nodes pour les Ensembles de nombre
-     *
-     * !-> choses pour lesquelles la v1 ne marchera pas :
-     *  !-- fractions non réduites
-     *  !-- nbs décimaux avec des 0
-     *  !-- nb quelconque de moins, genre -3*-4 ou -x/-y
-     * !-> pour ces choses là il faut obligatoirement parser la rpéonse élève ?
-     *
-     * Passer les sqrtNode en tree-iable
-     *
-     *
-     *
-     * !!!à fix :
-     * ! fraction réductible
-     * ! 0,20 au lieu de 0,2
-     * ! moins partout dans fraction
-     * !puissances négatives vers inverse fraction
-     * ! simplification du ln
-     * ! meileure gestion des [] : le clavier devriat pouvoir produire des left/right ;
-     *      !aussi en tapant [ puis diviser, le crochet passe en numérateur
-     * ! espace tous les 3 chiffres dans un nb (le clavier doit le fournir aussi!)
-    
-    */
     a: number;
     x: number;
     b: number | undefined;
@@ -1491,9 +1474,9 @@ declare const pcExercises: (import("./exercises/exercise").Exercise<{
     randSide: number;
     randSideQuestion: number;
 }> | import("./exercises/exercise").Exercise<{
-    reactionArray: import("./pc/molecularChemistry/reaction").ReactionSpecies[];
+    reactionArray: import("./pc/constants/molecularChemistry/reaction").ReactionSpecies[];
 }> | import("./exercises/exercise").Exercise<{
-    reactionArray: import("./pc/molecularChemistry/reaction").ReactionSpecies[];
+    reactionArray: import("./pc/constants/molecularChemistry/reaction").ReactionSpecies[];
     randomSpacieIndex: number;
 }> | import("./exercises/exercise").Exercise<{
     concentrationMere: number;
@@ -1535,6 +1518,10 @@ declare const pcExercises: (import("./exercises/exercise").Exercise<{
 }> | import("./exercises/exercise").Exercise<{
     period: number;
     splinePoints: number[][];
+}> | import("./exercises/exercise").Exercise<{
+    period: number;
+    frequency: number;
+    splinePoints: number[][];
 }> | import("./exercises/exercise").Exercise<{
     xA: number;
     yA: number;
@@ -1545,6 +1532,9 @@ declare const pcExercises: (import("./exercises/exercise").Exercise<{
     originIsMoon: boolean;
 }> | import("./exercises/exercise").Exercise<{
     mass: number;
+}> | import("./exercises/exercise").Exercise<{
+    planet: string;
+    mass: number;
 }> | import("./exercises/exercise").Exercise<{
     length: number;
     forceValue: number;
@@ -1563,6 +1553,31 @@ declare const pcExercises: (import("./exercises/exercise").Exercise<{
         significantPart: number;
         exponent: number;
     };
+}> | import("./exercises/exercise").Exercise<{
+    mass: number;
+    isAsking: string;
+}> | import("./exercises/exercise").Exercise<{
+    mass: number;
+    force: number;
+    target: "le poids" | "la masse";
+}> | import("./exercises/exercise").Exercise<{
+    planet: string;
+    mass: import("./pc/measure/measure").Measure<string>;
+    distance: import("./pc/measure/measure").Measure<string>;
+}> | import("./exercises/exercise").Exercise<{
+    planet: string;
+    mass: number;
+    h: number;
+}> | import("./exercises/exercise").Exercise<{
+    qA: {
+        significant: number;
+        exponent: number;
+    };
+    qB: {
+        significant: number;
+        exponent: number;
+    };
+    distance: number;
 }> | import("./exercises/exercise").Exercise<{
     lightYear: number;
 }> | import("./exercises/exercise").Exercise<{
@@ -1570,26 +1585,36 @@ declare const pcExercises: (import("./exercises/exercise").Exercise<{
     l: number;
     T: number;
 }> | import("./exercises/exercise").Exercise<{
-    atomSymbol: import("./pc/molecularChemistry/atomSymbols").AtomSymbols;
+    lightYear: number;
+    distanceMeters: import("./pc/measure/measure").Measure<string>;
+    isLightYearToMeters: boolean;
+}> | import("./exercises/exercise").Exercise<{
+    atomSymbol: import("./pc/constants/molecularChemistry/atomSymbols").AtomSymbols;
     elementToFind: "proton" | "neutron" | "electron";
 }> | import("./exercises/exercise").Exercise<{
-    atomSymbol: import("./pc/molecularChemistry/atomSymbols").AtomSymbols;
+    atomSymbol: import("./pc/constants/molecularChemistry/atomSymbols").AtomSymbols;
 }> | import("./exercises/exercise").Exercise<{
-    atomSymbol: import("./pc/molecularChemistry/atomSymbols").AtomSymbols;
+    atomSymbol: import("./pc/constants/molecularChemistry/atomSymbols").AtomSymbols;
 }> | import("./exercises/exercise").Exercise<{
-    atomSymbol: import("./pc/molecularChemistry/atomSymbols").AtomSymbols;
+    atomSymbol: import("./pc/constants/molecularChemistry/atomSymbols").AtomSymbols;
 }> | import("./exercises/exercise").Exercise<{
     totalWeight: number;
     percent: number;
     elWeight: number;
     type: number;
 }> | import("./exercises/exercise").Exercise<{}> | import("./exercises/exercise").Exercise<{
-    atomSymbol: import("./pc/molecularChemistry/atomSymbols").AtomSymbols;
+    atomSymbol: import("./pc/constants/molecularChemistry/atomSymbols").AtomSymbols;
 }> | import("./exercises/exercise").Exercise<{
-    atomSymbol: import("./pc/molecularChemistry/atomSymbols").AtomSymbols;
+    atomSymbol: import("./pc/constants/molecularChemistry/atomSymbols").AtomSymbols;
 }> | import("./exercises/exercise").Exercise<{
-    atomSymbol: import("./pc/molecularChemistry/atomSymbols").AtomSymbols;
+    atomSymbol: import("./pc/constants/molecularChemistry/atomSymbols").AtomSymbols;
     sampleMass: number;
+}> | import("./exercises/exercise").Exercise<{
+    totalMass: number;
+    totalVolume: number;
+    elementMass: number;
+    elementVolume: number;
+    targetProportion: "massique" | "volumique";
 }> | import("./exercises/exercise").Exercise<{
     maxQuantity: number;
     productQuantity: number;
@@ -1602,12 +1627,24 @@ declare const pcExercises: (import("./exercises/exercise").Exercise<{
 }> | import("./exercises/exercise").Exercise<{
     firstReagentVariables: number[];
     secondReagentVariables: number[];
+}> | import("./exercises/exercise").Exercise<{}> | import("./exercises/exercise").Exercise<{
+    a: number;
+    b: number;
+    vA: number;
+    vB: number;
+    cB: number;
 }> | import("./exercises/exercise").Exercise<{}> | import("./exercises/exercise").Exercise<{
     mol: number;
     molarMass: number;
 }> | import("./exercises/exercise").Exercise<{
     mass: number;
     molarMass: number;
+}> | import("./exercises/exercise").Exercise<{
+    quantity: number;
+}> | import("./exercises/exercise").Exercise<{
+    moleculeName: string;
+    sampleMass: number;
+    molarMass: number;
 }> | import("./exercises/exercise").Exercise<{
     amplitude: number;
     period: number;
@@ -1623,6 +1660,91 @@ declare const pcExercises: (import("./exercises/exercise").Exercise<{
 }> | import("./exercises/exercise").Exercise<{
     power: number;
     seconds: number;
+}> | import("./exercises/exercise").Exercise<{
+    E: number;
+    I: number;
+    r: number;
+    R: number;
+    isAsking: string;
+}> | import("./exercises/exercise").Exercise<{}> | import("./exercises/exercise").Exercise<{
+    isAsking: string;
+    uAB: number;
+    uED: number;
+    uDC: number;
+}> | import("./exercises/exercise").Exercise<{
+    l1: number;
+    l2: number;
+    isAsking: string;
+    circuit: string;
+}> | import("./exercises/exercise").Exercise<{
+    l1: number;
+    l2: number;
+}> | import("./exercises/exercise").Exercise<{
+    voltage: number;
+    current: number;
+    resistance: number;
+    target: string;
+    targetValue: number;
+}> | import("./exercises/exercise").Exercise<{
+    power: number;
+    seconds: number;
+    energy: number;
+}> | import("./exercises/exercise").Exercise<{
+    substance: string;
+    mass: number;
+    latentHeat: number;
+    energy: number;
+}> | import("./exercises/exercise").Exercise<{
+    isAsking: string;
+    mass: number;
+    velocity: number;
+    kineticEnergy: number;
+}> | import("./exercises/exercise").Exercise<{
+    entry: number;
+    out: number;
+}> | import("./exercises/exercise").Exercise<{
+    eComb: number;
+    quantity: number;
+}> | import("./exercises/exercise").Exercise<{
+    pc: number;
+    mass: number;
+}> | import("./exercises/exercise").Exercise<{
+    type: number;
+    pc?: number | undefined;
+    mass?: number | undefined;
+    eComb?: number | undefined;
+    quantity?: number | undefined;
+}> | import("./exercises/exercise").Exercise<{
+    mass: number;
+    specificHeat: number;
+    initialTemp: number;
+    finalTemp: number;
+    variable: "c" | "m" | "E_th" | "deltaT";
+}> | import("./exercises/exercise").Exercise<{
+    inputPower: number;
+    outputPower: number;
+    efficiency: number;
+    variable: "P_in" | "P_out" | "η";
+}> | import("./exercises/exercise").Exercise<{
+    norm: number;
+}> | import("./exercises/exercise").Exercise<{}> | import("./exercises/exercise").Exercise<{
+    distance: {
+        value: number;
+        unitIndex: number;
+    };
+    time: {
+        value: number;
+        unitIndex: number;
+    };
+}> | import("./exercises/exercise").Exercise<{}> | import("./exercises/exercise").Exercise<{
+    object1: string;
+    object2: string;
+    reference: "à l'autre" | "au sol";
+}> | import("./exercises/exercise").Exercise<{
+    speed: number;
+    distance: number;
+    deltaTime: number;
+    target: "distance" | "vitesse moyenne" | "temps";
 }> | import("./exercises/exercise").Exercise<{
     epsilon: number;
     l: number;
@@ -1634,9 +1756,28 @@ declare const pcExercises: (import("./exercises/exercise").Exercise<{
     absorbance: number;
     randomIndex: number;
 }> | import("./exercises/exercise").Exercise<{
-    wavelengths: import("./pc/measure/measure").Measure[];
+    concentration: number;
+    quantity: number;
+    volume: number;
+    variable: "C" | "V" | "n";
+}> | import("./exercises/exercise").Exercise<{
+    concentration: number;
+    mass: number;
+    molarMass: number;
+    variable: "C" | "M" | "t";
+}> | import("./exercises/exercise").Exercise<{
+    wavelengths: import("./pc/measure/measure").Measure<string>[];
     targetColor: "rouge" | "verte" | "bleue";
-    energy: import("./pc/measure/measure").Measure;
+    energy: import("./pc/measure/measure").Measure<string>;
+}> | import("./exercises/exercise").Exercise<{
+    atomicMass: number;
+    atomicNumber: number;
+}> | import("./exercises/exercise").Exercise<{}> | import("./exercises/exercise").Exercise<{
+    order: number;
+    multiplier: number;
+}> | import("./exercises/exercise").Exercise<{
+    E: number;
+    S: number;
 }>)[];
 export { mathExercises, pcExercises };
 //# sourceMappingURL=index.d.ts.map

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAG3D,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,MAAM;QACd,MAAM,EAAE,MAAM,aAAa,CAAC;QAC5B,SAAS,EAAE,MAAM,MAAM,CAAC;QACxB,YAAY,EAAE,CAAC,QAAQ,CAAC,EAAE,MAAM,KAAK,aAAa,CAAC;KACpD;CACF;AAcD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+BE;AAEF,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAjCnB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+BE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA/BF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+BE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAEgD,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAI3D,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,MAAM;QACd,MAAM,EAAE,MAAM,aAAa,CAAC;QAC5B,SAAS,EAAE,MAAM,MAAM,CAAC;QACxB,YAAY,EAAE,CAAC,QAAQ,CAAC,EAAE,MAAM,KAAK,aAAa,CAAC;KACpD;IACD,UAAU,MAAM;QACd,MAAM,EAAE,MAAM,aAAa,CAAC;KAC7B;CACF;AAgBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+BE;AAEF,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,CAAC"}

package/lib/index.js

@@ -30,6 +30,10 @@ const MathExercises = __importStar(require("./exercises/math"));
 const PCExercises = __importStar(require("./exercises/pc"));
 const infiniteNode_1 = require("./tree/nodes/numbers/infiniteNode");
 const toScientific_1 = require("./utils/numberPrototype/toScientific");
+const variableNode_1 = require("./tree/nodes/variables/variableNode");
+String.prototype.toTree = function () {
+    return new variableNode_1.VariableNode(this.valueOf());
+};
 Number.prototype.toTree = function () {
     const value = this.valueOf();
     if (value === Infinity)

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

@@ -0,0 +1,27 @@
+import { AlgebraicNode } from "../../tree/nodes/algebraicNode";
+type AleaBound = {
+    min?: number;
+    max?: number;
+    excludes?: number[];
+};
+export declare abstract class SpacePointConstructor {
+    static random(name: string, xOpts?: AleaBound, yOpts?: AleaBound, zOpts?: AleaBound): SpacePoint;
+    static randomDifferent(names: string[]): SpacePoint[];
+}
+export declare class SpacePoint {
+    name: string;
+    x: AlgebraicNode;
+    y: AlgebraicNode;
+    z: AlgebraicNode;
+    constructor(name: string, x: AlgebraicNode, y: AlgebraicNode, z: AlgebraicNode);
+    toTex(): string;
+    toTexWithCoords(): string;
+    toCoords(): string;
+    midpoint(B: SpacePoint, name?: string): SpacePoint;
+    distanceTo(B: SpacePoint): number;
+    equals(B: SpacePoint): boolean;
+    isAligned(B: SpacePoint, C: SpacePoint): void;
+    toGGBCommand(): string;
+}
+export {};
+//# sourceMappingURL=spacePoint.d.ts.map

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

@@ -0,0 +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"}

package/lib/math/geometry/spacePoint.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SpacePoint = exports.SpacePointConstructor = void 0;
+const numberNode_1 = require("../../tree/nodes/numbers/numberNode");
+const randint_1 = require("../utils/random/randint");
+class SpacePointConstructor {
+    static random(name, xOpts, yOpts, zOpts) {
+        const x = (0, randint_1.randint)(xOpts?.min ?? -9, xOpts?.max ?? 10, xOpts?.excludes ?? []);
+        const y = (0, randint_1.randint)(yOpts?.min ?? -9, yOpts?.max ?? 10, yOpts?.excludes ?? []);
+        const z = (0, randint_1.randint)(zOpts?.min ?? -9, zOpts?.max ?? 10, zOpts?.excludes ?? []);
+        return new SpacePoint(name, new numberNode_1.NumberNode(x), new numberNode_1.NumberNode(y), new numberNode_1.NumberNode(z));
+    }
+    static randomDifferent(names) {
+        const res = [];
+        const points = [];
+        for (let i = 0; i < names.length; i++) {
+            let x;
+            let y;
+            let z;
+            do {
+                x = (0, randint_1.randint)(-10, 11);
+                y = (0, randint_1.randint)(-10, 11);
+                z = (0, randint_1.randint)(-10, 11);
+            } while (points.some((point) => point[0] === x && point[1] === y && point[2] === z));
+            points.push([x, y, z]);
+            res.push(new SpacePoint(names[i], new numberNode_1.NumberNode(x), new numberNode_1.NumberNode(y), new numberNode_1.NumberNode(z)));
+        }
+        return res;
+    }
+}
+exports.SpacePointConstructor = SpacePointConstructor;
+class SpacePoint {
+    constructor(name, x, y, z) {
+        this.name = name;
+        this.x = x;
+        this.y = y;
+        this.z = z;
+    }
+    toTex() {
+        return `${this.name}`;
+    }
+    toTexWithCoords() {
+        return `${this.name}\\left(${this.x.toTex()};${this.y.toTex()};${this.z.toTex()}\\right)`;
+    }
+    toCoords() {
+        return `\\left(${this.x.toTex()};${this.y.toTex()};${this.z.toTex()}\\right)`;
+    }
+    midpoint(B, name = "I") {
+        // const types = [this.x.type, this.y.type, B.x.type, B.y.type];
+        // if (types.some((type) => type !== NodeType.number)) {
+        //   throw Error("general midpoint not implemented yet");
+        // }
+        // return new Point(
+        //   name,
+        //   new Rational((this.x as NumberNode).value + (B.x as NumberNode).value, 2)
+        //     .simplify()
+        //     .toTree(),
+        //   new Rational((this.y as NumberNode).value + (B.y as NumberNode).value, 2)
+        //     .simplify()
+        //     .toTree(),
+        // );
+        throw Error("unimplemented");
+    }
+    distanceTo(B) {
+        throw Error("unimplemented");
+    }
+    equals(B) {
+        return this.x.equals(B.x) && this.y.equals(B.y) && this.z.equals(B.z);
+    }
+    isAligned(B, C) {
+        // const AB = VectorConstructor.fromPoints(this, B);
+        // const AC = VectorConstructor.fromPoints(this, C);
+        // return AB.isColinear(AC);
+        throw Error("unimplemented");
+    }
+    toGGBCommand() {
+        return `${this.name} = (${this.x.toMathString()}, ${this.y.toMathString()}, ${this.z.toMathString()}})`;
+    }
+}
+exports.SpacePoint = SpacePoint;

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

@@ -0,0 +1,28 @@
+import { AlgebraicNode } from "../../tree/nodes/algebraicNode";
+import { Node } from "../../tree/nodes/node";
+import { SpacePoint } from "./spacePoint";
+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[];
+}
+export declare class SpaceVector {
+    name: string;
+    tex: string;
+    x: AlgebraicNode;
+    y: AlgebraicNode;
+    z: AlgebraicNode;
+    constructor(name: string, x: AlgebraicNode, y: AlgebraicNode, z: AlgebraicNode);
+    toTex(): string;
+    toInlineCoordsTex(): string;
+    toTexWithCoords(): string;
+    isColinear(v: SpaceVector): boolean;
+    determinant(v: SpaceVector): AlgebraicNode;
+    times(k: AlgebraicNode, name?: string): SpaceVector;
+    scalarProduct(v: SpaceVector): Node;
+    add(v: SpaceVector): SpaceVector;
+    getNorm(): AlgebraicNode;
+    getEndPoint(startPoint: SpacePoint, name?: string): SpacePoint;
+    equals(v: SpaceVector): boolean;
+}
+//# sourceMappingURL=spaceVector.d.ts.map

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

@@ -0,0 +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,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"}