mathjs 10.0.0 → 10.6.4

package/docs/reference/functions.md

@@ -1,289 +0,0 @@
-# Function reference
-
-## Expression functions
-
-Function | Description
----- | -----------
-[math.compile(expr)](functions/compile.md) | Parse and compile an expression.
-[math.evaluate(expr [, scope])](functions/evaluate.md) | Evaluate an expression.
-[math.help(search)](functions/help.md) | Retrieve help on a function or data type.
-[math.parser()](functions/parser.md) | Create a parser.
-
-## Algebra functions
-
-Function | Description
----- | -----------
-[derivative(expr, variable)](functions/derivative.md) | Takes the derivative of an expression expressed in parser Nodes.
-[math.lsolve(L, b)](functions/lsolve.md) | Finds one solution of a linear equation system by forwards substitution.
-[math.lsolveAll(L, b)](functions/lsolveAll.md) | Finds all solutions of a linear equation system by forwards substitution.
-[math.lup(A)](functions/lup.md) | Calculate the Matrix LU decomposition with partial pivoting.
-[math.lusolve(A, b)](functions/lusolve.md) | Solves the linear system `A * x = b` where `A` is an [n x n] matrix and `b` is a [n] column vector.
-[math.qr(A)](functions/qr.md) | Calculate the Matrix QR decomposition.
-[rationalize(expr)](functions/rationalize.md) | Transform a rationalizable expression in a rational fraction.
-[simplify(expr)](functions/simplify.md) | Simplify an expression tree.
-[math.slu(A, order, threshold)](functions/slu.md) | Calculate the Sparse Matrix LU decomposition with full pivoting.
-[math.usolve(U, b)](functions/usolve.md) | Finds one solution of a linear equation system by backward substitution.
-[math.usolveAll(U, b)](functions/usolveAll.md) | Finds all solutions of a linear equation system by backward substitution.
-
-## Arithmetic functions
-
-Function | Description
----- | -----------
-[math.abs(x)](functions/abs.md) | Calculate the absolute value of a number.
-[math.add(x, y)](functions/add.md) | Add two or more values, `x + y`.
-[math.cbrt(x [, allRoots])](functions/cbrt.md) | Calculate the cubic root of a value.
-[math.ceil(x)](functions/ceil.md) | Round a value towards plus infinity If `x` is complex, both real and imaginary part are rounded towards plus infinity.
-[math.cube(x)](functions/cube.md) | Compute the cube of a value, `x * x * x`.
-[math.divide(x, y)](functions/divide.md) | Divide two values, `x / y`.
-[math.dotDivide(x, y)](functions/dotDivide.md) | Divide two matrices element wise.
-[math.dotMultiply(x, y)](functions/dotMultiply.md) | Multiply two matrices element wise.
-[math.dotPow(x, y)](functions/dotPow.md) | Calculates the power of x to y element wise.
-[math.exp(x)](functions/exp.md) | Calculate the exponent of a value.
-[math.expm1(x)](functions/expm1.md) | Calculate the value of subtracting 1 from the exponential value.
-[math.fix(x)](functions/fix.md) | Round a value towards zero.
-[math.floor(x)](functions/floor.md) | Round a value towards minus infinity.
-[math.gcd(a, b)](functions/gcd.md) | Calculate the greatest common divisor for two or more values or arrays.
-[math.hypot(a, b, ...)](functions/hypot.md) | Calculate the hypotenusa of a list with values.
-[math.lcm(a, b)](functions/lcm.md) | Calculate the least common multiple for two or more values or arrays.
-[math.log(x [, base])](functions/log.md) | Calculate the logarithm of a value.
-[math.log10(x)](functions/log10.md) | Calculate the 10-base logarithm of a value.
-[math.log1p(x)](functions/log1p.md) | Calculate the logarithm of a `value+1`.
-[math.log2(x)](functions/log2.md) | Calculate the 2-base of a value.
-[math.mod(x, y)](functions/mod.md) | Calculates the modulus, the remainder of an integer division.
-[math.multiply(x, y)](functions/multiply.md) | Multiply two or more values, `x * y`.
-[math.norm(x [, p])](functions/norm.md) | Calculate the norm of a number, vector or matrix.
-[math.nthRoot(a)](functions/nthRoot.md) | Calculate the nth root of a value.
-[math.nthRoots(x)](functions/nthRoots.md) | Calculate the nth roots of a value.
-[math.pow(x, y)](functions/pow.md) | Calculates the power of x to y, `x ^ y`.
-[math.round(x [, n])](functions/round.md) | Round a value towards the nearest integer.
-[math.sign(x)](functions/sign.md) | Compute the sign of a value.
-[math.sqrt(x)](functions/sqrt.md) | Calculate the square root of a value.
-[math.square(x)](functions/square.md) | Compute the square of a value, `x * x`.
-[math.subtract(x, y)](functions/subtract.md) | Subtract two values, `x - y`.
-[math.unaryMinus(x)](functions/unaryMinus.md) | Inverse the sign of a value, apply a unary minus operation.
-[math.unaryPlus(x)](functions/unaryPlus.md) | Unary plus operation.
-[math.xgcd(a, b)](functions/xgcd.md) | Calculate the extended greatest common divisor for two values.
-
-## Bitwise functions
-
-Function | Description
----- | -----------
-[math.bitAnd(x, y)](functions/bitAnd.md) | Bitwise AND two values, `x & y`.
-[math.bitNot(x)](functions/bitNot.md) | Bitwise NOT value, `~x`.
-[math.bitOr(x, y)](functions/bitOr.md) | Bitwise OR two values, `x | y`.
-[math.bitXor(x, y)](functions/bitXor.md) | Bitwise XOR two values, `x ^ y`.
-[math.leftShift(x,&nbsp;y)](functions/leftShift.md) | Bitwise left logical shift of a value x by y number of bits, `x << y`.
-[math.rightArithShift(x,&nbsp;y)](functions/rightArithShift.md) | Bitwise right arithmetic shift of a value x by y number of bits, `x >> y`.
-[math.rightLogShift(x,&nbsp;y)](functions/rightLogShift.md) | Bitwise right logical shift of value x by y number of bits, `x >>> y`.
-
-## Combinatorics functions
-
-Function | Description
----- | -----------
-[math.bellNumbers(n)](functions/bellNumbers.md) | The Bell Numbers count the number of partitions of a set.
-[math.catalan(n)](functions/catalan.md) | The Catalan Numbers enumerate combinatorial structures of many different types.
-[math.composition(n,&nbsp;k)](functions/composition.md) | The composition counts of n into k parts.
-[math.stirlingS2(n,&nbsp;k)](functions/stirlingS2.md) | The Stirling numbers of the second kind, counts the number of ways to partition a set of n labelled objects into k nonempty unlabelled subsets.
-
-## Complex functions
-
-Function | Description
----- | -----------
-[math.arg(x)](functions/arg.md) | Compute the argument of a complex value.
-[math.conj(x)](functions/conj.md) | Compute the complex conjugate of a complex value.
-[math.im(x)](functions/im.md) | Get the imaginary part of a complex number.
-[math.re(x)](functions/re.md) | Get the real part of a complex number.
-
-## Geometry functions
-
-Function | Description
----- | -----------
-[math.distance([x1,&nbsp;y1],&nbsp;[x2,&nbsp;y2])](functions/distance.md) | Calculates:    The eucledian distance between two points in N-dimensional spaces.
-[math.intersect(endPoint1Line1, endPoint2Line1, endPoint1Line2, endPoint2Line2)](functions/intersect.md) | Calculates the point of intersection of two lines in two or three dimensions and of a line and a plane in three dimensions.
-
-## Logical functions
-
-Function | Description
----- | -----------
-[math.and(x,&nbsp;y)](functions/and.md) | Logical `and`.
-[math.not(x)](functions/not.md) | Logical `not`.
-[math.or(x,&nbsp;y)](functions/or.md) | Logical `or`.
-[math.xor(x,&nbsp;y)](functions/xor.md) | Logical `xor`.
-
-## Matrix functions
-
-Function | Description
----- | -----------
-[math.apply(A,&nbsp;dim,&nbsp;callback)](functions/apply.md) | Apply a function that maps an array to a scalar along a given axis of a matrix or array.
-[math.column(value,&nbsp;index)](functions/column.md) | Return a column from a Matrix.
-[math.concat(a,&nbsp;b,&nbsp;c,&nbsp;...&nbsp;[,&nbsp;dim])](functions/concat.md) | Concatenate two or more matrices.
-[math.count(x)](functions/count.md) | Count the number of elements of a matrix, array or string.
-[math.cross(x,&nbsp;y)](functions/cross.md) | Calculate the cross product for two vectors in three dimensional space.
-[math.ctranspose(x)](functions/ctranspose.md) | Transpose and complex conjugate a matrix.
-[math.det(x)](functions/det.md) | Calculate the determinant of a matrix.
-[math.diag(X)](functions/diag.md) | Create a diagonal matrix or retrieve the diagonal of a matrix  When `x` is a vector, a matrix with vector `x` on the diagonal will be returned.
-[math.diff(arr)](functions/diff.md) | Create a new matrix or array of the difference between elements of the given array The optional dim parameter lets you specify the dimension to evaluate the difference of If no dimension parameter is passed it is assumed as dimension 0  Dimension is zero-based in javascript and one-based in the parser and can be a number or bignumber Arrays must be 'rectangular' meaning arrays like [1, 2] If something is passed as a matrix it will be returned as a matrix but other than that all matrices are converted to arrays.
-[math.dot(x,&nbsp;y)](functions/dot.md) | Calculate the dot product of two vectors.
-[math.eigs(x,&nbsp;[prec])](functions/eigs.md) | Compute eigenvalues and eigenvectors of a matrix.
-[math.expm(x)](functions/expm.md) | Compute the matrix exponential, expm(A) = e^A.
-[math.filter(x,&nbsp;test)](functions/filter.md) | Filter the items in an array or one dimensional matrix.
-[math.flatten(x)](functions/flatten.md) | Flatten a multi dimensional matrix into a single dimensional matrix.
-[math.forEach(x,&nbsp;callback)](functions/forEach.md) | Iterate over all elements of a matrix/array, and executes the given callback function.
-[math.getMatrixDataType(x)](functions/getMatrixDataType.md) | Find the data type of all elements in a matrix or array, for example 'number' if all items are a number and 'Complex' if all values are complex numbers.
-[math.identity(n)](functions/identity.md) | Create a 2-dimensional identity matrix with size m x n or n x n.
-[math.inv(x)](functions/inv.md) | Calculate the inverse of a square matrix.
-[math.kron(x,&nbsp;y)](functions/kron.md) | Calculates the kronecker product of 2 matrices or vectors.
-[math.map(x,&nbsp;callback)](functions/map.md) | Create a new matrix or array with the results of the callback function executed on each entry of the matrix/array.
-[math.matrixFromColumns(...arr)](functions/matrixFromColumns.md) | Create a dense matrix from vectors as individual columns.
-[math.matrixFromFunction(size,&nbsp;fn)](functions/matrixFromFunction.md) | Create a matrix by evaluating a generating function at each index.
-[math.matrixFromRows(...arr)](functions/matrixFromRows.md) | Create a dense matrix from vectors as individual rows.
-[math.ones(m,&nbsp;n,&nbsp;p,&nbsp;...)](functions/ones.md) | Create a matrix filled with ones.
-[math.partitionSelect(x,&nbsp;k)](functions/partitionSelect.md) | Partition-based selection of an array or 1D matrix.
-[math.range(start,&nbsp;end&nbsp;[,&nbsp;step])](functions/range.md) | Create an array from a range.
-[math.reshape(x,&nbsp;sizes)](functions/reshape.md) | Reshape a multi dimensional array to fit the specified dimensions.
-[math.resize(x,&nbsp;size&nbsp;[,&nbsp;defaultValue])](functions/resize.md) | Resize a matrix.
-[math.rotate(w,&nbsp;theta)](functions/rotate.md) | Rotate a vector of size 1x2 counter-clockwise by a given angle Rotate a vector of size 1x3 counter-clockwise by a given angle around the given axis.
-[math.rotationMatrix(theta)](functions/rotationMatrix.md) | Create a 2-dimensional counter-clockwise rotation matrix (2x2) for a given angle (expressed in radians).
-[math.row(value,&nbsp;index)](functions/row.md) | Return a row from a Matrix.
-[math.size(x)](functions/size.md) | Calculate the size of a matrix or scalar.
-[math.sort(x)](functions/sort.md) | Sort the items in a matrix.
-[X&nbsp;=&nbsp;math.sqrtm(A)](functions/sqrtm.md) | Calculate the principal square root of a square matrix.
-[math.squeeze(x)](functions/squeeze.md) | Squeeze a matrix, remove inner and outer singleton dimensions from a matrix.
-[math.subset(x,&nbsp;index&nbsp;[,&nbsp;replacement])](functions/subset.md) | Get or set a subset of a matrix or string.
-[math.trace(x)](functions/trace.md) | Calculate the trace of a matrix: the sum of the elements on the main diagonal of a square matrix.
-[math.transpose(x)](functions/transpose.md) | Transpose a matrix.
-[math.zeros(m,&nbsp;n,&nbsp;p,&nbsp;...)](functions/zeros.md) | Create a matrix filled with zeros.
-
-## Probability functions
-
-Function | Description
----- | -----------
-[math.combinations(n,&nbsp;k)](functions/combinations.md) | Compute the number of ways of picking `k` unordered outcomes from `n` possibilities.
-[math.combinationsWithRep(n,&nbsp;k)](functions/combinationsWithRep.md) | Compute the number of ways of picking `k` unordered outcomes from `n` possibilities, allowing individual outcomes to be repeated more than once.
-[math.factorial(n)](functions/factorial.md) | Compute the factorial of a value  Factorial only supports an integer value as argument.
-[math.gamma(n)](functions/gamma.md) | Compute the gamma function of a value using Lanczos approximation for small values, and an extended Stirling approximation for large values.
-[math.kldivergence(x,&nbsp;y)](functions/kldivergence.md) | Calculate the Kullback-Leibler (KL) divergence  between two distributions.
-[math.multinomial(a)](functions/multinomial.md) | Multinomial Coefficients compute the number of ways of picking a1, a2, .
-[math.permutations(n&nbsp;[,&nbsp;k])](functions/permutations.md) | Compute the number of ways of obtaining an ordered subset of `k` elements from a set of `n` elements.
-[math.pickRandom(array)](functions/pickRandom.md) | Random pick one or more values from a one dimensional array.
-[math.random([min,&nbsp;max])](functions/random.md) | Return a random number larger or equal to `min` and smaller than `max` using a uniform distribution.
-[math.randomInt([min,&nbsp;max])](functions/randomInt.md) | Return a random integer number larger or equal to `min` and smaller than `max` using a uniform distribution.
-
-## Relational functions
-
-Function | Description
----- | -----------
-[math.compare(x,&nbsp;y)](functions/compare.md) | Compare two values.
-[math.compareNatural(x,&nbsp;y)](functions/compareNatural.md) | Compare two values of any type in a deterministic, natural way.
-[math.compareText(x,&nbsp;y)](functions/compareText.md) | Compare two strings lexically.
-[math.deepEqual(x,&nbsp;y)](functions/deepEqual.md) | Test element wise whether two matrices are equal.
-[math.equal(x,&nbsp;y)](functions/equal.md) | Test whether two values are equal.
-[math.equalText(x,&nbsp;y)](functions/equalText.md) | Check equality of two strings.
-[math.larger(x,&nbsp;y)](functions/larger.md) | Test whether value x is larger than y.
-[math.largerEq(x,&nbsp;y)](functions/largerEq.md) | Test whether value x is larger or equal to y.
-[math.smaller(x,&nbsp;y)](functions/smaller.md) | Test whether value x is smaller than y.
-[math.smallerEq(x,&nbsp;y)](functions/smallerEq.md) | Test whether value x is smaller or equal to y.
-[math.unequal(x,&nbsp;y)](functions/unequal.md) | Test whether two values are unequal.
-
-## Set functions
-
-Function | Description
----- | -----------
-[math.setCartesian(set1,&nbsp;set2)](functions/setCartesian.md) | Create the cartesian product of two (multi)sets.
-[math.setDifference(set1,&nbsp;set2)](functions/setDifference.md) | Create the difference of two (multi)sets: every element of set1, that is not the element of set2.
-[math.setDistinct(set)](functions/setDistinct.md) | Collect the distinct elements of a multiset.
-[math.setIntersect(set1,&nbsp;set2)](functions/setIntersect.md) | Create the intersection of two (multi)sets.
-[math.setIsSubset(set1,&nbsp;set2)](functions/setIsSubset.md) | Check whether a (multi)set is a subset of another (multi)set.
-[math.setMultiplicity(element,&nbsp;set)](functions/setMultiplicity.md) | Count the multiplicity of an element in a multiset.
-[math.setPowerset(set)](functions/setPowerset.md) | Create the powerset of a (multi)set.
-[math.setSize(set)](functions/setSize.md) | Count the number of elements of a (multi)set.
-[math.setSymDifference(set1,&nbsp;set2)](functions/setSymDifference.md) | Create the symmetric difference of two (multi)sets.
-[math.setUnion(set1,&nbsp;set2)](functions/setUnion.md) | Create the union of two (multi)sets.
-
-## Special functions
-
-Function | Description
----- | -----------
-[math.erf(x)](functions/erf.md) | Compute the erf function of a value using a rational Chebyshev approximations for different intervals of x.
-
-## Statistics functions
-
-Function | Description
----- | -----------
-[math.mad(a,&nbsp;b,&nbsp;c,&nbsp;...)](functions/mad.md) | Compute the median absolute deviation of a matrix or a list with values.
-[math.max(a,&nbsp;b,&nbsp;c,&nbsp;...)](functions/max.md) | Compute the maximum value of a matrix or a  list with values.
-[math.mean(a,&nbsp;b,&nbsp;c,&nbsp;...)](functions/mean.md) | Compute the mean value of matrix or a list with values.
-[math.median(a,&nbsp;b,&nbsp;c,&nbsp;...)](functions/median.md) | Compute the median of a matrix or a list with values.
-[math.min(a,&nbsp;b,&nbsp;c,&nbsp;...)](functions/min.md) | Compute the minimum value of a matrix or a  list of values.
-[math.mode(a,&nbsp;b,&nbsp;c,&nbsp;...)](functions/mode.md) | Computes the mode of a set of numbers or a list with values(numbers or characters).
-[math.prod(a,&nbsp;b,&nbsp;c,&nbsp;...)](functions/prod.md) | Compute the product of a matrix or a list with values.
-[math.quantileSeq(A,&nbsp;prob[,&nbsp;sorted])](functions/quantileSeq.md) | Compute the prob order quantile of a matrix or a list with values.
-[math.std(a,&nbsp;b,&nbsp;c,&nbsp;...)](functions/std.md) | Compute the standard deviation of a matrix or a  list with values.
-[math.sum(a,&nbsp;b,&nbsp;c,&nbsp;...)](functions/sum.md) | Compute the sum of a matrix or a list with values.
-[math.variance(a,&nbsp;b,&nbsp;c,&nbsp;...)](functions/variance.md) | Compute the variance of a matrix or a  list with values.
-
-## String functions
-
-Function | Description
----- | -----------
-[math.bin(value)](functions/bin.md) | Format a number as binary.
-[math.format(value&nbsp;[,&nbsp;precision])](functions/format.md) | Format a value of any type into a string.
-[math.hex(value)](functions/hex.md) | Format a number as hexadecimal.
-[math.oct(value)](functions/oct.md) | Format a number as octal.
-[math.print(template, values [, precision])](functions/print.md) | Interpolate values into a string template.
-
-## Trigonometry functions
-
-Function | Description
----- | -----------
-[math.acos(x)](functions/acos.md) | Calculate the inverse cosine of a value.
-[math.acosh(x)](functions/acosh.md) | Calculate the hyperbolic arccos of a value, defined as `acosh(x) = ln(sqrt(x^2 - 1) + x)`.
-[math.acot(x)](functions/acot.md) | Calculate the inverse cotangent of a value, defined as `acot(x) = atan(1/x)`.
-[math.acoth(x)](functions/acoth.md) | Calculate the hyperbolic arccotangent of a value, defined as `acoth(x) = atanh(1/x) = (ln((x+1)/x) + ln(x/(x-1))) / 2`.
-[math.acsc(x)](functions/acsc.md) | Calculate the inverse cosecant of a value, defined as `acsc(x) = asin(1/x)`.
-[math.acsch(x)](functions/acsch.md) | Calculate the hyperbolic arccosecant of a value, defined as `acsch(x) = asinh(1/x) = ln(1/x + sqrt(1/x^2 + 1))`.
-[math.asec(x)](functions/asec.md) | Calculate the inverse secant of a value.
-[math.asech(x)](functions/asech.md) | Calculate the hyperbolic arcsecant of a value, defined as `asech(x) = acosh(1/x) = ln(sqrt(1/x^2 - 1) + 1/x)`.
-[math.asin(x)](functions/asin.md) | Calculate the inverse sine of a value.
-[math.asinh(x)](functions/asinh.md) | Calculate the hyperbolic arcsine of a value, defined as `asinh(x) = ln(x + sqrt(x^2 + 1))`.
-[math.atan(x)](functions/atan.md) | Calculate the inverse tangent of a value.
-[math.atan2(y,&nbsp;x)](functions/atan2.md) | Calculate the inverse tangent function with two arguments, y/x.
-[math.atanh(x)](functions/atanh.md) | Calculate the hyperbolic arctangent of a value, defined as `atanh(x) = ln((1 + x)/(1 - x)) / 2`.
-[math.cos(x)](functions/cos.md) | Calculate the cosine of a value.
-[math.cosh(x)](functions/cosh.md) | Calculate the hyperbolic cosine of a value, defined as `cosh(x) = 1/2 * (exp(x) + exp(-x))`.
-[math.cot(x)](functions/cot.md) | Calculate the cotangent of a value.
-[math.coth(x)](functions/coth.md) | Calculate the hyperbolic cotangent of a value, defined as `coth(x) = 1 / tanh(x)`.
-[math.csc(x)](functions/csc.md) | Calculate the cosecant of a value, defined as `csc(x) = 1/sin(x)`.
-[math.csch(x)](functions/csch.md) | Calculate the hyperbolic cosecant of a value, defined as `csch(x) = 1 / sinh(x)`.
-[math.sec(x)](functions/sec.md) | Calculate the secant of a value, defined as `sec(x) = 1/cos(x)`.
-[math.sech(x)](functions/sech.md) | Calculate the hyperbolic secant of a value, defined as `sech(x) = 1 / cosh(x)`.
-[math.sin(x)](functions/sin.md) | Calculate the sine of a value.
-[math.sinh(x)](functions/sinh.md) | Calculate the hyperbolic sine of a value, defined as `sinh(x) = 1/2 * (exp(x) - exp(-x))`.
-[math.tan(x)](functions/tan.md) | Calculate the tangent of a value.
-[math.tanh(x)](functions/tanh.md) | Calculate the hyperbolic tangent of a value, defined as `tanh(x) = (exp(2 * x) - 1) / (exp(2 * x) + 1)`.
-
-## Unit functions
-
-Function | Description
----- | -----------
-[math.to(x,&nbsp;unit)](functions/to.md) | Change the unit of a value.
-
-## Utils functions
-
-Function | Description
----- | -----------
-[math.clone(x)](functions/clone.md) | Clone an object.
-[math.hasNumericValue(x)](functions/hasNumericValue.md) | Test whether a value is an numeric value.
-[math.isInteger(x)](functions/isInteger.md) | Test whether a value is an integer number.
-[math.isNaN(x)](functions/isNaN.md) | Test whether a value is NaN (not a number).
-[math.isNegative(x)](functions/isNegative.md) | Test whether a value is negative: smaller than zero.
-[math.isNumeric(x)](functions/isNumeric.md) | Test whether a value is an numeric value.
-[math.isPositive(x)](functions/isPositive.md) | Test whether a value is positive: larger than zero.
-[math.isPrime(x)](functions/isPrime.md) | Test whether a value is prime: has no divisors other than itself and one.
-[math.isZero(x)](functions/isZero.md) | Test whether a value is zero.
-[math.numeric(x)](functions/numeric.md) | Convert a numeric input to a specific numeric type: number, BigNumber, or Fraction.
-[math.typeOf(x)](functions/typeOf.md) | Determine the type of a variable.
-
-
-
-<!-- Note: This file is automatically generated from source code comments. Changes made in this file will be overridden. -->

