mathjs-min 11.7.2

package/lib/cjs/function/arithmetic/dotMultiply.js

@@ -0,0 +1,71 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createDotMultiply = void 0;
+var _factory = require("../../utils/factory.js");
+var _matAlgo02xDS = require("../../type/matrix/utils/matAlgo02xDS0.js");
+var _matAlgo09xS0Sf = require("../../type/matrix/utils/matAlgo09xS0Sf.js");
+var _matAlgo11xS0s = require("../../type/matrix/utils/matAlgo11xS0s.js");
+var _matrixAlgorithmSuite = require("../../type/matrix/utils/matrixAlgorithmSuite.js");
+var name = 'dotMultiply';
+var dependencies = ['typed', 'matrix', 'equalScalar', 'multiplyScalar', 'concat'];
+var createDotMultiply = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+    matrix = _ref.matrix,
+    equalScalar = _ref.equalScalar,
+    multiplyScalar = _ref.multiplyScalar,
+    concat = _ref.concat;
+  var matAlgo02xDS0 = (0, _matAlgo02xDS.createMatAlgo02xDS0)({
+    typed: typed,
+    equalScalar: equalScalar
+  });
+  var matAlgo09xS0Sf = (0, _matAlgo09xS0Sf.createMatAlgo09xS0Sf)({
+    typed: typed,
+    equalScalar: equalScalar
+  });
+  var matAlgo11xS0s = (0, _matAlgo11xS0s.createMatAlgo11xS0s)({
+    typed: typed,
+    equalScalar: equalScalar
+  });
+  var matrixAlgorithmSuite = (0, _matrixAlgorithmSuite.createMatrixAlgorithmSuite)({
+    typed: typed,
+    matrix: matrix,
+    concat: concat
+  });
+
+  /**
+   * Multiply two matrices element wise. The function accepts both matrices and
+   * scalar values.
+   *
+   * Syntax:
+   *
+   *    math.dotMultiply(x, y)
+   *
+   * Examples:
+   *
+   *    math.dotMultiply(2, 4) // returns 8
+   *
+   *    a = [[9, 5], [6, 1]]
+   *    b = [[3, 2], [5, 2]]
+   *
+   *    math.dotMultiply(a, b) // returns [[27, 10], [30, 2]]
+   *    math.multiply(a, b)    // returns [[52, 28], [23, 14]]
+   *
+   * See also:
+   *
+   *    multiply, divide, dotDivide
+   *
+   * @param  {number | BigNumber | Fraction | Complex | Unit | Array | Matrix} x Left hand value
+   * @param  {number | BigNumber | Fraction | Complex | Unit | Array | Matrix} y Right hand value
+   * @return {number | BigNumber | Fraction | Complex | Unit | Array | Matrix}                    Multiplication of `x` and `y`
+   */
+  return typed(name, matrixAlgorithmSuite({
+    elop: multiplyScalar,
+    SS: matAlgo09xS0Sf,
+    DS: matAlgo02xDS0,
+    Ss: matAlgo11xS0s
+  }));
+});
+exports.createDotMultiply = createDotMultiply;

package/lib/cjs/function/arithmetic/dotPow.js

