math-exercises 1.1.0 → 1.2.0

package/src/exercises/powers/powersProduct.js

@@ -0,0 +1,46 @@
+"use strict";
+exports.__esModule = true;
+exports.getPowersProductQuestion = exports.powersProduct = exports.powersOfTenProduct = void 0;
+var randint_1 = require("../../mathutils/random/randint");
+var power_1 = require("../../numbers/integer/power");
+var latexParse_1 = require("../../tree/latexParser/latexParse");
+var numberNode_1 = require("../../tree/nodes/numbers/numberNode");
+var multiplyNode_1 = require("../../tree/nodes/operators/multiplyNode");
+var powerNode_1 = require("../../tree/nodes/operators/powerNode");
+var getDistinctQuestions_1 = require("../utils/getDistinctQuestions");
+/**
+ * a^b*a^c
+ */
+exports.powersOfTenProduct = {
+    id: "powersOfTenProduct",
+    connector: "=",
+    instruction: "Calculer :",
+    label: "Multiplication de puissances de 10",
+    levels: ["4", "3", "2", "1"],
+    section: "Calculs",
+    isSingleStep: true,
+    generator: function (nb) { return (0, getDistinctQuestions_1.getDistinctQuestions)(function () { return getPowersProductQuestion(true); }, nb); }
+};
+exports.powersProduct = {
+    id: "powersProduct",
+    connector: "=",
+    instruction: "Calculer :",
+    label: "Multiplication de puissances",
+    levels: ["4", "3", "2", "1"],
+    section: "Puissances",
+    isSingleStep: true,
+    generator: function (nb) { return (0, getDistinctQuestions_1.getDistinctQuestions)(getPowersProductQuestion, nb); }
+};
+function getPowersProductQuestion(useOnlyPowersOfTen) {
+    if (useOnlyPowersOfTen === void 0) { useOnlyPowersOfTen = false; }
+    var a = useOnlyPowersOfTen ? 10 : (0, randint_1.randint)(-11, 11);
+    var _a = [1, 2].map(function (el) { return (0, randint_1.randint)(-11, 11); }), b = _a[0], c = _a[1];
+    var statement = new multiplyNode_1.MultiplyNode(new powerNode_1.PowerNode(new numberNode_1.NumberNode(a), new numberNode_1.NumberNode(b)), new powerNode_1.PowerNode(new numberNode_1.NumberNode(a), new numberNode_1.NumberNode(c)));
+    var answerTree = new power_1.Power(a, b + c).simplify();
+    var question = {
+        statement: (0, latexParse_1.latexParse)(statement),
+        answer: (0, latexParse_1.latexParse)(answerTree)
+    };
+    return question;
+}
+exports.getPowersProductQuestion = getPowersProductQuestion;

package/src/exercises/powers/powersProduct.ts

@@ -0,0 +1,51 @@
+import { randint } from "../../mathutils/random/randint";
+import { Power } from "../../numbers/integer/power";
+import { latexParse } from "../../tree/latexParser/latexParse";
+import { NumberNode } from "../../tree/nodes/numbers/numberNode";
+import { MultiplyNode } from "../../tree/nodes/operators/multiplyNode";
+import { PowerNode } from "../../tree/nodes/operators/powerNode";
+import { Exercise, Question } from "../exercise";
+import { getDistinctQuestions } from "../utils/getDistinctQuestions";
+
+/**
+ * a^b*a^c
+ */
+
+export const powersOfTenProduct: Exercise = {
+  id: "powersOfTenProduct",
+  connector: "=",
+  instruction: "Calculer :",
+  label: "Multiplication de puissances de 10",
+  levels: ["4", "3", "2", "1"],
+  section: "Calculs",
+  isSingleStep: true,
+  generator: (nb: number) => getDistinctQuestions(() => getPowersProductQuestion(true), nb),
+};
+
+export const powersProduct: Exercise = {
+  id: "powersProduct",
+  connector: "=",
+  instruction: "Calculer :",
+  label: "Multiplication de puissances",
+  levels: ["4", "3", "2", "1"],
+  section: "Puissances",
+  isSingleStep: true,
+  generator: (nb: number) => getDistinctQuestions(getPowersProductQuestion, nb),
+};
+
+export function getPowersProductQuestion(useOnlyPowersOfTen: boolean = false): Question {
+  const a = useOnlyPowersOfTen ? 10 : randint(-11, 11);
+  const [b, c] = [1, 2].map((el) => randint(-11, 11));
+
+  const statement = new MultiplyNode(
+    new PowerNode(new NumberNode(a), new NumberNode(b)),
+    new PowerNode(new NumberNode(a), new NumberNode(c))
+  );
+  const answerTree = new Power(a, b + c).simplify();
+
+  const question: Question = {
+    statement: latexParse(statement),
+    answer: latexParse(answerTree),
+  };
+  return question;
+}