package/docs/reference/index.md

@@ -1,5 +0,0 @@
-# Reference
-
-- [Classes](classes.md)
-- [Constants](constants.md)
-- [Functions](functions.md)

package/examples/advanced/convert_fraction_to_bignumber.js

@@ -1,59 +0,0 @@
-// Convert from Fraction to BigNumber
-//
-// In the configuration of math.js one can specify the default number type to
-// be `number`, `BigNumber`, or `Fraction`. Not all functions support `Fraction`
-// or `BigNumber`, and if not supported these input types will be converted to
-// numbers.
-//
-// When `Fraction` is configured, one may want to fallback to `BigNumber`
-// instead of `number`. Also, one may want to be able to mix `Fraction` and
-// `BigNumber` in operations like summing them up. This can be achieved by
-// adding an extra conversion to the list of conversions as demonstrated in
-// this example.
-
-// Create an empty math.js instance, with only typed
-// (every instance contains `import` and `config` also out of the box)
-const { create, typedDependencies, all } = require('../..')
-const math = create({
-  typedDependencies
-})
-
-// TODO: this should be much easier
-const allExceptLoaded = Object.keys(all)
-  .map(key => all[key])
-  .filter(factory => math[factory.fn] === undefined)
-
-// Configure to use fractions by default
-math.config({ number: 'Fraction' })
-
-// Add a conversion from Faction -> BigNumber
-// this conversion:
-// - must be inserted in the conversions list before the conversion Fraction -> number
-// - must be added to the conversions before loading functions into math.js
-math.typed.conversions.unshift({
-  from: 'Fraction',
-  to: 'BigNumber',
-  convert: function (fraction) {
-    return new math.BigNumber(fraction.n).div(fraction.d)
-  }
-})
-
-// Import all data types, functions, constants, the expression parser, etc.
-math.import(allExceptLoaded)
-
-// Operators `add` and `divide` do have support for Fractions, so the result
-// will simply be a Fraction (default behavior of math.js).
-const ans1 = math.evaluate('1/3 + 1/4')
-console.log(math.typeOf(ans1), math.format(ans1))
-// outputs "Fraction 7/12"
-
-// Function sqrt doesn't have Fraction support, will now fall back to BigNumber
-// instead of number.
-const ans2 = math.evaluate('sqrt(4)')
-console.log(math.typeOf(ans2), math.format(ans2))
-// outputs "BigNumber 2"
-
-// We can now do operations with mixed Fractions and BigNumbers
-const ans3 = math.add(math.fraction(2, 5), math.bignumber(3))
-console.log(math.typeOf(ans3), math.format(ans3))
-// outputs "BigNumber 3.4"