@@ -0,0 +1,83 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createDotPow = void 0;
+var _factory = require("../../utils/factory.js");
+var _matAlgo03xDSf = require("../../type/matrix/utils/matAlgo03xDSf.js");
+var _matAlgo07xSSf = require("../../type/matrix/utils/matAlgo07xSSf.js");
+var _matAlgo11xS0s = require("../../type/matrix/utils/matAlgo11xS0s.js");
+var _matAlgo12xSfs = require("../../type/matrix/utils/matAlgo12xSfs.js");
+var _matrixAlgorithmSuite = require("../../type/matrix/utils/matrixAlgorithmSuite.js");
+var name = 'dotPow';
+var dependencies = ['typed', 'equalScalar', 'matrix', 'pow', 'DenseMatrix', 'concat'];
+var createDotPow = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+    equalScalar = _ref.equalScalar,
+    matrix = _ref.matrix,
+    pow = _ref.pow,
+    DenseMatrix = _ref.DenseMatrix,
+    concat = _ref.concat;
+  var matAlgo03xDSf = (0, _matAlgo03xDSf.createMatAlgo03xDSf)({
+    typed: typed
+  });
+  var matAlgo07xSSf = (0, _matAlgo07xSSf.createMatAlgo07xSSf)({
+    typed: typed,
+    DenseMatrix: DenseMatrix
+  });
+  var matAlgo11xS0s = (0, _matAlgo11xS0s.createMatAlgo11xS0s)({
+    typed: typed,
+    equalScalar: equalScalar
+  });
+  var matAlgo12xSfs = (0, _matAlgo12xSfs.createMatAlgo12xSfs)({
+    typed: typed,
+    DenseMatrix: DenseMatrix
+  });
+  var matrixAlgorithmSuite = (0, _matrixAlgorithmSuite.createMatrixAlgorithmSuite)({
+    typed: typed,
+    matrix: matrix,
+    concat: concat
+  });
+  var powScalarSignatures = {};
+  for (var signature in pow.signatures) {
+    if (Object.prototype.hasOwnProperty.call(pow.signatures, signature)) {
+      if (!signature.includes('Matrix') && !signature.includes('Array')) {
+        powScalarSignatures[signature] = pow.signatures[signature];
+      }
+    }
+  }
+  var powScalar = typed(powScalarSignatures);
+
+  /**
+   * Calculates the power of x to y element wise.
+   *
+   * Syntax:
+   *
+   *    math.dotPow(x, y)
+   *
+   * Examples:
+   *
+   *    math.dotPow(2, 3)            // returns number 8
+   *
+   *    const a = [[1, 2], [4, 3]]
+   *    math.dotPow(a, 2)            // returns Array [[1, 4], [16, 9]]
+   *    math.pow(a, 2)               // returns Array [[9, 8], [16, 17]]
+   *
+   * See also:
+   *
+   *    pow, sqrt, multiply
+   *
+   * @param  {number | BigNumber | Complex | Unit | Array | Matrix} x  The base
+   * @param  {number | BigNumber | Complex | Unit | Array | Matrix} y  The exponent
+   * @return {number | BigNumber | Complex | Unit | Array | Matrix}                     The value of `x` to the power `y`
+   */
+  return typed(name, matrixAlgorithmSuite({
+    elop: powScalar,
+    SS: matAlgo07xSSf,
+    DS: matAlgo03xDSf,
+    Ss: matAlgo11xS0s,
+    sS: matAlgo12xSfs
+  }));
+});
+exports.createDotPow = createDotPow;

package/lib/cjs/function/arithmetic/exp.js

@@ -0,0 +1,53 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createExp = void 0;
+var _factory = require("../../utils/factory.js");
+var _index = require("../../plain/number/index.js");
+var name = 'exp';
+var dependencies = ['typed'];
+var createExp = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed;
+  /**
+   * Calculate the exponential of a value.
+   * For matrices, if you want the matrix exponential of square matrix, use
+   * the `expm` function; if you want to take the exponential of each element,
+   * see the examples.
+   *
+   * Syntax:
+   *
+   *    math.exp(x)
+   *
+   * Examples:
+   *
+   *    math.exp(2)                  // returns number 7.3890560989306495
+   *    math.pow(math.e, 2)          // returns number 7.3890560989306495
+   *    math.log(math.exp(2))        // returns number 2
+   *
+   *    math.map([1, 2, 3], math.exp)
+   *    // returns Array [
+   *    //   2.718281828459045,
+   *    //   7.3890560989306495,
+   *    //   20.085536923187668
+   *    // ]
+   *
+   * See also:
+   *
+   *    expm1, expm, log, pow
+   *
+   * @param {number | BigNumber | Complex} x  A number to exponentiate
+   * @return {number | BigNumber | Complex} Exponential of `x`
+   */
+  return typed(name, {
+    number: _index.expNumber,
+    Complex: function Complex(x) {
+      return x.exp();
+    },
+    BigNumber: function BigNumber(x) {
+      return x.exp();
+    }
+  });
+});
+exports.createExp = createExp;