package/src/exercises/powers/scientificToDecimal.js

@@ -0,0 +1,38 @@
+"use strict";
+exports.__esModule = true;
+exports.getScientificToDecimalQuestion = exports.scientificToDecimal = void 0;
+var randint_1 = require("../../mathutils/random/randint");
+var decimal_1 = require("../../numbers/decimals/decimal");
+var integer_1 = require("../../numbers/integer/integer");
+var latexParse_1 = require("../../tree/latexParser/latexParse");
+var numberNode_1 = require("../../tree/nodes/numbers/numberNode");
+var multiplyNode_1 = require("../../tree/nodes/operators/multiplyNode");
+var powerNode_1 = require("../../tree/nodes/operators/powerNode");
+var getDistinctQuestions_1 = require("../utils/getDistinctQuestions");
+/**
+ * a*10^x vers décimal
+ *  */
+exports.scientificToDecimal = {
+    id: "scientificToDecimal",
+    connector: "=",
+    instruction: "Donner l'écriture décimale de :",
+    label: "Ecriture décimale de $a\\times 10^x",
+    levels: ["5", "4", "3", "2"],
+    section: "Puissances",
+    isSingleStep: true,
+    generator: function (nb) { return (0, getDistinctQuestions_1.getDistinctQuestions)(getScientificToDecimalQuestion, nb); }
+};
+function getScientificToDecimalQuestion() {
+    var randPower = (0, randint_1.randint)(-6, 8);
+    var int = integer_1.IntegerConstructor.random((0, randint_1.randint)(1, 4));
+    var fracPart = decimal_1.DecimalConstructor.randomFracPart((0, randint_1.randint)(0, 4));
+    var randDecimal = decimal_1.DecimalConstructor.fromParts(int + "", fracPart);
+    var statement = new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(randDecimal.value), new powerNode_1.PowerNode(new numberNode_1.NumberNode(10), new numberNode_1.NumberNode(randPower)));
+    var answerTree = randDecimal.multiplyByPowerOfTen(randPower).toTree();
+    var question = {
+        statement: (0, latexParse_1.latexParse)(statement),
+        answer: (0, latexParse_1.latexParse)(answerTree)
+    };
+    return question;
+}
+exports.getScientificToDecimalQuestion = getScientificToDecimalQuestion;

package/src/exercises/powers/scientificToDecimal.ts

