simple-squiggle

A restricted subset of Squiggle
Log | Files | Refs | README

ceil.js (4488B)

      1 import Decimal from 'decimal.js';
      2 import { factory } from '../../utils/factory.js';
      3 import { deepMap } from '../../utils/collection.js';
      4 import { nearlyEqual } from '../../utils/number.js';
      5 import { nearlyEqual as bigNearlyEqual } from '../../utils/bignumber/nearlyEqual.js';
      6 import { ceilNumber } from '../../plain/number/index.js';
      7 import { createAlgorithm11 } from '../../type/matrix/utils/algorithm11.js';
      8 import { createAlgorithm14 } from '../../type/matrix/utils/algorithm14.js';
      9 var name = 'ceil';
     10 var dependencies = ['typed', 'config', 'round', 'matrix', 'equalScalar'];
     11 export var createCeil = /* #__PURE__ */factory(name, dependencies, _ref => {
     12   var {
     13     typed,
     14     config,
     15     round,
     16     matrix,
     17     equalScalar
     18   } = _ref;
     19   var algorithm11 = createAlgorithm11({
     20     typed,
     21     equalScalar
     22   });
     23   var algorithm14 = createAlgorithm14({
     24     typed
     25   });
     26   /**
     27    * Round a value towards plus infinity
     28    * If `x` is complex, both real and imaginary part are rounded towards plus infinity.
     29    * For matrices, the function is evaluated element wise.
     30    *
     31    * Syntax:
     32    *
     33    *    math.ceil(x)
     34    *    math.ceil(x, n)
     35    *
     36    * Examples:
     37    *
     38    *    math.ceil(3.2)               // returns number 4
     39    *    math.ceil(3.8)               // returns number 4
     40    *    math.ceil(-4.2)              // returns number -4
     41    *    math.ceil(-4.7)              // returns number -4
     42    *
     43    *    math.ceil(3.212, 2)          // returns number 3.22
     44    *    math.ceil(3.288, 2)          // returns number 3.29
     45    *    math.ceil(-4.212, 2)         // returns number -4.21
     46    *    math.ceil(-4.782, 2)         // returns number -4.78
     47    *
     48    *    const c = math.complex(3.24, -2.71)
     49    *    math.ceil(c)                 // returns Complex 4 - 2i
     50    *    math.ceil(c, 1)              // returns Complex 3.3 - 2.7i
     51    *
     52    *    math.ceil([3.2, 3.8, -4.7])  // returns Array [4, 4, -4]
     53    *    math.ceil([3.21, 3.82, -4.71], 1)  // returns Array [3.3, 3.9, -4.7]
     54    *
     55    * See also:
     56    *
     57    *    floor, fix, round
     58    *
     59    * @param  {number | BigNumber | Fraction | Complex | Array | Matrix} x  Number to be rounded
     60    * @param  {number | BigNumber | Array} [n=0]                            Number of decimals
     61    * @return {number | BigNumber | Fraction | Complex | Array | Matrix} Rounded value
     62    */
     63 
     64   return typed('ceil', {
     65     number: function number(x) {
     66       if (nearlyEqual(x, round(x), config.epsilon)) {
     67         return round(x);
     68       } else {
     69         return ceilNumber(x);
     70       }
     71     },
     72     'number, number': function numberNumber(x, n) {
     73       if (nearlyEqual(x, round(x, n), config.epsilon)) {
     74         return round(x, n);
     75       } else {
     76         var [number, exponent] = "".concat(x, "e").split('e');
     77         var result = Math.ceil(Number("".concat(number, "e").concat(Number(exponent) + n)));
     78         [number, exponent] = "".concat(result, "e").split('e');
     79         return Number("".concat(number, "e").concat(Number(exponent) - n));
     80       }
     81     },
     82     Complex: function Complex(x) {
     83       return x.ceil();
     84     },
     85     'Complex, number': function ComplexNumber(x, n) {
     86       return x.ceil(n);
     87     },
     88     BigNumber: function BigNumber(x) {
     89       if (bigNearlyEqual(x, round(x), config.epsilon)) {
     90         return round(x);
     91       } else {
     92         return x.ceil();
     93       }
     94     },
     95     'BigNumber, BigNumber': function BigNumberBigNumber(x, n) {
     96       if (bigNearlyEqual(x, round(x, n), config.epsilon)) {
     97         return round(x, n);
     98       } else {
     99         return x.toDecimalPlaces(n.toNumber(), Decimal.ROUND_CEIL);
    100       }
    101     },
    102     Fraction: function Fraction(x) {
    103       return x.ceil();
    104     },
    105     'Fraction, number': function FractionNumber(x, n) {
    106       return x.ceil(n);
    107     },
    108     'Array | Matrix': function ArrayMatrix(x) {
    109       // deep map collection, skip zeros since ceil(0) = 0
    110       return deepMap(x, this, true);
    111     },
    112     'Array | Matrix, number': function ArrayMatrixNumber(x, n) {
    113       // deep map collection, skip zeros since ceil(0) = 0
    114       return deepMap(x, i => this(i, n), true);
    115     },
    116     'SparseMatrix, number | BigNumber': function SparseMatrixNumberBigNumber(x, y) {
    117       return algorithm11(x, y, this, false);
    118     },
    119     'DenseMatrix, number | BigNumber': function DenseMatrixNumberBigNumber(x, y) {
    120       return algorithm14(x, y, this, false);
    121     },
    122     'number | Complex | BigNumber, Array': function numberComplexBigNumberArray(x, y) {
    123       // use matrix implementation
    124       return algorithm14(matrix(y), x, this, true).valueOf();
    125     }
    126   });
    127 });