package/lib/cjs/function/arithmetic/expm1.js

@@ -0,0 +1,58 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createExpm1 = void 0;
+var _factory = require("../../utils/factory.js");
+var _index = require("../../plain/number/index.js");
+var name = 'expm1';
+var dependencies = ['typed', 'Complex'];
+var createExpm1 = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+    _Complex = _ref.Complex;
+  /**
+   * Calculate the value of subtracting 1 from the exponential value.
+   * This function is more accurate than `math.exp(x)-1` when `x` is near 0
+   * To avoid ambiguity with the matrix exponential `expm`, this function
+   * does not operate on matrices; if you wish to apply it elementwise, see
+   * the examples.
+   *
+   * Syntax:
+   *
+   *    math.expm1(x)
+   *
+   * Examples:
+   *
+   *    math.expm1(2)                      // returns number 6.38905609893065
+   *    math.pow(math.e, 2) - 1            // returns number 6.3890560989306495
+   *    math.expm1(1e-8)                   // returns number 1.0000000050000001e-8
+   *    math.exp(1e-8) - 1                 // returns number 9.9999999392253e-9
+   *    math.log(math.expm1(2) + 1)        // returns number 2
+   *
+   *    math.map([1, 2, 3], math.expm1)
+   *    // returns Array [
+   *    //   1.718281828459045,
+   *    //   6.3890560989306495,
+   *    //   19.085536923187668
+   *    // ]
+   *
+   * See also:
+   *
+   *    exp, expm, log, pow
+   *
+   * @param {number | BigNumber | Complex} x  The number to exponentiate
+   * @return {number | BigNumber | Complex} Exponential of `x`, minus one
+   */
+  return typed(name, {
+    number: _index.expm1Number,
+    Complex: function Complex(x) {
+      var r = Math.exp(x.re);
+      return new _Complex(r * Math.cos(x.im) - 1, r * Math.sin(x.im));
+    },
+    BigNumber: function BigNumber(x) {
+      return x.exp().minus(1);
+    }
+  });
+});
+exports.createExpm1 = createExpm1;

package/lib/cjs/function/arithmetic/fix.js