@@ -0,0 +1,44 @@
+import { randint } from "../../mathutils/random/randint";
+import { DecimalConstructor } from "../../numbers/decimals/decimal";
+import { IntegerConstructor } from "../../numbers/integer/integer";
+import { Power } from "../../numbers/integer/power";
+import { latexParse } from "../../tree/latexParser/latexParse";
+import { NumberNode } from "../../tree/nodes/numbers/numberNode";
+import { FractionNode } from "../../tree/nodes/operators/fractionNode";
+import { MultiplyNode } from "../../tree/nodes/operators/multiplyNode";
+import { PowerNode } from "../../tree/nodes/operators/powerNode";
+import { Exercise, Question } from "../exercise";
+import { getDistinctQuestions } from "../utils/getDistinctQuestions";
+
+/**
+ * a*10^x vers décimal
+ *  */
+
+export const scientificToDecimal: Exercise = {
+  id: "scientificToDecimal",
+  connector: "=",
+  instruction: "Donner l'écriture décimale de :",
+  label: "Ecriture décimale de $a\\times 10^x",
+  levels: ["5", "4", "3", "2"],
+  section: "Puissances",
+  isSingleStep: true,
+  generator: (nb: number) => getDistinctQuestions(getScientificToDecimalQuestion, nb),
+};
+
+export function getScientificToDecimalQuestion(): Question {
+  const randPower = randint(-6, 8);
+  const int = IntegerConstructor.random(randint(1, 4));
+  const fracPart = DecimalConstructor.randomFracPart(randint(0, 4));
+  const randDecimal = DecimalConstructor.fromParts(int + "", fracPart);
+  const statement = new MultiplyNode(
+    new NumberNode(randDecimal.value),
+    new PowerNode(new NumberNode(10), new NumberNode(randPower))
+  );
+  const answerTree = randDecimal.multiplyByPowerOfTen(randPower).toTree();
+
+  const question: Question = {
+    statement: latexParse(statement),
+    answer: latexParse(answerTree),
+  };
+  return question;
+}

package/src/exercises/squareRoots/simpifySquareRoot.js

@@ -1,17 +1,16 @@
 "use strict";
-/**
- *  type (ax+b)(cx+d) ± (ax+b)(ex+f)
- */
 exports.__esModule = true;
 exports.getSimplifySquareRoot = exports.simplifySquareRoot = void 0;
 var squareRoot_1 = require("../../numbers/reals/squareRoot");
 var latexParse_1 = require("../../tree/latexParser/latexParse");
 var getDistinctQuestions_1 = require("../utils/getDistinctQuestions");
 exports.simplifySquareRoot = {
+    id: "simplifySqrt",
     connector: "=",
     instruction: "Simplifier :",
     label: "Simplification de racines carrées",
     levels: ["3", "2", "1"],
+    isSingleStep: false,
     section: "Racines carrées",
     generator: function (nb) { return (0, getDistinctQuestions_1.getDistinctQuestions)(getSimplifySquareRoot, nb); }
 };

package/src/exercises/squareRoots/simpifySquareRoot.ts

@@ -4,10 +4,12 @@ import { Exercise, Question } from "../exercise";
 import { getDistinctQuestions } from "../utils/getDistinctQuestions";
 
 export const simplifySquareRoot: Exercise = {
+  id: "simplifySqrt",
   connector: "=",
   instruction: "Simplifier :",
   label: "Simplification de racines carrées",
   levels: ["3", "2", "1"],
+  isSingleStep: false,
   section: "Racines carrées",
   generator: (nb: number) => getDistinctQuestions(getSimplifySquareRoot, nb),
 };

package/src/index.js

@@ -1,10 +1,10 @@
 "use strict";
 exports.__esModule = true;
-var equationType1Exercise_1 = require("./exercises/calculLitteral/equation/equationType1Exercise");
-var equationType2Exercise_1 = require("./exercises/calculLitteral/equation/equationType2Exercise");
-var equationType3Exercise_1 = require("./exercises/calculLitteral/equation/equationType3Exercise");
-var equationType4Exercise_1 = require("./exercises/calculLitteral/equation/equationType4Exercise");
-console.log(equationType1Exercise_1.equationType1Exercise.generator(10));
-console.log(equationType2Exercise_1.equationType2Exercise.generator(10));
-console.log(equationType3Exercise_1.equationType3Exercise.generator(10));
-console.log(equationType4Exercise_1.equationType4Exercise.generator(10));
+exports.exercises = void 0;
+var exercises_1 = require("./exercises/exercises");
+exports.exercises = exercises_1.exercises;
+var scientificToDecimal_1 = require("./exercises/powers/scientificToDecimal");
+// exercises.forEach((exo) => {
+//   console.log(exo.instruction, exo.generator(10));
+// });
+console.log(scientificToDecimal_1.scientificToDecimal);