package/examples/advanced/custom_argument_parsing.js

@@ -1,98 +0,0 @@
-/**
- * The expression parser of math.js has support for letting functions
- * parse and evaluate arguments themselves, instead of calling them with
- * evaluated arguments.
- *
- * By adding a property `raw` with value true to a function, the function
- * will be invoked with unevaluated arguments, allowing the function
- * to process the arguments in a customized way.
- */
-const { create, all } = require('../..')
-const math = create(all)
-
-/**
- * Calculate the numeric integration of a function
- * @param {Function} f
- * @param {number} start
- * @param {number} end
- * @param {number} [step=0.01]
- */
-function integrate (f, start, end, step) {
-  let total = 0
-  step = step || 0.01
-  for (let x = start; x < end; x += step) {
-    total += f(x + step / 2) * step
-  }
-  return total
-}
-
-/**
- * A transformation for the integrate function. This transformation will be
- * invoked when the function is used via the expression parser of math.js.
- *
- * Syntax:
- *
- *     integrate(integrand, variable, start, end)
- *     integrate(integrand, variable, start, end, step)
- *
- * Usage:
- *
- *     math.evaluate('integrate(2*x, x, 0, 2)')
- *     math.evaluate('integrate(2*x, x, 0, 2, 0.01)')
- *
- * @param {Array.<math.Node>} args
- *            Expects the following arguments: [f, x, start, end, step]
- * @param {Object} math
- * @param {Object} [scope]
- */
-integrate.transform = function (args, math, scope) {
-  // determine the variable name
-  if (!args[1].isSymbolNode) {
-    throw new Error('Second argument must be a symbol')
-  }
-  const variable = args[1].name
-
-  // evaluate start, end, and step
-  const start = args[2].compile().evaluate(scope)
-  const end = args[3].compile().evaluate(scope)
-  const step = args[4] && args[4].compile().evaluate(scope) // step is optional
-
-  // create a new scope, linked to the provided scope. We use this new scope
-  // to apply the variable.
-  const fnScope = Object.create(scope)
-
-  // construct a function which evaluates the first parameter f after applying
-  // a value for parameter x.
-  const fnCode = args[0].compile()
-  const f = function (x) {
-    fnScope[variable] = x
-    return fnCode.evaluate(fnScope)
-  }
-
-  // execute the integration
-  return integrate(f, start, end, step)
-}
-
-// mark the transform function with a "rawArgs" property, so it will be called
-// with uncompiled, unevaluated arguments.
-integrate.transform.rawArgs = true
-
-// import the function into math.js. Raw functions must be imported in the
-// math namespace, they can't be used via `evaluate(scope)`.
-math.import({
-  integrate: integrate
-})
-
-// use the function in JavaScript
-function f (x) {
-  return math.pow(x, 0.5)
-}
-console.log(math.integrate(f, 0, 1)) // outputs 0.6667254718034714
-
-// use the function via the expression parser
-console.log(math.evaluate('integrate(x^0.5, x, 0, 1)')) // outputs 0.6667254718034714
-
-// use the function via the expression parser (2)
-const scope = {}
-math.evaluate('f(x) = 2 * x', scope)
-console.log(math.evaluate('integrate(f(x), x, 0, 2)', scope)) // outputs 4.000000000000003

