math-exercises 1.2.7 → 1.2.10

package/src/polynomials/affine.ts

@@ -1,60 +0,0 @@
-import { Rational } from "../numbers/rationals/rational";
-import { Interval } from "../sets/intervals/intervals";
-import { Polynomial } from "./polynomial";
-import { DiscreteSet } from "../sets/discreteSet";
-import { MathSet } from "../sets/mathSet";
-import { Integer } from "../numbers/integer/integer";
-import { Node, NodeType } from "../tree/nodes/node";
-import { MultiplyNode } from "../tree/nodes/operators/multiplyNode";
-import { NumberNode } from "../tree/nodes/numbers/numberNode";
-import { VariableNode } from "../tree/nodes/variables/variableNode";
-import { AddNode } from "../tree/nodes/operators/addNode";
-import { Nombre } from "../numbers/nombre";
-
-export abstract class AffineConstructor {
-  static random(
-    domainA: MathSet = new Interval("[[-10; 10]]").difference(new DiscreteSet([new Integer(0)])),
-    domainB: MathSet = new Interval("[[-10; 10]]")
-  ): Affine {
-    const a = domainA.getRandomElement();
-    const b = domainB.getRandomElement();
-    return new Affine(a.value, b.value);
-  }
-
-  static differentRandoms(
-    nb: number,
-    domainA: MathSet = new Interval("[[-10; 10]]").difference(new DiscreteSet([new Integer(0)])),
-    domainB: MathSet = new Interval("[[-10; 10]]")
-  ): Affine[] {
-    const res: Affine[] = [];
-    for (let i = 0; i < nb; i++) {
-      let aff: Affine;
-      do {
-        aff = AffineConstructor.random(domainA, domainB);
-      } while (res.some((affine) => affine.equals(aff)));
-      res.push(aff);
-    }
-    return res;
-  }
-}
-
-export class Affine extends Polynomial {
-  a: number;
-  b: number;
-  variable: string;
-
-  constructor(a: number, b: number, variable: string = "x") {
-    super([b, a], variable);
-    this.a = a;
-    this.b = b;
-    this.variable = variable;
-  }
-
-  getRoot(): Nombre {
-    return new Rational(-this.b, this.a).simplify();
-  }
-
-  toString(): string {
-    return super.toTex();
-  }
-}

package/src/polynomials/polynomial.js