package/src/index.ts

@@ -1,19 +1,8 @@
-import { allIdentities } from "./exercises/calculLitteral/distributivity/allIdentities";
-import { doubleDistributivity } from "./exercises/calculLitteral/distributivity/doubleDistributivity";
-import { simpleDistributivity } from "./exercises/calculLitteral/distributivity/simpleDistributivity";
-import { equationType1Exercise } from "./exercises/calculLitteral/equation/equationType1Exercise";
-import { equationType2Exercise } from "./exercises/calculLitteral/equation/equationType2Exercise";
-import { equationType3Exercise } from "./exercises/calculLitteral/equation/equationType3Exercise";
-import { equationType4Exercise } from "./exercises/calculLitteral/equation/equationType4Exercise";
-import { factoType1Exercise } from "./exercises/calculLitteral/factorisation/factoType1Exercise";
 import { exercises } from "./exercises/exercises";
-import { simplifySquareRoot } from "./exercises/squareRoots/simpifySquareRoot";
-import { randint } from "./mathutils/random/randint";
-import { Rational } from "./numbers/rationals/rational";
-import { SquareRoot } from "./numbers/reals/squareRoot";
-import { Affine } from "./polynomials/affine";
-import { Polynomial } from "./polynomials/polynomial";
-import { latexParse } from "./tree/latexParser/latexParse";
-import { VariableNode } from "./tree/nodes/variables/variableNode";
+import { scientificToDecimal } from "./exercises/powers/scientificToDecimal";
 
+console.log(scientificToDecimal.generator(10));
+// exercises.forEach((exo) => {
+//   console.log(exo.instruction, exo.generator(10));
+// });
 export { exercises };

package/src/mathutils/arithmetic/coprimesOf.js

@@ -0,0 +1,13 @@
+"use strict";
+exports.__esModule = true;
+exports.coprimesOf = void 0;
+var gcd_1 = require("./gcd");
+var coprimesOf = function (nb) {
+    var coprimes = [];
+    for (var i = 2; i <= nb; i++) {
+        if ((0, gcd_1.gcd)(nb, i) === 1)
+            coprimes.push(i);
+    }
+    return coprimes;
+};
+exports.coprimesOf = coprimesOf;

package/src/mathutils/arithmetic/coprimesOf.ts

@@ -0,0 +1,9 @@
+import { gcd } from "./gcd";
+
+export const coprimesOf = (nb: number) => {
+  let coprimes = [];
+  for (let i = 2; i <= nb; i++) {
+    if (gcd(nb, i) === 1) coprimes.push(i);
+  }
+  return coprimes;
+};

package/src/mathutils/arithmetic/dividersOf.ts

@@ -0,0 +1,7 @@
+export const dividersOf = (nb: number) => {
+  let divisors = [];
+  for (let i = 1; i <= nb; i++) {
+    if (nb % i === 0) divisors.push(i);
+  }
+  return divisors;
+};

package/src/mathutils/arithmetic/lcd.js

@@ -0,0 +1,12 @@
+"use strict";
+exports.__esModule = true;
+exports.lcd = void 0;
+function lcd(a, b) {
+    var max = Math.max(a, b);
+    for (var i = max; i < a * b; i++) {
+        if (i % a === 0 && i % b === 0)
+            return i;
+    }
+    return a * b;
+}
+exports.lcd = lcd;

package/src/mathutils/arithmetic/lcd.ts

@@ -0,0 +1,7 @@
+export function lcd(a: number, b: number) {
+  const max = Math.max(a, b);
+  for (let i = max; i < a * b; i++) {
+    if (i % a === 0 && i % b === 0) return i;
+  }
+  return a * b;
+}

package/src/mathutils/arithmetic/nonCoprimesOf.ts