package/examples/advanced/custom_datatype.js

@@ -1,56 +0,0 @@
-// This example demonstrates importing a custom data type,
-// and extending an existing function (add) with support for this data type.
-
-const { create, factory, all } = require('../..')
-const math = create(all)
-
-// factory function which defines a new data type CustomValue
-const createCustomValue = factory('CustomValue', ['typed'], ({ typed }) => {
-  // create a new data type
-  function CustomValue (value) {
-    this.value = value
-  }
-  CustomValue.prototype.isCustomValue = true
-  CustomValue.prototype.toString = function () {
-    return 'CustomValue:' + this.value
-  }
-
-  // define a new data type with typed-function
-  typed.addType({
-    name: 'CustomValue',
-    test: function (x) {
-      // test whether x is of type CustomValue
-      return x && x.isCustomValue === true
-    }
-  })
-
-  return CustomValue
-})
-
-// function add which can add the CustomValue data type
-// When imported in math.js, the existing function `add` with support for
-// CustomValue, because both implementations are typed-functions and do not
-// have conflicting signatures.
-const createAddCustomValue = factory('add', ['typed', 'CustomValue'], ({ typed, CustomValue }) => {
-  return typed('add', {
-    'CustomValue, CustomValue': function (a, b) {
-      return new CustomValue(a.value + b.value)
-    }
-  })
-})
-
-// import the new data type and function
-math.import([
-  createCustomValue,
-  createAddCustomValue
-])
-
-// use the new type
-const ans1 = math.add(new math.CustomValue(2), new math.CustomValue(3))
-console.log(ans1.toString())
-// outputs 'CustomValue:5'
-
-// you can automatically use the new type in functions which use `add` under the hood:
-const ans2 = math.sum(new math.CustomValue(6), new math.CustomValue(1), new math.CustomValue(2))
-console.log(ans2.toString())
-// outputs 'CustomValue:9'