@@ -1,128 +0,0 @@
-"use strict";
-exports.__esModule = true;
-exports.Polynomial = void 0;
-var numberNode_1 = require("../tree/nodes/numbers/numberNode");
-var addNode_1 = require("../tree/nodes/operators/addNode");
-var multiplyNode_1 = require("../tree/nodes/operators/multiplyNode");
-var oppositeNode_1 = require("../tree/nodes/functions/oppositeNode");
-var powerNode_1 = require("../tree/nodes/operators/powerNode");
-var variableNode_1 = require("../tree/nodes/variables/variableNode");
-var Polynomial = /** @class */ (function () {
-    /**
-     *
-     * @param coefficients coefficients[i] est le coeff de x^i
-     * @param variable
-     */
-    function Polynomial(coefficients, variable) {
-        if (variable === void 0) { variable = "x"; }
-        if (coefficients.length === 0)
-            throw Error("coeffs must be not null");
-        if (coefficients[coefficients.length - 1] === 0) {
-            throw Error("n-th coeff must be not null");
-        }
-        this.coefficients = coefficients;
-        this.variable = variable;
-        this.degree = coefficients.length - 1;
-    }
-    Polynomial.prototype.equals = function (P) {
-        return P.degree === this.degree && this.coefficients.every(function (coeff, i) { return coeff === P.coefficients[i]; });
-    };
-    Polynomial.prototype.getRoots = function () { };
-    Polynomial.prototype.add = function (P) {
-        if (P.variable !== this.variable)
-            throw Error("Can't add two polynomials with different variables");
-        var newDegree = P.degree === this.degree && P.coefficients[P.degree] === -this.coefficients[this.degree]
-            ? P.degree - 1
-            : Math.max(P.degree, this.degree);
-        var res = [];
-        for (var i = 0; i < newDegree + 1; i++) {
-            res[i] = P.coefficients[i] + this.coefficients[i];
-        }
-        return new Polynomial(res, this.variable);
-    };
-    Polynomial.prototype.times = function (nb) {
-        return new Polynomial(this.coefficients.map(function (coeff) { return coeff * nb; }), this.variable);
-    };
-    Polynomial.prototype.multiply = function (Q) {
-        if (Q.variable !== this.variable)
-            throw Error("Can't multiply two polynomials with different variables");
-        var p = this.degree;
-        var q = Q.degree;
-        var res = Array.apply(0, new Array(this.degree)).map(function (i) { return 0; });
-        for (var k = 0; k <= p + q; k++) {
-            var sum = 0;
-            for (var m = 0; m <= k; m++) {
-                sum += (this.coefficients[m] || 0) * (Q.coefficients[k - m] || 0);
-            }
-            res[k] = sum;
-        }
-        return new Polynomial(res, this.variable);
-    };
-    Polynomial.prototype.opposite = function () {
-        return new Polynomial(this.coefficients.map(function (coeff) { return -coeff; }), this.variable);
-    };
-    Polynomial.prototype.toTree = function () {
-        var _this = this;
-        var recursive = function (cursor) {
-            var coeff = _this.coefficients[cursor];
-            if (coeff === 0)
-                return recursive(cursor - 1);
-            if (cursor === 0) {
-                return new numberNode_1.NumberNode(coeff);
-            }
-            var monome = cursor > 1
-                ? new powerNode_1.PowerNode(new variableNode_1.VariableNode(_this.variable), new numberNode_1.NumberNode(cursor))
-                : new variableNode_1.VariableNode(_this.variable);
-            var res;
-            if (coeff === 1)
-                res = monome;
-            else if (coeff === -1)
-                res = new oppositeNode_1.OppositeNode(monome);
-            else
-                res = new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(coeff), monome);
-            var nextCoeff;
-            for (var i = cursor - 1; i > -1; i--) {
-                if (_this.coefficients[i]) {
-                    nextCoeff = _this.coefficients[i];
-                    break;
-                }
-            }
-            if (nextCoeff) {
-                return new addNode_1.AddNode(res, recursive(cursor - 1));
-            }
-            else {
-                return res;
-            }
-        };
-        return recursive(this.degree);
-    };
-    Polynomial.prototype.toTex = function () {
-        var s = "";
-        for (var i = this.degree; i > -1; i--) {
-            var coeff = this.coefficients[i];
-            if (coeff === 0)
-                continue;
-            if (i === 0)
-                s += coeff > 0 ? "+".concat(coeff) : coeff;
-            else if (i === this.degree) {
-                s += coeff === 1 ? "" : coeff === -1 ? "-" : coeff;
-            }
-            else {
-                s += coeff === 1 ? "+" : coeff === -1 ? "-" : coeff > 0 ? "+".concat(coeff) : coeff;
-            }
-            //x^n
-            if (i === 0)
-                continue;
-            if (i === 1)
-                s += this.variable;
-            else
-                s += "".concat(this.variable, "^{").concat(i, "}");
-        }
-        return s;
-    };
-    Polynomial.prototype.toString = function () {
-        return this.toTex();
-    };
-    return Polynomial;
-}());
-exports.Polynomial = Polynomial;

package/src/polynomials/polynomial.ts