@@ -0,0 +1,9 @@
+import { gcd } from "./gcd";
+
+export const nonCoprimesOf = (nb: number) => {
+  let nonCoprimes = [];
+  for (let i = 1; i <= nb; i++) {
+    if (gcd(nb, i) !== 1) nonCoprimes.push(i);
+  }
+  return nonCoprimes;
+};

package/src/mathutils/arithmetic/nonDividersOf.ts

@@ -0,0 +1,12 @@
+import { dividersOf } from "./dividersOf";
+
+export const nonDivisorOf = (nb: number) => {
+  let nonDividers = [];
+  let dividers = dividersOf(nb);
+
+  for (let i = 2; i < nb; i++) {
+    if (nb % i !== 0) nonDividers.push(i);
+  }
+
+  return nonDividers;
+};

package/src/mathutils/decimals/decimalPartLengthOf.ts

@@ -0,0 +1,10 @@
+export const decimalPartLengthOf = (x: number) => {
+  function hasFraction(x: number) {
+    return Math.abs(Math.round(x) - x) > 1e-10;
+  }
+
+  let count = 0;
+  // multiply by increasing powers of 10 until the fractional part is ~ 0
+  while (hasFraction(x * 10 ** count) && isFinite(10 ** count)) count++;
+  return count;
+};

package/src/mathutils/random/randint.js

@@ -1,9 +1,18 @@
 "use strict";
 exports.__esModule = true;
 exports.randint = void 0;
