math-exercises 2.1.0 → 2.1.2

package/lib/exercises/pc/sound/findSoundPeriodFromFrequency.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findSoundPeriodFromFrequency = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const decimal_1 = require("../../../math/numbers/decimals/decimal");
+const randint_1 = require("../../../math/utils/random/randint");
+const getFindSoundPeriodFromFrequencyQuestion = () => {
+    const frequency = (0, randint_1.randint)(20, 20000);
+    const period = 1 / frequency;
+    const periodDecimal = new decimal_1.Decimal(period);
+    const answer = periodDecimal.value.toScientific(1).toTex({ scientific: 1 });
+    const question = {
+        answer,
+        instruction: `Un signal sonore a une fréquence de $${frequency}\\ \\text{Hz}$. Calculer la période de ce signal en secondes (en écriture scientifique avec 2 chiffres significatifs).`,
+        keys: ["timesTenPower"],
+        answerFormat: "tex",
+        identifiers: { frequency },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, frequency }) => {
+    const propositions = [];
+    const period = 1 / frequency;
+    const dec = new decimal_1.Decimal(period);
+    const wrongPeriod = dec
+        .multiplyByPowerOfTen((0, randint_1.randint)(-2, 2, [0]))
+        .value.toScientific(1)
+        .toTex({ scientific: 1 });
+    (0, exercise_1.addValidProp)(propositions, answer);
+    (0, exercise_1.tryToAddWrongProp)(propositions, wrongPeriod);
+    while (propositions.length < n) {
+        const period = 1 / (0, randint_1.randint)(20, 20000);
+        const periodDecimal = new decimal_1.Decimal(period);
+        (0, exercise_1.tryToAddWrongProp)(propositions, periodDecimal.value.toScientific(1).toTex({ scientific: 1 }));
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { frequency }) => {
+    const period = 1 / frequency;
+    const periodDecimal = new decimal_1.Decimal(period);
+    const periodNotation = periodDecimal.toScientificNotation(1);
+    const texs = periodNotation.toAllValidTexs({ forbidPowerToProduct: true });
+    return texs.includes(ans);
+};
+exports.findSoundPeriodFromFrequency = {
+    id: "findSoundPeriodFromFrequency",
+    label: "Calculer la période d'un signal sonore en fonction de la fréquence",
+    levels: ["2nde"],
+    isSingleStep: true,
+    sections: ["Son"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getFindSoundPeriodFromFrequencyQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Physique",
+};

package/lib/exercises/pc/sound/frequencyComparison.d.ts

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../exercises/exercise";
+type Identifiers = {
+    frequency1: number;
+    frequency2: number;
+    soundAsked: number;
+};
+export declare const frequencyComparison: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=frequencyComparison.d.ts.map

package/lib/exercises/pc/sound/frequencyComparison.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"frequencyComparison.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/sound/frequencyComparison.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAKlC,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAqDF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAcrD,CAAC"}

package/lib/exercises/pc/sound/frequencyComparison.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.frequencyComparison = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const randint_1 = require("../../../math/utils/random/randint");
+const coinFlip_1 = require("../../../utils/coinFlip");
+const getFrequencyComparisonQuestion = () => {
+    const soundAsked = (0, coinFlip_1.coinFlip)() ? 1 : 2;
+    const soundCompared = soundAsked === 1 ? 2 : 1;
+    const frequency1 = (0, randint_1.randint)(20, 1000);
+    const frequency2 = (0, randint_1.randint)(20, 1000, [frequency1]);
+    const highestFrequency = frequency1 > frequency2 ? 1 : 2;
+    const answer = soundAsked === highestFrequency
+        ? `Plus aigu que le son ${soundCompared}`
+        : `Plus grave que le son ${soundCompared}`;
+    const question = {
+        answer,
+        instruction: `La fréquence de deux sons sont $f_1 = ${frequency1}\\ \\text{Hz}$ et $f_2 = ${frequency2}\\ \\text{Hz}$. Le son ${soundAsked} est :`,
+        keys: [],
+        answerFormat: "raw",
+        identifiers: { frequency1, frequency2, soundAsked },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, soundAsked }) => {
+    const propositions = [];
+    const soundCompared = soundAsked === 1 ? 2 : 1;
+    (0, exercise_1.addValidProp)(propositions, answer, "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, `Plus aigu que le son ${soundCompared}`, "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, `Plus grave que le son ${soundCompared}`, "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, `Aussi aigu que le son ${soundCompared}`, "raw");
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+exports.frequencyComparison = {
+    id: "frequencyComparison",
+    label: "Comparer deux fréquences sonores",
+    levels: ["2nde"],
+    isSingleStep: true,
+    sections: ["Son"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getFrequencyComparisonQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Physique",
+    answerType: "QCM",
+};

package/lib/exercises/pc/sound/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./frequencyComparison";
+export * from "./findSoundPeriodFromFrequency";
+export * from "./findSoundFrequencyFromPeriod";
+export * from "./findPeriodFromGraph";
+//# sourceMappingURL=index.d.ts.map

package/lib/exercises/pc/sound/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/sound/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,uBAAuB,CAAC"}

package/lib/exercises/pc/sound/index.js

@@ -0,0 +1,20 @@
+"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("./frequencyComparison"), exports);
+__exportStar(require("./findSoundPeriodFromFrequency"), exports);
+__exportStar(require("./findSoundFrequencyFromPeriod"), exports);
+__exportStar(require("./findPeriodFromGraph"), exports);

package/lib/exercises/pc/waves/findDistanceFromEarth.d.ts

@@ -0,0 +1,7 @@
+import { Exercise } from "../../../exercises/exercise";
+type Identifiers = {
+    lightYear: number;
+};
+export declare const findDistanceFromEarth: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=findDistanceFromEarth.d.ts.map

package/lib/exercises/pc/waves/findDistanceFromEarth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"findDistanceFromEarth.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/waves/findDistanceFromEarth.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAUlC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAsEF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAavD,CAAC"}

package/lib/exercises/pc/waves/findDistanceFromEarth.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findDistanceFromEarth = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const decimal_1 = require("../../../math/numbers/decimals/decimal");
+const randfloat_1 = require("../../../math/utils/random/randfloat");
+const randint_1 = require("../../../math/utils/random/randint");
+const round_1 = require("../../../math/utils/round");
+const getFindDistanceFromEarthQuestion = () => {
+    const lightYear = (0, round_1.round)((0, randfloat_1.randfloat)(4.2, 50), 1);
+    const speed = 300000000;
+    const secondsInAYear = 365.25 * 24 * 3600;
+    const lightDistanceTravelled = speed * secondsInAYear;
+    const lightDistanceTravelledDecimal = new decimal_1.Decimal(lightDistanceTravelled);
+    const lightDistanceTravelledDecimalScientificNotation = lightDistanceTravelledDecimal.toScientificNotation(1);
+    const distanceFromEarth = lightYear * lightDistanceTravelledDecimalScientificNotation.evaluate({});
+    // Aide : Passer par la distance parcourue par la lumière en une année. L'année-lumière est la distance parcourue par la lumière dans le vide en une année.
+    const question = {
+        answer: `${distanceFromEarth.toScientific(1).toTex({ scientific: 1 })}`,
+        instruction: `Une planète se trouve à ${lightYear.frenchify()} années-lumières de nous. Calculer à quelle distance de la Terre se trouve la planète en mètres (en écriture scientifique avec 2 chiffres significatifs). 
+    `,
+        keys: ["timesTenPower"],
+        answerFormat: "tex",
+        identifiers: { lightYear },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, lightYear }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    //error from not multiplying by distance in a lightYear
+    const speed = 300000000;
+    const distanceWithoutYearTime = lightYear * speed;
+    (0, exercise_1.tryToAddWrongProp)(propositions, distanceWithoutYearTime.toScientific(1).toTex({ scientific: 1 }));
+    const secondsInAYear = 365.25 * 24 * 3600;
+    //error from wrong distance found
+    const wrongLightDistanceTravelled = speed / secondsInAYear;
+    const distanceFromEarth = lightYear * wrongLightDistanceTravelled;
+    (0, exercise_1.tryToAddWrongProp)(propositions, distanceFromEarth.toScientific(1).toTex({ scientific: 1 }));
+    const speedDecimal = new decimal_1.Decimal(speed);
+    while (propositions.length < n) {
+        //error from not having the right speed
+        const wrongSpeed = speedDecimal.multiplyByPowerOfTen((0, randint_1.randint)(-2, 2, [0]));
+        const lightDistanceTravelled = wrongSpeed.value * secondsInAYear;
+        const distanceFromEarth = lightYear * lightDistanceTravelled;
+        (0, exercise_1.tryToAddWrongProp)(propositions, distanceFromEarth.toScientific(1).toTex({ scientific: 1 }));
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+exports.findDistanceFromEarth = {
+    id: "findDistanceFromEarth",
+    label: "Calculer la distance d'une planète à la Terre",
+    levels: ["2nde"],
+    isSingleStep: true,
+    sections: ["Ondes"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getFindDistanceFromEarthQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Physique",
+};

package/lib/exercises/pc/waves/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./findDistanceFromEarth";
+//# sourceMappingURL=index.d.ts.map

package/lib/exercises/pc/waves/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/waves/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC"}

package/lib/exercises/pc/waves/index.js

@@ -0,0 +1,17 @@
+"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("./findDistanceFromEarth"), exports);

package/lib/exercises/pc/weight/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./weightOnTheMoon";
+//# sourceMappingURL=index.d.ts.map

package/lib/exercises/pc/weight/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/weight/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC"}

package/lib/exercises/pc/weight/index.js

@@ -0,0 +1,17 @@
+"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("./weightOnTheMoon"), exports);

package/lib/exercises/pc/weight/weightOnTheMoon.d.ts

@@ -0,0 +1,8 @@
+import { Exercise } from "../../../exercises/exercise";
+type Identifiers = {
+    weight: number;
+    originIsMoon: boolean;
+};
+export declare const weightOnTheMoon: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=weightOnTheMoon.d.ts.map

package/lib/exercises/pc/weight/weightOnTheMoon.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"weightOnTheMoon.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/weight/weightOnTheMoon.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAQlC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,OAAO,CAAC;CACvB,CAAC;AA+DF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAcjD,CAAC"}

package/lib/exercises/pc/weight/weightOnTheMoon.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.weightOnTheMoon = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const frenchify_1 = require("../../../math/utils/latex/frenchify");
+const randfloat_1 = require("../../../math/utils/random/randfloat");
+const round_1 = require("../../../math/utils/round");
+const gravity_1 = require("../../../pc/constants/gravity");
+const coinFlip_1 = require("../../../utils/coinFlip");
+const getWeightOnTheMoonQuestion = () => {
+    const originIsMoon = (0, coinFlip_1.coinFlip)();
+    const origin = originIsMoon ? "Lune" : "Terre";
+    const destination = originIsMoon ? "Terre" : "Lune";
+    const weight = (0, round_1.round)((0, randfloat_1.randfloat)(2, 30), 1);
+    const gl = gravity_1.moonGravity.measure.toSignificant(1);
+    const gt = gravity_1.earthGravity.measure.toSignificant(1);
+    //Pt = m gt  = Pl/gl gt
+    //Pl = m gl  = Pt/gt gl
+    const answer = (0, round_1.round)(originIsMoon
+        ? (weight / gl.evaluate()) * gt.evaluate()
+        : (weight / gt.evaluate()) * gl.evaluate(), 1) + "N";
+    const question = {
+        answer: (0, frenchify_1.frenchify)(answer),
+        instruction: `Un objet a un poids de $${weight.frenchify()}\\ \\text{N}$ sur la ${origin}. Quel est son poids sur la ${destination} ?
+    
+Données : $g_T = ${gt.toTex()}\\ ${gravity_1.earthGravity.unit}$ , $g_L = ${gl.toTex()}\\ ${gravity_1.moonGravity.unit}$
+    `,
+        keys: ["N"],
+        answerFormat: "tex",
+        identifiers: { weight, originIsMoon },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, originIsMoon, weight }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    const gl = gravity_1.moonGravity.measure.toSignificant(1);
+    const gt = gravity_1.earthGravity.measure.toSignificant(1);
+    (0, exercise_1.tryToAddWrongProp)(propositions, (0, round_1.round)(!originIsMoon
+        ? (weight / gl.evaluate()) * gt.evaluate()
+        : (weight / gt.evaluate()) * gl.evaluate(), 1).frenchify() + "N");
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, (0, round_1.round)((0, randfloat_1.randfloat)(2, 100), 1).frenchify() + "N");
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return [answer, answer.replace("N", "")].includes(ans);
+};
+exports.weightOnTheMoon = {
+    id: "weightOnTheMoon",
+    connector: "=",
+    label: "Passer du poids sur la Lune au poids sur la Terre",
+    levels: ["2nde"],
+    isSingleStep: true,
+    sections: ["Forces"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getWeightOnTheMoonQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Physique",
+};

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

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

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

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

package/lib/exercises/utils/getAtoms.js

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

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

@@ -0,0 +1,2 @@
+export declare const getElectronicConfigurationFromShells: (shells: number[]) => string;
+//# sourceMappingURL=getElectronicConfigurationFromShells.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getElectronicConfigurationFromShells.d.ts","sourceRoot":"","sources":["../../../src/exercises/utils/getElectronicConfigurationFromShells.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,oCAAoC,WAAY,MAAM,EAAE,WAOpE,CAAC"}

package/lib/exercises/utils/getElectronicConfigurationFromShells.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getElectronicConfigurationFromShells = void 0;
+const electronsShells = [
+    { label: "1s", possibleNumberOfElectrons: 1 },
+    { label: "2s", possibleNumberOfElectrons: 2 },
+    { label: "2p", possibleNumberOfElectrons: 2 },
+    { label: "3s", possibleNumberOfElectrons: 3 },
+    { label: "3p", possibleNumberOfElectrons: 3 },
+];
+const getElectronicConfigurationFromShells = (shells) => {
+    //get [2, 2, 6, 2, 6],
+    //return 1s^2 2s^2 2p^6 3s^2 3p^6
+    const tex = shells
+        .map((shell, index) => electronsShells[index].label + "^" + shell)
+        .join("\\ ");
+    return tex;
+};
+exports.getElectronicConfigurationFromShells = getElectronicConfigurationFromShells;

package/lib/geogebra/geogebraConstructor.d.ts

@@ -6,6 +6,7 @@ type GeogebraOptions = {
     isGridBold?: boolean;
     isGridSimple?: boolean;
     isXAxesNatural?: boolean;
+    axisLabels?: string[];
 };
 type GetAdaptedCoords = {
     xMin: number;
@@ -23,6 +24,7 @@ export declare class GeogebraConstructor {
     isGridBold: boolean;
     isAxesRatioFixed: boolean;
     isXAxesNatural: boolean;
+    axisLabels?: string[];
     constructor(commands: string[], options: GeogebraOptions | undefined);
     getAdaptedCoords({ xMin, xMax, yMin, yMax, forceShowAxes, }: GetAdaptedCoords): number[];
     getOptions(): GeogebraOptions;

package/lib/geogebra/geogebraConstructor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"geogebraConstructor.d.ts","sourceRoot":"","sources":["../../src/geogebra/geogebraConstructor.ts"],"names":[],"mappings":"AAAA,KAAK,eAAe,GAAG;IACrB,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,YAAY,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,KAAK,CAAC;IACxC,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B,CAAC;AAEF,KAAK,gBAAgB,GAAG;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB,CAAC;AAEF,qBAAa,mBAAmB;IAC9B,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,YAAY,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,KAAK,CAAC;IACvC,QAAQ,EAAE,OAAO,CAAC;IAClB,QAAQ,EAAE,OAAO,CAAC;IAClB,YAAY,EAAE,OAAO,CAAC;IACtB,UAAU,EAAE,OAAO,CAAC;IACpB,gBAAgB,EAAE,OAAO,CAAC;IAC1B,cAAc,EAAE,OAAO,CAAC;gBAEZ,QAAQ,EAAE,MAAM,EAAE,EAAE,OAAO,EAAE,eAAe,GAAG,SAAS;IAWpE,gBAAgB,CAAC,EACf,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,aAAa,GACd,EAAE,gBAAgB;IAmBnB,UAAU,IAAI,eAAe;CAW9B"}
+{"version":3,"file":"geogebraConstructor.d.ts","sourceRoot":"","sources":["../../src/geogebra/geogebraConstructor.ts"],"names":[],"mappings":"AAAA,KAAK,eAAe,GAAG;IACrB,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,YAAY,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,KAAK,CAAC;IACxC,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;CACvB,CAAC;AAEF,KAAK,gBAAgB,GAAG;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB,CAAC;AAEF,qBAAa,mBAAmB;IAC9B,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,YAAY,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,KAAK,CAAC;IACvC,QAAQ,EAAE,OAAO,CAAC;IAClB,QAAQ,EAAE,OAAO,CAAC;IAClB,YAAY,EAAE,OAAO,CAAC;IACtB,UAAU,EAAE,OAAO,CAAC;IACpB,gBAAgB,EAAE,OAAO,CAAC;IAC1B,cAAc,EAAE,OAAO,CAAC;IACxB,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;gBACV,QAAQ,EAAE,MAAM,EAAE,EAAE,OAAO,EAAE,eAAe,GAAG,SAAS;IAYpE,gBAAgB,CAAC,EACf,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,aAAa,GACd,EAAE,gBAAgB;IAmBnB,UAAU,IAAI,eAAe;CAY9B"}

package/lib/geogebra/geogebraConstructor.js

@@ -11,6 +11,7 @@ class GeogebraConstructor {
         this.isGridBold = options?.isGridBold ?? false;
         this.isGridSimple = options?.isGridSimple ?? false;
         this.isXAxesNatural = options?.isXAxesNatural ?? false;
+        this.axisLabels = options?.axisLabels ?? undefined;
     }
     getAdaptedCoords({ xMin, xMax, yMin, yMax, forceShowAxes, }) {
         const showAxes = forceShowAxes ?? this.hideAxes ? false : true;
@@ -39,6 +40,7 @@ class GeogebraConstructor {
             gridDistance: this.gridDistance,
             isAxesRatioFixed: this.isAxesRatioFixed,
             isXAxesNatural: this.isXAxesNatural,
+            axisLabels: this.axisLabels,
         };
     }
 }

package/lib/index.d.ts

@@ -3,6 +3,7 @@ declare global {
     interface Number {
         toTree: () => AlgebraicNode;
         frenchify: () => string;
+        toScientific: (decimals?: number) => AlgebraicNode;
     }
 }
 /**
@@ -207,6 +208,38 @@ 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;
@@ -753,6 +786,9 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
 }> | import("./exercises/exercise").Exercise<{
     percent: number;
     nb: number;
+}> | import("./exercises/exercise").Exercise<{
+    total: number;
+    lefties: number;
 }> | import("./exercises/exercise").Exercise<{
     int: number;
     power: number;
@@ -971,6 +1007,38 @@ declare const mathExercises: (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;
@@ -1013,6 +1081,23 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
     angleValue: number;
 }>)[];
 declare const pcExercises: (import("./exercises/exercise").Exercise<{
+    numbers: number[];
+}> | import("./exercises/exercise").Exercise<{
+    randQuation: number;
+    x1: string | number;
+    x2: string | number;
+    x3: string | number;
+    x4: string | number;
+}> | import("./exercises/exercise").Exercise<{
+    total: number;
+    lefties: number;
+}> | import("./exercises/exercise").Exercise<{
+    decimal: number;
+}> | import("./exercises/exercise").Exercise<{
+    a: number;
+    b: number;
+    c: number;
+}> | import("./exercises/exercise").Exercise<{
     reactionArray: import("./pc/molecularChemistry/reaction").ReactionSpecies[];
 }> | import("./exercises/exercise").Exercise<{
     reactionArray: import("./pc/molecularChemistry/reaction").ReactionSpecies[];
@@ -1046,6 +1131,47 @@ declare const pcExercises: (import("./exercises/exercise").Exercise<{
     randomMaterial1: number;
     randomMaterial2: number;
     ramdonAngleIncidenceDeg: number;
+}> | import("./exercises/exercise").Exercise<{
+    frequency1: number;
+    frequency2: number;
+    soundAsked: number;
+}> | import("./exercises/exercise").Exercise<{
+    frequency: number;
+}> | import("./exercises/exercise").Exercise<{
+    period: number;
+}> | import("./exercises/exercise").Exercise<{
+    period: number;
+    splinePoints: number[][];
+}> | import("./exercises/exercise").Exercise<{
+    xA: number;
+    yA: number;
+    xB: number;
+    yB: number;
+}> | import("./exercises/exercise").Exercise<{
+    weight: number;
+    originIsMoon: boolean;
+}> | import("./exercises/exercise").Exercise<{
+    mass: number;
+}> | import("./exercises/exercise").Exercise<{
+    lightYear: number;
+}> | import("./exercises/exercise").Exercise<{
+    atomSymbol: import("./pc/molecularChemistry/atomSymbols").AtomSymbols;
+    elementToFind: "proton" | "neutron" | "electron";
+}> | import("./exercises/exercise").Exercise<{
+    atomSymbol: import("./pc/molecularChemistry/atomSymbols").AtomSymbols;
+}> | import("./exercises/exercise").Exercise<{
+    atomSymbol: import("./pc/molecularChemistry/atomSymbols").AtomSymbols;
+}> | import("./exercises/exercise").Exercise<{
+    atomSymbol: import("./pc/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;
+}> | import("./exercises/exercise").Exercise<{
+    atomSymbol: import("./pc/molecularChemistry/atomSymbols").AtomSymbols;
 }>)[];
 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;AAE3D,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,MAAM;QACd,MAAM,EAAE,MAAM,aAAa,CAAC;QAC5B,SAAS,EAAE,MAAM,MAAM,CAAC;KACzB;CACF;AAWD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+BE;AAEF,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAA+B,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;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"}