@@ -1,137 +0,0 @@
-import { Node } from "../tree/nodes/node";
-import { NumberNode } from "../tree/nodes/numbers/numberNode";
-import { AddNode } from "../tree/nodes/operators/addNode";
-import { MultiplyNode } from "../tree/nodes/operators/multiplyNode";
-import { OppositeNode } from "../tree/nodes/functions/oppositeNode";
-import { PowerNode } from "../tree/nodes/operators/powerNode";
-import { SubstractNode } from "../tree/nodes/operators/substractNode";
-import { VariableNode } from "../tree/nodes/variables/variableNode";
-
-export class Polynomial {
-  degree: number;
-  variable: string;
-  /**
-   * coefficients[i] est le coeff de x^i
-   */
-  coefficients: number[];
-
-  /**
-   *
-   * @param coefficients coefficients[i] est le coeff de x^i
-   * @param variable
-   */
-  constructor(coefficients: number[], variable: string = "x") {
-    if (coefficients.length === 0) throw Error("coeffs must be not null");
-    if (coefficients[coefficients.length - 1] === 0) {
-      throw Error("n-th coeff must be not null");
-    }
-    this.coefficients = coefficients;
-    this.variable = variable;
-    this.degree = coefficients.length - 1;
-  }
-  equals(P: Polynomial): boolean {
-    return P.degree === this.degree && this.coefficients.every((coeff, i) => coeff === P.coefficients[i]);
-  }
-  getRoots() {}
-  add(P: Polynomial): Polynomial {
-    if (P.variable !== this.variable) throw Error("Can't add two polynomials with different variables");
-
-    const newDegree =
-      P.degree === this.degree && P.coefficients[P.degree] === -this.coefficients[this.degree]
-        ? P.degree - 1
-        : Math.max(P.degree, this.degree);
-
-    const res: number[] = [];
-    for (let i = 0; i < newDegree + 1; i++) {
-      res[i] = P.coefficients[i] + this.coefficients[i];
-    }
-    return new Polynomial(res, this.variable);
-  }
-  times(nb: number): Polynomial {
-    return new Polynomial(
-      this.coefficients.map((coeff) => coeff * nb),
-      this.variable
-    );
-  }
-  multiply(Q: Polynomial): Polynomial {
-    if (Q.variable !== this.variable) throw Error("Can't multiply two polynomials with different variables");
-
-    const p = this.degree;
-    const q = Q.degree;
-    const res: number[] = Array.apply(0, new Array(this.degree)).map((i) => 0);
-
-    for (let k = 0; k <= p + q; k++) {
-      let sum = 0;
-      for (let m = 0; m <= k; m++) {
-        sum += (this.coefficients[m] || 0) * (Q.coefficients[k - m] || 0);
-      }
-      res[k] = sum;
-    }
-
-    return new Polynomial(res, this.variable);
-  }
-
-  opposite(): Polynomial {
-    return new Polynomial(
-      this.coefficients.map((coeff) => -coeff),
-      this.variable
-    );
-  }
-
-  toTree(): Node {
-    const recursive = (cursor: number): Node => {
-      const coeff = this.coefficients[cursor];
-      if (coeff === 0) return recursive(cursor - 1);
-
-      if (cursor === 0) {
-        return new NumberNode(coeff);
-      }
-
-      const monome =
-        cursor > 1
-          ? new PowerNode(new VariableNode(this.variable), new NumberNode(cursor))
-          : new VariableNode(this.variable);
-
-      let res: Node;
-      if (coeff === 1) res = monome;
-      else if (coeff === -1) res = new OppositeNode(monome);
-      else res = new MultiplyNode(new NumberNode(coeff), monome);
-
-      let nextCoeff;
-      for (let i = cursor - 1; i > -1; i--) {
-        if (this.coefficients[i]) {
-          nextCoeff = this.coefficients[i];
-          break;
-        }
-      }
-      if (nextCoeff) {
-        return new AddNode(res, recursive(cursor - 1));
-      } else {
-        return res;
-      }
-    };
-    return recursive(this.degree);
-  }
-
-  toTex(): string {
-    let s = "";
-    for (let i = this.degree; i > -1; i--) {
-      const coeff = this.coefficients[i];
-      if (coeff === 0) continue;
-      if (i === 0) s += coeff > 0 ? `+${coeff}` : coeff;
-      else if (i === this.degree) {
-        s += coeff === 1 ? "" : coeff === -1 ? "-" : coeff;
-      } else {
-        s += coeff === 1 ? "+" : coeff === -1 ? "-" : coeff > 0 ? `+${coeff}` : coeff;
-      }
-      //x^n
-      if (i === 0) continue;
-      if (i === 1) s += this.variable;
-      else s += `${this.variable}^{${i}}`;
-    }
-    return s;
-  }
-  toString(): string {
-    return this.toTex();
-  }
-}

package/src/sets/discreteSet.js

