mathjs/es/factoriesNumber.js

Math.js is an extensive math library for JavaScript and Node.js. It features a flexible expression parser with support for symbolic computation, comes with a large set of built-in functions and constants, and offers an integrated solution to work with dif

import { absNumber, acoshNumber, acosNumber, acothNumber, acotNumber, acschNumber, acscNumber, addNumber, andNumber, asechNumber, asecNumber, asinhNumber, asinNumber, atan2Number, atanhNumber, atanNumber, bitAndNumber, bitNotNumber, bitOrNumber, bitXorNumber, cbrtNumber, ceilNumber, combinationsNumber, coshNumber, cosNumber, cothNumber, cotNumber, cschNumber, cscNumber, cubeNumber, divideNumber, expm1Number, expNumber, fixNumber, floorNumber, gammaNumber, gcdNumber, isIntegerNumber, isNaNNumber, isNegativeNumber, isPositiveNumber, isZeroNumber, lcmNumber, leftShiftNumber, log10Number, log1pNumber, log2Number, logNumber, modNumber, multiplyNumber, normNumber, notNumber, orNumber, powNumber, rightArithShiftNumber, rightLogShiftNumber, sechNumber, secNumber, signNumber, sinhNumber, sinNumber, sqrtNumber, squareNumber, subtractNumber, tanhNumber, tanNumber, unaryMinusNumber, unaryPlusNumber, xgcdNumber, xorNumber } from './plain/number';
import { factory } from './utils/factory';
import { noIndex, noMatrix, noSubset } from './utils/noop'; // ----------------------------------------------------------------------------
// classes and functions
// core

export { createTyped } from './core/function/typed'; // classes

export { createResultSet } from './type/resultset/ResultSet';
export { createRangeClass } from './type/matrix/Range';
export { createHelpClass } from './expression/Help';
export { createChainClass } from './type/chain/Chain';
export { createHelp } from './expression/function/help';
export { createChain } from './type/chain/function/chain'; // algebra

export { createSimplify } from './function/algebra/simplify';
export { createDerivative } from './function/algebra/derivative';
export { createRationalize } from './function/algebra/rationalize'; // arithmetic

export var createUnaryMinus = /* #__PURE__ */createNumberFactory('unaryMinus', unaryMinusNumber);
export var createUnaryPlus = /* #__PURE__ */createNumberFactory('unaryPlus', unaryPlusNumber);
export var createAbs = /* #__PURE__ */createNumberFactory('abs', absNumber);
export var createAddScalar = /* #__PURE__ */createNumberFactory('addScalar', addNumber);
export var createCbrt = /* #__PURE__ */createNumberFactory('cbrt', cbrtNumber);
export var createCeil = /* #__PURE__ */createNumberFactory('ceil', ceilNumber);
export var createCube = /* #__PURE__ */createNumberFactory('cube', cubeNumber);
export var createExp = /* #__PURE__ */createNumberFactory('exp', expNumber);
export var createExpm1 = /* #__PURE__ */createNumberFactory('expm1', expm1Number);
export var createFix = /* #__PURE__ */createNumberFactory('fix', fixNumber);
export var createFloor = /* #__PURE__ */createNumberFactory('floor', floorNumber);
export var createGcd = /* #__PURE__ */createNumberFactory('gcd', gcdNumber);
export var createLcm = /* #__PURE__ */createNumberFactory('lcm', lcmNumber);
export var createLog10 = /* #__PURE__ */createNumberFactory('log10', log10Number);
export var createLog2 = /* #__PURE__ */createNumberFactory('log2', log2Number);
export var createMod = /* #__PURE__ */createNumberFactory('mod', modNumber);
export var createMultiplyScalar = /* #__PURE__ */createNumberFactory('multiplyScalar', multiplyNumber);
export var createMultiply = /* #__PURE__ */createNumberFactory('multiply', multiplyNumber);
export { createNthRootNumber as createNthRoot } from './function/arithmetic/nthRoot';
export var createSign = /* #__PURE__ */createNumberFactory('sign', signNumber);
export var createSqrt = /* #__PURE__ */createNumberFactory('sqrt', sqrtNumber);
export var createSquare = /* #__PURE__ */createNumberFactory('square', squareNumber);
export var createSubtract = /* #__PURE__ */createNumberFactory('subtract', subtractNumber);
export var createXgcd = /* #__PURE__ */createNumberFactory('xgcd', xgcdNumber);
export var createDivideScalar = /* #__PURE__ */createNumberFactory('divideScalar', divideNumber);
export var createPow = /* #__PURE__ */createNumberFactory('pow', powNumber);
export { createRoundNumber as createRound } from './function/arithmetic/round';
export var createLog = /* #__PURE__ */createNumberFactory('log', logNumber);
export var createLog1p = /* #__PURE__ */createNumberFactory('log1p', log1pNumber);
export var createAdd = /* #__PURE__ */createNumberFactory('add', addNumber);
export { createHypot } from './function/arithmetic/hypot';
export var createNorm = /* #__PURE__ */createNumberFactory('norm', normNumber);
export var createDivide = /* #__PURE__ */createNumberFactory('divide', divideNumber); // bitwise