@@ -0,0 +1,140 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createFixNumber = exports.createFix = void 0;
+var _factory = require("../../utils/factory.js");
+var _collection = require("../../utils/collection.js");
+var _matAlgo12xSfs = require("../../type/matrix/utils/matAlgo12xSfs.js");
+var _matAlgo14xDs = require("../../type/matrix/utils/matAlgo14xDs.js");
+var name = 'fix';
+var dependencies = ['typed', 'Complex', 'matrix', 'ceil', 'floor', 'equalScalar', 'zeros', 'DenseMatrix'];
+var createFixNumber = /* #__PURE__ */(0, _factory.factory)(name, ['typed', 'ceil', 'floor'], function (_ref) {
+  var typed = _ref.typed,
+    ceil = _ref.ceil,
+    floor = _ref.floor;
+  return typed(name, {
+    number: function number(x) {
+      return x > 0 ? floor(x) : ceil(x);
+    },
+    'number, number': function numberNumber(x, n) {
+      return x > 0 ? floor(x, n) : ceil(x, n);
+    }
+  });
+});
+exports.createFixNumber = createFixNumber;
+var createFix = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref2) {
+  var typed = _ref2.typed,
+    _Complex = _ref2.Complex,
+    matrix = _ref2.matrix,
+    ceil = _ref2.ceil,
+    floor = _ref2.floor,
+    equalScalar = _ref2.equalScalar,
+    zeros = _ref2.zeros,
+    DenseMatrix = _ref2.DenseMatrix;
+  var matAlgo12xSfs = (0, _matAlgo12xSfs.createMatAlgo12xSfs)({
+    typed: typed,
+    DenseMatrix: DenseMatrix
+  });
+  var matAlgo14xDs = (0, _matAlgo14xDs.createMatAlgo14xDs)({
+    typed: typed
+  });
+  var fixNumber = createFixNumber({
+    typed: typed,
+    ceil: ceil,
+    floor: floor
+  });
+  /**
+   * Round a value towards zero.
+   * For matrices, the function is evaluated element wise.
+   *
+   * Syntax:
+   *
+   *    math.fix(x)
+   *    math.fix(x,n)
+   *
+   * Examples:
+   *
+   *    math.fix(3.2)                // returns number 3
+   *    math.fix(3.8)                // returns number 3
+   *    math.fix(-4.2)               // returns number -4
+   *    math.fix(-4.7)               // returns number -4
+   *
+   *    math.fix(3.12, 1)                // returns number 3.1
+   *    math.fix(3.18, 1)                // returns number 3.1
+   *    math.fix(-4.12, 1)               // returns number -4.1
+   *    math.fix(-4.17, 1)               // returns number -4.1
+   *
+   *    const c = math.complex(3.22, -2.78)
+   *    math.fix(c)                  // returns Complex 3 - 2i
+   *    math.fix(c, 1)               // returns Complex 3.2 -2.7i
+   *
+   *    math.fix([3.2, 3.8, -4.7])      // returns Array [3, 3, -4]
+   *    math.fix([3.2, 3.8, -4.7], 1)   // returns Array [3.2, 3.8, -4.7]
+   *
+   * See also:
+   *
+   *    ceil, floor, round
+   *
+   * @param  {number | BigNumber | Fraction | Complex | Array | Matrix} x    Number to be rounded
+   * @param  {number | BigNumber | Array} [n=0]                             Number of decimals
+   * @return {number | BigNumber | Fraction | Complex | Array | Matrix}     Rounded value
+   */
+  return typed('fix', {
+    number: fixNumber.signatures.number,
+    'number, number | BigNumber': fixNumber.signatures['number,number'],
+    Complex: function Complex(x) {
+      return new _Complex(x.re > 0 ? Math.floor(x.re) : Math.ceil(x.re), x.im > 0 ? Math.floor(x.im) : Math.ceil(x.im));
+    },
+    'Complex, number': function ComplexNumber(x, n) {
+      return new _Complex(x.re > 0 ? floor(x.re, n) : ceil(x.re, n), x.im > 0 ? floor(x.im, n) : ceil(x.im, n));
+    },
+    'Complex, BigNumber': function ComplexBigNumber(x, bn) {
+      var n = bn.toNumber();
+      return new _Complex(x.re > 0 ? floor(x.re, n) : ceil(x.re, n), x.im > 0 ? floor(x.im, n) : ceil(x.im, n));
+    },
+    BigNumber: function BigNumber(x) {
+      return x.isNegative() ? ceil(x) : floor(x);
+    },
+    'BigNumber, number | BigNumber': function BigNumberNumberBigNumber(x, n) {
+      return x.isNegative() ? ceil(x, n) : floor(x, n);
+    },
+    Fraction: function Fraction(x) {
+      return x.s < 0 ? x.ceil() : x.floor();
+    },
+    'Fraction, number | BigNumber': function FractionNumberBigNumber(x, n) {
+      return x.s < 0 ? ceil(x, n) : floor(x, n);
+    },
+    'Array | Matrix': typed.referToSelf(function (self) {
+      return function (x) {
+        // deep map collection, skip zeros since fix(0) = 0
+        return (0, _collection.deepMap)(x, self, true);
+      };
+    }),
+    'Array | Matrix, number | BigNumber': typed.referToSelf(function (self) {
+      return function (x, n) {
+        // deep map collection, skip zeros since fix(0) = 0
+        return (0, _collection.deepMap)(x, function (i) {
+          return self(i, n);
+        }, true);
+      };
+    }),
+    'number | Complex | Fraction | BigNumber, Array': typed.referToSelf(function (self) {
+      return function (x, y) {
+        // use matrix implementation
+        return matAlgo14xDs(matrix(y), x, self, true).valueOf();
+      };
+    }),
+    'number | Complex | Fraction | BigNumber, Matrix': typed.referToSelf(function (self) {
+      return function (x, y) {
+        if (equalScalar(x, 0)) return zeros(y.size(), y.storage());
+        if (y.storage() === 'dense') {
+          return matAlgo14xDs(y, x, self, true);
+        }
+        return matAlgo12xSfs(y, x, self, true);
+      };
+    })
+  });
+});
+exports.createFix = createFix;