@@ -1,30 +0,0 @@
-"use strict";
-exports.__esModule = true;
-exports.DiscreteSet = void 0;
-var random_1 = require("../utils/random");
-var DiscreteSet = /** @class */ (function () {
-    function DiscreteSet(elements) {
-        var _this = this;
-        this.elements = Array.from(new Set(elements));
-        var tex = "\\{";
-        this.elements.forEach(function (el, index) {
-            tex += el.tex;
-            if (index < _this.elements.length - 1)
-                tex += ";";
-            else
-                tex += "\\}";
-        });
-        this.tex = tex;
-    }
-    DiscreteSet.prototype.toTex = function () {
-        return this.tex;
-    };
-    DiscreteSet.prototype.includes = function (el) {
-        return this.elements.some(function (nb) { return nb.value === el.value && nb.tex === el.tex; });
-    };
-    DiscreteSet.prototype.getRandomElement = function () {
-        return (0, random_1.random)(this.elements);
-    };
-    return DiscreteSet;
-}());
-exports.DiscreteSet = DiscreteSet;

package/src/sets/discreteSet.ts

@@ -1,30 +0,0 @@
-import { Nombre } from "../numbers/nombre";
-import { random } from "../utils/random";
-import { MathSetInterface } from "./mathSetInterface";
-
-export class DiscreteSet implements MathSetInterface {
-  elements: Nombre[];
-  tex: string;
-  constructor(elements: Nombre[]) {
-    this.elements = Array.from(new Set(elements));
-    let tex = "\\{";
-    this.elements.forEach((el, index) => {
-      tex += el.tex;
-      if (index < this.elements.length - 1) tex += ";";
-      else tex += "\\}";
-    });
-    this.tex = tex;
-  }
-
-  toTex(): string {
-    return this.tex;
-  }
-
-  includes(el: Nombre): boolean {
-    return this.elements.some((nb) => nb.value === el.value && nb.tex === el.tex);
-  }
-
-  getRandomElement(): Nombre {
-    return random(this.elements);
-  }
-}

package/src/sets/intervals/intervals.ts

@@ -1,122 +0,0 @@
-import { EPSILON } from "../../numbers/epsilon";
-import { Nombre, NumberType } from "../../numbers/nombre";
-import { round } from "../../mathutils/round";
-import { MathSetInterface } from "../mathSetInterface";
-import { DiscreteSet } from "../discreteSet";
-import { MathSet } from "../mathSet";
-import { Integer } from "../../numbers/integer/integer";
-import { Real } from "../../numbers/reals/real";
-
-enum BoundType {
-  OO = "]a;b[",
-  OF = "]a;b]",
-  FO = "[a;b[",
-  FF = "[a;b]",
-}
-
-export class Interval implements MathSetInterface {
-  min: number;
-  max: number;
-  boundType: BoundType;
-  type: NumberType;
-  tex: string;
-  /**
-   * [[a; b]] pour un interval d'integer;  [a;b] pour des réels
-   */
-  constructor(tex = "[-10; 10]") {
-    this.tex = tex;
-    const isInt = tex[1] === "[" || tex[1] === "]";
-    this.type = isInt ? NumberType.Integer : NumberType.Real;
-    const left = tex[0];
-    const right = tex[tex.length - 1];
-    const [a, b] = tex
-      .slice(isInt ? 2 : 1, isInt ? tex.length - 2 : tex.length - 1)
-      .split(";");
-
-    switch (`${left}a;b${right}`) {
-      case "[a;b]":
-        this.boundType = BoundType.FF;
-        break;
-      case "]a;b[":
-        this.boundType = BoundType.OO;
-        break;
-      case "[a;b[":
-        this.boundType = BoundType.FO;
-        break;
-      case "]a;b]":
-        this.boundType = BoundType.OF;
-        break;
-      default:
-        throw console.error("wrong interval");
-    }
-    function getBound(bound: string) {
-      return bound === "-\\infty"
-        ? Number.NEGATIVE_INFINITY
-        : bound === "+\\infty"
-        ? Number.POSITIVE_INFINITY
-        : Number(bound);
-    }
-    this.min = getBound(a);
-    this.max = getBound(b);
-  }
-
-  // union(interval: Interval): MathSet {
-  //[a,b] [c,d]
-  //si a=c return a, max(b,d)
-  //si si b = d return min(a,c), b
-  //si a=d return c,b sauf si  OXXO
-  //si b=c return a,d sauf si XOOX
-  //si c > b ou d < a alors union disjointe avec plus petit en 1er
-  //sinon return min(a,c), max(b,d)
-  //res = a
-  // return new MathSet();
-  // }
-  exclude(nb: number) {
-    const rand = () => {
-      let x;
-      do {
-        x = this.getRandomElement();
-      } while (x.value === nb);
-      return x;
-    };
-    return new MathSet(this.toTex() + `\\{${nb}\\}`, rand);
-  }
-
-  difference(set: DiscreteSet): MathSet {
-    const rand = () => {
-      let x;
-      do {
-        x = this.getRandomElement();
-      } while (set.includes(x));
-      return x;
-    };
-
-    return new MathSet(this.toTex() + `\\ ${set.toTex()}`, rand);
-  }
-
-  toTex(): string {
-    return this.tex;
-  }
-
-  getRandomElement(
-    precision: number = this.type === NumberType.Integer ? 0 : 2
-  ): Nombre {
-    if (this.min === -Infinity || this.max === Infinity)
-      throw Error("Can't chose amongst infinity");
-    let min =
-      this.boundType === BoundType.OO || this.boundType === BoundType.OF
-        ? this.min + EPSILON
-        : this.min;
-    let max =
-      this.boundType === BoundType.OO || this.boundType === BoundType.FO
-        ? this.max - EPSILON
-        : this.max;
-    const value = round(min + Math.random() * (max - this.min), precision);
-    switch (this.type) {
-      case NumberType.Integer:
-        return new Integer(value);
-      default:
-        return new Real(value, value.toString());
-    }
-  }
-}