export var createBitAnd = /* #__PURE__ */createNumberFactory('bitAnd', bitAndNumber);
export var createBitNot = /* #__PURE__ */createNumberFactory('bitNot', bitNotNumber);
export var createBitOr = /* #__PURE__ */createNumberFactory('bitOr', bitOrNumber);
export var createBitXor = /* #__PURE__ */createNumberFactory('bitXor', bitXorNumber);
export var createLeftShift = /* #__PURE__ */createNumberFactory('leftShift', leftShiftNumber);
export var createRightArithShift = /* #__PURE__ */createNumberFactory('rightArithShift', rightArithShiftNumber);
export var createRightLogShift = /* #__PURE__ */createNumberFactory('rightLogShift', rightLogShiftNumber); // combinatorics

export { createStirlingS2 } from './function/combinatorics/stirlingS2';
export { createBellNumbers } from './function/combinatorics/bellNumbers';
export { createCatalan } from './function/combinatorics/catalan';
export { createComposition } from './function/combinatorics/composition'; // constants

export { createE, createUppercaseE, createFalse // createI,
, createInfinity, createLN10, createLN2, createLOG10E, createLOG2E, createNaN, createNull, createPhi, createPi, createUppercasePi, createSQRT1_2 // eslint-disable-line camelcase
, createSQRT2, createTau, createTrue, createVersion } from './constants'; // create

export { createNumber } from './type/number';
export { createString } from './type/string';
export { createBoolean } from './type/boolean';
export { createParser } from './expression/function/parser'; // expression

export { createNode } from './expression/node/Node';
export { createAccessorNode } from './expression/node/AccessorNode';
export { createArrayNode } from './expression/node/ArrayNode';
export { createAssignmentNode } from './expression/node/AssignmentNode';
export { createBlockNode } from './expression/node/BlockNode';
export { createConditionalNode } from './expression/node/ConditionalNode';
export { createConstantNode } from './expression/node/ConstantNode';
export { createFunctionAssignmentNode } from './expression/node/FunctionAssignmentNode';
export { createIndexNode } from './expression/node/IndexNode';
export { createObjectNode } from './expression/node/ObjectNode';
export { createOperatorNode } from './expression/node/OperatorNode';
export { createParenthesisNode } from './expression/node/ParenthesisNode';
export { createRangeNode } from './expression/node/RangeNode';
export { createRelationalNode } from './expression/node/RelationalNode';
export { createSymbolNode } from './expression/node/SymbolNode';
export { createFunctionNode } from './expression/node/FunctionNode';
export { createParse } from './expression/parse';
export { createCompile } from './expression/function/compile';
export { createEvaluate } from './expression/function/evaluate';
export { createParserClass } from './expression/Parser'; // logical

export var createAnd = /* #__PURE__ */createNumberFactory('and', andNumber);
export var createNot = /* #__PURE__ */createNumberFactory('not', notNumber);
export var createOr = /* #__PURE__ */createNumberFactory('or', orNumber);
export var createXor = /* #__PURE__ */createNumberFactory('xor', xorNumber); // matrix

export { createApply } from './function/matrix/apply';
export { createFilter } from './function/matrix/filter';
export { createForEach } from './function/matrix/forEach';
export { createMap } from './function/matrix/map';
export { createRange } from './function/matrix/range';
export { createSize } from './function/matrix/size'; // FIXME: create a lightweight "number" implementation of subset only supporting plain objects/arrays

export var createIndex = /* #__PURE__ */factory('index', [], function () {
  return noIndex;
});
export var createMatrix = /* #__PURE__ */factory('matrix', [], function () {
  return noMatrix;
}); // FIXME: needed now because subset transform needs it. Remove the need for it in subset

export var createSubset = /* #__PURE__ */factory('subset', [], function () {
  return noSubset;
}); // TODO: provide number+array implementations for map, filter, forEach, zeros, ...?
// TODO: create range implementation for range?

export { createPartitionSelect } from './function/matrix/partitionSelect'; // probability

export var createCombinations = createNumberFactory('combinations', combinationsNumber);
export var createGamma = createNumberFactory('gamma', gammaNumber);
export { createCombinationsWithRep } from './function/probability/combinationsWithRep';
export { createFactorial } from './function/probability/factorial';
export { createMultinomial } from './function/probability/multinomial';
export { createPermutations } from './function/probability/permutations';
export { createPickRandom } from './function/probability/pickRandom';
export { createRandomNumber as createRandom } from './function/probability/random';
export { createRandomInt } from './function/probability/randomInt'; // relational

export { createEqualScalarNumber as createEqualScalar } from './function/relational/equalScalar';
export { createCompareNumber as createCompare } from './function/relational/compare';
export { createCompareNatural } from './function/relational/compareNatural';
export { createCompareTextNumber as createCompareText } from './function/relational/compareText';
export { createEqualNumber as createEqual } from './function/relational/equal';
export { createEqualText } from './function/relational/equalText';
export { createSmallerNumber as createSmaller } from './function/relational/smaller';
export { createSmallerEqNumber as createSmallerEq } from './function/relational/smallerEq';
export { createLargerNumber as createLarger } from './function/relational/larger';
export { createLargerEqNumber as createLargerEq } from './function/relational/largerEq';
export { createDeepEqual } from './function/relational/deepEqual';
export { createUnequalNumber as createUnequal } from './function/relational/unequal'; // special