package/examples/advanced/custom_evaluate_using_factories.js

@@ -1,19 +0,0 @@
-const { create, evaluateDependencies, factory } = require('../..')
-
-// custom implementations of all functions you want to support
-const add = (a, b) => a + b
-const subtract = (a, b) => a - b
-const multiply = (a, b) => a * b
-const divide = (a, b) => a / b
-
-// create factories for the functions, and create an evaluate function with those
-// these functions will also be used by the classes like Unit.
-const { evaluate } = create({
-  evaluateDependencies,
-  createAdd: factory('add', [], () => add),
-  createSubtract: factory('subtract', [], () => subtract),
-  createMultiply: factory('multiply', [], () => multiply),
-  createDivide: factory('divide', [], () => divide)
-})
-
-console.log(evaluate('2 + 3 * 4')) // 14

package/examples/advanced/custom_evaluate_using_import.js

@@ -1,18 +0,0 @@
-const { create, evaluateDependencies } = require('../..')
-
-// custom implementations of all functions you want to support
-const add = (a, b) => a + b
-const subtract = (a, b) => a - b
-const multiply = (a, b) => a * b
-const divide = (a, b) => a / b
-
-// create a mathjs instance with hardly any functions
-// there are some functions created which are used internally by evaluate though,
-// for example by the Unit class which has dependencies on addScalar, subtract,
-// multiplyScalar, etc.
-const math = create(evaluateDependencies)
-
-// import your own functions
-math.import({ add, subtract, multiply, divide }, { override: true })
-
-console.log(math.evaluate('2 + 3 * 4')) // 14