package/lib/cjs/function/arithmetic/floor.js

@@ -0,0 +1,190 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createFloorNumber = exports.createFloor = void 0;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _decimal = _interopRequireDefault(require("decimal.js"));
+var _factory = require("../../utils/factory.js");
+var _collection = require("../../utils/collection.js");
+var _number = require("../../utils/number.js");
+var _nearlyEqual = require("../../utils/bignumber/nearlyEqual.js");
+var _matAlgo11xS0s = require("../../type/matrix/utils/matAlgo11xS0s.js");
+var _matAlgo12xSfs = require("../../type/matrix/utils/matAlgo12xSfs.js");
+var _matAlgo14xDs = require("../../type/matrix/utils/matAlgo14xDs.js");
+var name = 'floor';
+var dependencies = ['typed', 'config', 'round', 'matrix', 'equalScalar', 'zeros', 'DenseMatrix'];
+var createFloorNumber = /* #__PURE__ */(0, _factory.factory)(name, ['typed', 'config', 'round'], function (_ref) {
+  var typed = _ref.typed,
+    config = _ref.config,
+    round = _ref.round;
+  return typed(name, {
+    number: function number(x) {
+      if ((0, _number.nearlyEqual)(x, round(x), config.epsilon)) {
+        return round(x);
+      } else {
+        return Math.floor(x);
+      }
+    },
+    'number, number': function numberNumber(x, n) {
+      if ((0, _number.nearlyEqual)(x, round(x, n), config.epsilon)) {
+        return round(x, n);
+      } else {
+        var _split = "".concat(x, "e").split('e'),
+          _split2 = (0, _slicedToArray2["default"])(_split, 2),
+          number = _split2[0],
+          exponent = _split2[1];
+        var result = Math.floor(Number("".concat(number, "e").concat(Number(exponent) + n)));
+        var _split3 = "".concat(result, "e").split('e');
+        var _split4 = (0, _slicedToArray2["default"])(_split3, 2);
+        number = _split4[0];
+        exponent = _split4[1];
+        return Number("".concat(number, "e").concat(Number(exponent) - n));
+      }
+    }
+  });
+});
+exports.createFloorNumber = createFloorNumber;
+var createFloor = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref2) {
+  var typed = _ref2.typed,
+    config = _ref2.config,
+    round = _ref2.round,
+    matrix = _ref2.matrix,
+    equalScalar = _ref2.equalScalar,
+    zeros = _ref2.zeros,
+    DenseMatrix = _ref2.DenseMatrix;
+  var matAlgo11xS0s = (0, _matAlgo11xS0s.createMatAlgo11xS0s)({
+    typed: typed,
+    equalScalar: equalScalar
+  });
+  var matAlgo12xSfs = (0, _matAlgo12xSfs.createMatAlgo12xSfs)({
+    typed: typed,
+    DenseMatrix: DenseMatrix
+  });
+  var matAlgo14xDs = (0, _matAlgo14xDs.createMatAlgo14xDs)({
+    typed: typed
+  });
+  var floorNumber = createFloorNumber({
+    typed: typed,
+    config: config,
+    round: round
+  });
+  /**
+   * Round a value towards minus infinity.
+   * For matrices, the function is evaluated element wise.
+   *
+   * Syntax:
+   *
+   *    math.floor(x)
+   *    math.floor(x, n)
+   *
+   * Examples:
+   *
+   *    math.floor(3.2)              // returns number 3
+   *    math.floor(3.8)              // returns number 3
+   *    math.floor(-4.2)             // returns number -5
+   *    math.floor(-4.7)             // returns number -5
+   *
+   *    math.floor(3.212, 2)          // returns number 3.21
+   *    math.floor(3.288, 2)          // returns number 3.28
+   *    math.floor(-4.212, 2)         // returns number -4.22
+   *    math.floor(-4.782, 2)         // returns number -4.79
+   *
+   *    const c = math.complex(3.24, -2.71)
+   *    math.floor(c)                 // returns Complex 3 - 3i
+   *    math.floor(c, 1)              // returns Complex 3.2 -2.8i
+   *
+   *    math.floor([3.2, 3.8, -4.7])       // returns Array [3, 3, -5]
+   *    math.floor([3.21, 3.82, -4.71], 1)  // returns Array [3.2, 3.8, -4.8]
+   *
+   *    math.floor(math.tau, [2, 3])  // returns Array [6.28, 6.283]
+   *
+   *    // Note that floor(array, array) currently not implemented.
+   *
+   * See also:
+   *
+   *    ceil, fix, round
+   *
+   * @param  {number | BigNumber | Fraction | Complex | Array | Matrix} x  Number to be rounded
+   * @param  {number | BigNumber | Array} [n=0]                            Number of decimals
+   * @return {number | BigNumber | Fraction | Complex | Array | Matrix} Rounded value
+   */
+  return typed('floor', {
+    number: floorNumber.signatures.number,
+    'number,number': floorNumber.signatures['number,number'],
+    Complex: function Complex(x) {
+      return x.floor();
+    },
+    'Complex, number': function ComplexNumber(x, n) {
+      return x.floor(n);
+    },
+    'Complex, BigNumber': function ComplexBigNumber(x, n) {
+      return x.floor(n.toNumber());
+    },
+    BigNumber: function BigNumber(x) {
+      if ((0, _nearlyEqual.nearlyEqual)(x, round(x), config.epsilon)) {
+        return round(x);
+      } else {
+        return x.floor();
+      }
+    },
+    'BigNumber, BigNumber': function BigNumberBigNumber(x, n) {
+      if ((0, _nearlyEqual.nearlyEqual)(x, round(x, n), config.epsilon)) {
+        return round(x, n);
+      } else {
+        return x.toDecimalPlaces(n.toNumber(), _decimal["default"].ROUND_FLOOR);
+      }
+    },
+    Fraction: function Fraction(x) {
+      return x.floor();
+    },
+    'Fraction, number': function FractionNumber(x, n) {
+      return x.floor(n);
+    },
+    'Fraction, BigNumber': function FractionBigNumber(x, n) {
+      return x.floor(n.toNumber());
+    },
+    'Array | Matrix': typed.referToSelf(function (self) {
+      return function (x) {
+        // deep map collection, skip zeros since floor(0) = 0
+        return (0, _collection.deepMap)(x, self, true);
+      };
+    }),
+    'Array, number | BigNumber': typed.referToSelf(function (self) {
+      return function (x, n) {
+        // deep map collection, skip zeros since ceil(0) = 0
+        return (0, _collection.deepMap)(x, function (i) {
+          return self(i, n);
+        }, true);
+      };
+    }),
+    'SparseMatrix, number | BigNumber': typed.referToSelf(function (self) {
+      return function (x, y) {
+        return matAlgo11xS0s(x, y, self, false);
+      };
+    }),
+    'DenseMatrix, number | BigNumber': typed.referToSelf(function (self) {
+      return function (x, y) {
+        return matAlgo14xDs(x, y, self, false);
+      };
+    }),
+    'number | Complex | Fraction | BigNumber, Array': typed.referToSelf(function (self) {
+      return function (x, y) {
+        // use matrix implementation
+        return matAlgo14xDs(matrix(y), x, self, true).valueOf();
+      };
+    }),
+    'number | Complex | Fraction | BigNumber, Matrix': typed.referToSelf(function (self) {
+      return function (x, y) {
+        if (equalScalar(x, 0)) return zeros(y.size(), y.storage());
+        if (y.storage() === 'dense') {
+          return matAlgo14xDs(y, x, self, true);
+        }
+        return matAlgo12xSfs(y, x, self, true);
+      };
+    })
+  });
+});
+exports.createFloor = createFloor;