package/src/sets/mathSet.js

@@ -1,11 +0,0 @@
-"use strict";
-exports.__esModule = true;
-exports.MathSet = void 0;
-var MathSet = /** @class */ (function () {
-    function MathSet(tex, getRandomElement) {
-        this.tex = tex;
-        this.getRandomElement = getRandomElement;
-    }
-    return MathSet;
-}());
-exports.MathSet = MathSet;

package/src/sets/mathSet.ts

@@ -1,12 +0,0 @@
-import { Nombre } from "../numbers/nombre";
-import { DiscreteSet } from "./discreteSet";
-import { MathSetInterface } from "./mathSetInterface";
-
-export class MathSet implements MathSetInterface {
-  tex: string;
-  getRandomElement: () => Nombre;
-  constructor(tex: string, getRandomElement: () => Nombre) {
-    this.tex = tex;
-    this.getRandomElement = getRandomElement;
-  }
-}

package/src/sets/mathSetInterface.js

@@ -1,2 +0,0 @@
-"use strict";
-exports.__esModule = true;

package/src/sets/mathSetInterface.ts

@@ -1,10 +0,0 @@
-import { Nombre } from "../numbers/nombre";
-
-export interface MathSetInterface {
-  tex: string;
-  getRandomElement: () => Nombre;
-  //   constructor(tex: string, getRandomElement: () => number) {
-  //     this.tex = tex;
-  //     this.getRandomElement = getRandomElement;
-  //   }
-}

package/src/tree/latexParser/latexParse.js