package/examples/advanced/custom_loading.js

@@ -1,33 +0,0 @@
-import {
-  create,
-  fractionDependencies,
-  addDependencies,
-  divideDependencies,
-  formatDependencies
-} from '../..'
-
-const config = {
-  // optionally, you can specify configuration
-}
-
-// Create just the functions we need
-const { fraction, add, divide, format } = create({
-  fractionDependencies,
-  addDependencies,
-  divideDependencies,
-  formatDependencies
-}, config)
-
-// Use the created functions
-const a = fraction(1, 3)
-const b = fraction(3, 7)
-const c = add(a, b)
-const d = divide(a, b)
-console.log('c =', format(c)) // outputs "c = 16/21"
-console.log('d =', format(d)) // outputs "d = 7/9"
-
-// Now, when bundling your application for use in the browser, only the used
-// parts of math.js will be bundled. For example to create a bundle using Webpack:
-//
-//     npx webpack custom_loading.js -o custom_loading.bundle.js --mode=production
-//

package/examples/advanced/custom_relational_functions.js

@@ -1,62 +0,0 @@
-const { create, all, factory } = require('../..')
-
-// First let's see what the default behavior is:
-// strings are compared by their numerical value
-console.log('default (compare string by their numerical value)')
-const { evaluate } = create(all)
-evaluateAndLog(evaluate, '2 < 10') // true
-evaluateAndLog(evaluate, '"2" < "10"') // true
-evaluateAndLog(evaluate, '"a" == "b"') // Error: Cannot convert "a" to a number
-evaluateAndLog(evaluate, '"a" == "a"') // Error: Cannot convert "a" to a number
-console.log('')
-
-// Suppose we want different behavior for string comparisons. To achieve
-// this we can replace the factory functions for all relational functions
-// with our own. In this simple example we use the JavaScript implementation.
-console.log('custom (compare strings lexically)')
-
-const allWithCustomFunctions = {
-  ...all,
-
-  createEqual: factory('equal', [], () => function equal (a, b) {
-    return a === b
-  }),
-
-  createUnequal: factory('unequal', [], () => function unequal (a, b) {
-    return a !== b
-  }),
-
-  createSmaller: factory('smaller', [], () => function smaller (a, b) {
-    return a < b
-  }),
-
-  createSmallerEq: factory('smallerEq', [], () => function smallerEq (a, b) {
-    return a <= b
-  }),
-
-  createLarger: factory('larger', [], () => function larger (a, b) {
-    return a > b
-  }),
-
-  createLargerEq: factory('largerEq', [], () => function largerEq (a, b) {
-    return a >= b
-  }),
-
-  createCompare: factory('compare', [], () => function compare (a, b) {
-    return a > b ? 1 : a < b ? -1 : 0
-  })
-}
-const evaluateCustom = create(allWithCustomFunctions).evaluate
-evaluateAndLog(evaluateCustom, '2 < 10') // true
-evaluateAndLog(evaluateCustom, '"2" < "10"') // false
-evaluateAndLog(evaluateCustom, '"a" == "b"') // false
-evaluateAndLog(evaluateCustom, '"a" == "a"') // true
-
-// helper function to evaluate an expression and print the results
-function evaluateAndLog (evaluate, expression) {
-  try {
-    console.log(expression, evaluate(expression))
-  } catch (err) {
-    console.error(expression, err.toString())
-  }
-}