-var randint = function (a, b) {
+/**
+ * @returns random [[a, b[[
+ */
+var randint = function (a, b, excludes) {
     if (b === undefined)
         return Math.floor(Math.random() * a);
-    return a + Math.floor(Math.random() * (b - a));
+    if (!excludes)
+        return a + Math.floor(Math.random() * (b - a));
+    var res;
+    do {
+        res = a + Math.floor(Math.random() * (b - a));
+    } while (excludes.includes(res));
+    return res;
 };
 exports.randint = randint;

package/src/mathutils/random/randint.ts

@@ -1,4 +1,12 @@
-export const randint = (a: number, b?: number) => {
+/**
+ * @returns random [[a, b[[
+ */
+export const randint = (a: number, b?: number, excludes?: number[]): number => {
   if (b === undefined) return Math.floor(Math.random() * a);
-  return a + Math.floor(Math.random() * (b - a));
+  if (!excludes) return a + Math.floor(Math.random() * (b - a));
+  let res;
+  do {
+    res = a + Math.floor(Math.random() * (b - a));
+  } while (excludes.includes(res));
+  return res;
 };

package/src/numbers/decimals/decimal.js

@@ -0,0 +1,144 @@
+"use strict";
+exports.__esModule = true;
+exports.Decimal = exports.DecimalConstructor = void 0;
+var randint_1 = require("../../mathutils/random/randint");
+var numberNode_1 = require("../../tree/nodes/numbers/numberNode");
+var integer_1 = require("../integer/integer");
+var nombre_1 = require("../nombre");
+var DecimalConstructor = /** @class */ (function () {
+    function DecimalConstructor() {
+    }
+    DecimalConstructor.randomFracPart = function (precision) {
+        var decimals = "";
+        for (var i = 0; i < precision; i++) {
+            decimals += (0, randint_1.randint)(i === precision - 1 ? 1 : 0, 10);
+        }
+        return decimals;
+    };
+    DecimalConstructor.random = function (min, max, precision) {
+        var int = (0, randint_1.randint)(min, max) + "";
+        var decimals = DecimalConstructor.randomFracPart(precision);
+        return DecimalConstructor.fromParts(int, decimals);
+    };
+    DecimalConstructor.fromParts = function (intPart, decimalPart) {
+        return new Decimal(Number("" + intPart + "." + decimalPart));
+    };
+    return DecimalConstructor;
+}());
+exports.DecimalConstructor = DecimalConstructor;
+var Decimal = /** @class */ (function () {
+    function Decimal(value) {
+        this.type = nombre_1.NumberType.Decimal;
+        this.value = value;
+        this.tex = value + "";
+        var _a = (value + "").split("."), intPartString = _a[0], decimalPartString = _a[1];
+        this.intPart = Number(intPartString);
+        this.decimalPart = decimalPartString || "";
+        this.precision = this.decimalPart.length;
+    }
+    /**
+     *
+     * @param precision 0 = unité, 1 = dizieme, ... , -1 : dizaine
+     * @returns
+     */
+    Decimal.prototype.round = function (precision) {
+        var intPartString = this.intPart + "";
+        if (precision < 0) {
+            if (precision < -intPartString.length)
+                throw Error("can't round to higher precision");
+            return new integer_1.Integer(this.intPart).round(-precision);
+        }
+        if (precision > this.precision)
+            throw Error("can't round to higher precision");
+        if (precision === this.precision)
+            return this;
+        var newFracPart = "", newIntPart = "";
+        var shouldRoundUp = Number(this.decimalPart[precision]) > 4;
+        if (shouldRoundUp) {
+            var retenue = true;
+            var i = precision - 1;
+            while (retenue) {
+                if (i > -1) {
+                    var nb = (Number(this.decimalPart[i]) + 1) % 10;
+                    if (nb || newFracPart) {
+                        newFracPart = nb.toString() + newFracPart;
+                    }
+                    if (nb !== 0) {
+                        retenue = false;
+                        for (var j = i - 1; j > -1; j--) {
+                            newFracPart = this.decimalPart[j] + newFracPart;
+                        }
+                        newIntPart = intPartString;
+                    }
+                    else
+                        i--;
+                }
+                else {
+                    var nb = (Number(intPartString[i + intPartString.length]) + 1) % 10;
+                    newIntPart = nb + "" + newIntPart;
+                    if (nb !== 0) {
+                        retenue = false;
+                        for (var j = i + intPartString.length - 1; j > -1; j--) {
+                            newIntPart = intPartString[j] + newIntPart;
+                        }
+                    }
+                    else
+                        i--;
+                }
+            }
+        }
+        else {
+            var retenue = true;
+            var i = precision - 1;
+            while (retenue) {
+                if (i > -1) {
+                    var nb = Number(this.decimalPart[i]);
+                    if (nb || newFracPart) {
+                        newFracPart = nb.toString() + newFracPart;
+                    }
+                    if (nb !== 0) {
+                        retenue = false;
+                        for (var j = i - 1; j > -1; j--) {
+                            newFracPart = this.decimalPart[j] + newFracPart;
+                        }
+                        newIntPart = intPartString;
+                    }
+                    else
+                        i--;
+                }
+                else {
+                    newIntPart = intPartString;
+                    retenue = false;
+                }
+            }
+        }
+        return DecimalConstructor.fromParts(newIntPart, newFracPart);
+    };
+    Decimal.prototype.multiplyByPowerOfTen = function (power) {
+        var newIntPart = "", newFracPart = "";
+        if (power > -1) {
+            newIntPart = this.intPart + "";
+            for (var i = 0; i < power; i++) {
+                newIntPart += i > this.decimalPart.length - 1 ? "0" : this.decimalPart[i];
+            }
+            newFracPart = this.decimalPart.slice(power);
+        }
+        else {
+            var intPartString = this.intPart + "";
+            newFracPart = this.decimalPart;
+            for (var i = intPartString.length - 1; i > intPartString.length - 1 + power; i--) {
+                newFracPart = (i < 0 ? "0" : intPartString[i]) + newFracPart;
+            }
+            if (power + intPartString.length < 1)
+                newIntPart = "0";
+            else
+                newIntPart = intPartString.slice(0, power + intPartString.length);
+        }
+        return DecimalConstructor.fromParts(newIntPart, newFracPart);
+    };
+    Decimal.prototype.toTree = function () {
+        return new numberNode_1.NumberNode(this.value);
+    };
+    return Decimal;
+}());
+exports.Decimal = Decimal;