export { createErf } from './function/special/erf'; // statistics

export { createMode } from './function/statistics/mode';
export { createProd } from './function/statistics/prod';
export { createMax } from './function/statistics/max';
export { createMin } from './function/statistics/min';
export { createSum } from './function/statistics/sum';
export { createMean } from './function/statistics/mean';
export { createMedian } from './function/statistics/median';
export { createMad } from './function/statistics/mad';
export { createVariance } from './function/statistics/variance';
export { createQuantileSeq } from './function/statistics/quantileSeq';
export { createStd } from './function/statistics/std'; // string

export { createFormat } from './function/string/format';
export { createPrint } from './function/string/print'; // trigonometry

export var createAcos = /* #__PURE__ */createNumberFactory('acos', acosNumber);
export var createAcosh = /* #__PURE__ */createNumberFactory('acosh', acoshNumber);
export var createAcot = /* #__PURE__ */createNumberFactory('acot', acotNumber);
export var createAcoth = /* #__PURE__ */createNumberFactory('acoth', acothNumber);
export var createAcsc = /* #__PURE__ */createNumberFactory('acsc', acscNumber);
export var createAcsch = /* #__PURE__ */createNumberFactory('acsch', acschNumber);
export var createAsec = /* #__PURE__ */createNumberFactory('asec', asecNumber);
export var createAsech = /* #__PURE__ */createNumberFactory('asech', asechNumber);
export var createAsin = /* #__PURE__ */createNumberFactory('asin', asinNumber);
export var createAsinh = /* #__PURE__ */createNumberFactory('asinh', asinhNumber);
export var createAtan = /* #__PURE__ */createNumberFactory('atan', atanNumber);
export var createAtan2 = /* #__PURE__ */createNumberFactory('atan2', atan2Number);
export var createAtanh = /* #__PURE__ */createNumberFactory('atanh', atanhNumber);
export var createCos = /* #__PURE__ */createNumberFactory('cos', cosNumber);
export var createCosh = /* #__PURE__ */createNumberFactory('cosh', coshNumber);
export var createCot = /* #__PURE__ */createNumberFactory('cot', cotNumber);
export var createCoth = /* #__PURE__ */createNumberFactory('coth', cothNumber);
export var createCsc = /* #__PURE__ */createNumberFactory('csc', cscNumber);
export var createCsch = /* #__PURE__ */createNumberFactory('csch', cschNumber);
export var createSec = /* #__PURE__ */createNumberFactory('sec', secNumber);
export var createSech = /* #__PURE__ */createNumberFactory('sech', sechNumber);
export var createSin = /* #__PURE__ */createNumberFactory('sin', sinNumber);
export var createSinh = /* #__PURE__ */createNumberFactory('sinh', sinhNumber);
export var createTan = /* #__PURE__ */createNumberFactory('tan', tanNumber);
export var createTanh = /* #__PURE__ */createNumberFactory('tanh', tanhNumber); // transforms

export { createApplyTransform } from './expression/transform/apply.transform';
export { createFilterTransform } from './expression/transform/filter.transform';
export { createForEachTransform } from './expression/transform/forEach.transform';
export { createMapTransform } from './expression/transform/map.transform';
export { createMaxTransform } from './expression/transform/max.transform';
export { createMeanTransform } from './expression/transform/mean.transform';
export { createMinTransform } from './expression/transform/min.transform';
export { createRangeTransform } from './expression/transform/range.transform';
export { createSubsetTransform } from './expression/transform/subset.transform';
export { createStdTransform } from './expression/transform/std.transform';
export { createSumTransform } from './expression/transform/sum.transform';
export { createVarianceTransform } from './expression/transform/variance.transform'; // utils

export { createClone } from './function/utils/clone';
export var createIsInteger = /* #__PURE__ */createNumberFactory('isInteger', isIntegerNumber);
export var createIsNegative = /* #__PURE__ */createNumberFactory('isNegative', isNegativeNumber);
export { createIsNumeric } from './function/utils/isNumeric';
export { createHasNumericValue } from './function/utils/hasNumericValue';
export var createIsPositive = /* #__PURE__ */createNumberFactory('isPositive', isPositiveNumber);
export var createIsZero = /* #__PURE__ */createNumberFactory('isZero', isZeroNumber);
export var createIsNaN = /* #__PURE__ */createNumberFactory('isNaN', isNaNNumber);
export { createTypeOf } from './function/utils/typeOf';
export { createIsPrime } from './function/utils/isPrime';
export { createNumeric } from './function/utils/numeric'; // json

export { createReviver } from './json/reviver'; // helper function to create a factory function for a function which only needs typed-function

function createNumberFactory(name, fn) {
  return factory(name, ['typed'], function (_ref) {
    var typed = _ref.typed;
    return typed(fn);
  });
}