@@ -1,117 +0,0 @@
-"use strict";
-exports.__esModule = true;
-exports.latexParse = void 0;
-var functionNode_1 = require("../nodes/functions/functionNode");
-var node_1 = require("../nodes/node");
-var operatorNode_1 = require("../nodes/operators/operatorNode");
-function latexParse(node) {
-    if (!node) {
-        console.log("parsing a null node ???");
-        return "";
-    }
-    switch (node.type) {
-        case node_1.NodeType.variable:
-            return node.tex;
-        case node_1.NodeType.number:
-            return node.tex;
-        case node_1.NodeType.operator:
-            var operatorNode = node;
-            var rightTex = latexParse(operatorNode.rightChild);
-            var leftTex = latexParse(operatorNode.leftChild);
-            var leftChild = operatorNode.leftChild, rightChild = operatorNode.rightChild;
-            switch (operatorNode.id) {
-                case operatorNode_1.OperatorIds.add:
-                    return "".concat(leftTex, " ").concat(rightTex[0] === "-" ? "" : "+ ").concat(rightTex);
-                case operatorNode_1.OperatorIds.substract: {
-                    var needBrackets = (rightChild.type === node_1.NodeType.operator &&
-                        [operatorNode_1.OperatorIds.add, operatorNode_1.OperatorIds.substract].includes(rightChild.id)) ||
-                        rightTex[0] === "-";
-                    if (needBrackets)
-                        rightTex = "(".concat(rightTex, ")");
-                    return "".concat(leftTex, " - ").concat(rightTex);
-                }
-                case operatorNode_1.OperatorIds.multiply: {
-                    if (leftChild.type === node_1.NodeType.operator) {
-                        if ([operatorNode_1.OperatorIds.add, operatorNode_1.OperatorIds.substract, operatorNode_1.OperatorIds.divide].includes(leftChild.id))
-                            leftTex = "(".concat(leftTex, ")");
-                    }
-                    var needBrackets = rightTex[0] === "-";
-                    if (rightChild.type === node_1.NodeType.operator) {
-                        var operatorRightChild = rightChild;
-                        needBrackets || (needBrackets = [operatorNode_1.OperatorIds.add, operatorNode_1.OperatorIds.substract].includes(operatorRightChild.id));
-                    }
-                    if (needBrackets)
-                        rightTex = "(".concat(rightTex, ")");
-                    //  permet de gérer le cas 3*2^x
-                    var showTimesSign = !isNaN(+rightTex[0]) || rightChild.type === node_1.NodeType.number;
-                    if (rightChild.type === node_1.NodeType.operator) {
-                        var operatorRightChild = rightChild;
-                        showTimesSign || (showTimesSign = [operatorNode_1.OperatorIds.fraction].includes(operatorRightChild.id));
-                    }
-                    return "".concat(leftTex).concat(showTimesSign ? "\\times " : "").concat(rightTex);
-                }
-                case operatorNode_1.OperatorIds.divide: {
-                    if (leftChild.type === node_1.NodeType.operator) {
-                        if ([operatorNode_1.OperatorIds.add, operatorNode_1.OperatorIds.substract, operatorNode_1.OperatorIds.multiply].includes(leftChild.id))
-                            leftTex = "(".concat(leftTex, ")");
-                    }
-                    var needBrackets = rightTex[0] === "-";
-                    if (rightChild.type === node_1.NodeType.operator) {
-                        var operatorRightChild = rightChild;
-                        needBrackets || (needBrackets = [operatorNode_1.OperatorIds.add, operatorNode_1.OperatorIds.substract].includes(operatorRightChild.id));
-                    }
-                    if (needBrackets)
-                        rightTex = "(".concat(rightTex, ")");
-                    return "".concat(leftTex, " \\div ").concat(rightTex);
-                }
-                case operatorNode_1.OperatorIds.fraction: {
-                    return "\\frac{".concat(leftTex, "}{").concat(rightTex, "}");
-                }
-                case operatorNode_1.OperatorIds.power: {
-                    var needBrackets = leftTex[0] === "-";
-                    if (leftChild.type === node_1.NodeType.operator) {
-                        var childOperator = leftChild;
-                        needBrackets || (needBrackets = [
-                            operatorNode_1.OperatorIds.add,
-                            operatorNode_1.OperatorIds.substract,
-                            operatorNode_1.OperatorIds.multiply,
-                            operatorNode_1.OperatorIds.divide,
-                            operatorNode_1.OperatorIds.fraction,
-                            operatorNode_1.OperatorIds.power,
-                        ].includes(childOperator.id));
-                    }
-                    if (needBrackets)
-                        leftTex = "(".concat(leftTex, ")");
-                    return "".concat(leftTex, "^{").concat(rightTex, "}");
-                }
-                case operatorNode_1.OperatorIds.equal: {
-                    return "".concat(leftTex, " = ").concat(rightTex);
-                }
-                default:
-                    return node.tex;
-            }
-        case node_1.NodeType["function"]: {
-            var functionNode = node;
-            var child = functionNode.child;
-            var childTex = latexParse(functionNode.child);
-            switch (functionNode.id) {
-                case functionNode_1.FunctionsIds.sqrt: {
-                    return "\\sqrt{".concat(childTex, "}");
-                }
-                case functionNode_1.FunctionsIds.opposite: {
-                    var needBrackets = childTex[0] === "-";
-                    if (child.type === node_1.NodeType.operator) {
-                        var operatorChild = child;
-                        needBrackets || (needBrackets = [operatorNode_1.OperatorIds.add, operatorNode_1.OperatorIds.substract].includes(operatorChild.id));
-                    }
-                    if (needBrackets)
-                        childTex = "(".concat(childTex, ")");
-                    return "-".concat(childTex);
-                }
-            }
-        }
-        default:
-            return "";
-    }
-}
-exports.latexParse = latexParse;