diff --git a/src/core/function/typed.js b/src/core/function/typed.js index 829746b12..ec93a32bb 100644 --- a/src/core/function/typed.js +++ b/src/core/function/typed.js @@ -327,5 +327,8 @@ export function createTyped (type) { } ] + // TODO: this is a temporary test + typed.type = type + return typed } diff --git a/src/function/bitwise/bitAnd.js b/src/function/bitwise/bitAnd.js index 437b0262f..1b81b8f51 100644 --- a/src/function/bitwise/bitAnd.js +++ b/src/function/bitwise/bitAnd.js @@ -14,11 +14,10 @@ const name = 'bitAnd' const dependencies = [ 'typed', 'matrix', - 'equalScalar', - 'type.DenseMatrix' + 'equalScalar' ] -export const createBitAnd = factory(name, dependencies, ({ typed, matrix, equalScalar, type: { DenseMatrix } }) => { +export const createBitAnd = factory(name, dependencies, ({ typed, matrix, equalScalar }) => { const algorithm02 = createAlgorithm02({ typed, equalScalar }) const algorithm06 = createAlgorithm06({ typed, equalScalar }) const algorithm11 = createAlgorithm11({ typed, equalScalar }) diff --git a/src/mainAll.js b/src/mainAll.js index 473d9c57c..e0b924414 100644 --- a/src/mainAll.js +++ b/src/mainAll.js @@ -1,6 +1,4 @@ import { create as _create } from './core/core' - -// type import { createNumber } from './type/number' import { createBigNumberClass } from './type/bignumber/BigNumber' import { createBignumber } from './type/bignumber/function/bignumber' @@ -12,8 +10,6 @@ import { createMatrix } from './type/matrix/function/matrix' import { createMatrixClass } from './type/matrix/Matrix' import { createDenseMatrixClass } from './type/matrix/DenseMatrix' import { createSparseMatrixClass } from './type/matrix/SparseMatrix' - -// arithmetic import { createAbs } from './function/arithmetic/abs' import { createAdd } from './function/arithmetic/add' import { createAddScalar } from './function/arithmetic/addScalar' @@ -51,13 +47,9 @@ import { createSubtract } from './function/arithmetic/subtract' import { createUnaryMinus } from './function/arithmetic/unaryMinus' import { createUnaryPlus } from './function/arithmetic/unaryPlus' import { createXgcd } from './function/arithmetic/xgcd' - -// relational import { createEqualScalar } from './function/relational/equalScalar' import { createSmaller } from './function/relational/smaller' import { createLarger } from './function/relational/larger' - -// utils import { createClone } from './function/utils/clone' import { createIsInteger } from './function/utils/isInteger' import { createIsNegative } from './function/utils/isNegative' @@ -69,6 +61,119 @@ import { createIsNaN } from './function/utils/isNaN' import { createNumeric } from './function/utils/numeric' import { createTypeOf } from './function/utils/typeOf' import { createEmbeddedDocs } from './expression/embeddedDocs' +import { createUnitClass } from './type/unit/Unit' +import { createUnit } from './type/unit/function/unit' +import { createArg } from './function/complex/arg' +import { createConj } from './function/complex/conj' +import { createIm } from './function/complex/im' +import { createRe } from './function/complex/re' +import { createLeftShift } from './function/bitwise/leftShift' +import { createRightArithShift } from './function/bitwise/rightArithShift' +import { createRightLogShift } from './function/bitwise/rightLogShift' +import { createBitXor } from './function/bitwise/bitXor' +import { createBitOr } from './function/bitwise/bitOr' +import { createBitNot } from './function/bitwise/bitNot' +import { createBitAnd } from './function/bitwise/bitAnd' +import { createCompare } from './function/relational/compare' +import { createCompareNatural } from './function/relational/compareNatural' +import { createDeepEqual } from './function/relational/deepEqual' +import { createCompareText } from './function/relational/compareText' +import { createEqual } from './function/relational/equal' +import { createEqualText } from './function/relational/equalText' +import { createLargerEq } from './function/relational/largerEq' +import { createSmallerEq } from './function/relational/smallerEq' +import { createUnequal } from './function/relational/unequal' +import { createPrint } from './function/string/print' +import { createFormat } from './function/string/format' +import { createAnd } from './function/logical/and' +import { createXor } from './function/logical/xor' +import { createOr } from './function/logical/or' +import { createNot } from './function/logical/not' +import { createParseExpression } from './expression/parse' +import { createEval } from './expression/function/eval' +import { createCompile } from './expression/function/compile' +import { createParse } from './expression/function/parse' +import { createSymbolNode } from './expression/node/SymbolNode' +import { createRelationalNode } from './expression/node/RelationalNode' +import { createRangeNode } from './expression/node/RangeNode' +import { createParenthesisNode } from './expression/node/ParenthesisNode' +import { createOperatorNode } from './expression/node/OperatorNode' +import { createObjectNode } from './expression/node/ObjectNode' +import { createIndexNode } from './expression/node/IndexNode' +import { createFunctionNode } from './expression/node/FunctionNode' +import { createFunctionAssignmentNode } from './expression/node/FunctionAssignmentNode' +import { createConstantNode } from './expression/node/ConstantNode' +import { createConditionalNode } from './expression/node/ConditionalNode' +import { createBlockNode } from './expression/node/BlockNode' +import { createAssignmentNode } from './expression/node/AssignmentNode' +import { createArrayNode } from './expression/node/ArrayNode' +import { createAccessorNode } from './expression/node/AccessorNode' +import { createNode } from './expression/node/Node' +import { createParserClass } from './expression/Parser' +import { createImmutableDenseMatrixClass } from './type/matrix/ImmutableDenseMatrix' +import { createIndexClass } from './type/matrix/MatrixIndex' +import { createRangeClass } from './type/matrix/Range' +import { createResultSet } from './type/resultset/ResultSet' +import { createChainClass } from './type/chain/Chain' +import { createChain } from './type/chain/function/chain' +import { createSpaClass } from './type/matrix/Spa' +import { createFibonacciHeapClass } from './type/matrix/FibonacciHeap' +import { createSparse } from './type/matrix/function/sparse' +import { createBoolean } from './type/boolean' +import { createString } from './type/string' +import { createIdentity } from './function/matrix/identity' +import { createGetMatrixDataType } from './function/matrix/getMatrixDataType' +import { createPartitionSelect } from './function/matrix/partitionSelect' +import { createReshape } from './function/matrix/reshape' +import { createResize } from './function/matrix/resize' +import { createSize } from './function/matrix/size' +import { createSqueeze } from './function/matrix/squeeze' +import { createZeros } from './function/matrix/zeros' +import { createTranspose } from './function/matrix/transpose' +import { createTrace } from './function/matrix/trace' +import { createSubset } from './function/matrix/subset' +import { createSqrtm } from './function/matrix/sqrtm' +import { createSort } from './function/matrix/sort' +import { createRange } from './function/matrix/range' +import { createOnes } from './function/matrix/ones' +import { createMap } from './function/matrix/map' +import { createKron } from './function/matrix/kron' +import { createInv } from './function/matrix/inv' +import { createIndex } from './type/matrix/function' +import { createForEach } from './function/matrix/forEach' +import { createFlatten } from './function/matrix/flatten' +import { createFilter } from './function/matrix/filter' +import { createEye } from './function/matrix/eye' +import { createExpm } from './function/matrix/expm' +import { createDot } from './function/matrix/dot' +import { createDiag } from './function/matrix/diag' +import { createDet } from './function/matrix/det' +import { createCtranspose } from './function/matrix/ctranspose' +import { createCross } from './function/matrix/cross' +import { createConcat } from './function/matrix/concat' +import { createMax } from './function/statistics/max' +import { createMean } from './function/statistics/mean' +import { createQuantileSeq } from './function/statistics/quantileSeq' +import { createVariance } from './function/statistics/variance' +import { createMedian } from './function/statistics/median' +import { createSum } from './function/statistics/sum' +import { createStd } from './function/statistics/std' +import { createProd } from './function/statistics/prod' +import { createMode } from './function/statistics/mode' +import { createMin } from './function/statistics/min' +import { createMad } from './function/statistics/mad' +import { createLsolve } from './function/algebra/solver/lsolve' +import { createRationalize } from './function/algebra/rationalize' +import { createLusolve } from './function/algebra/solver/lusolve' +import { createUsolve } from './function/algebra/solver/usolve' +import { createDerivative } from './function/algebra/derivative' +import { createSimplify } from './function/algebra/simplify' +import { createSlu } from './function/algebra/decomposition/slu' +import { createQr } from './function/algebra/decomposition/qr' +import { createLup } from './function/algebra/decomposition/lup' +import { createResolve } from './function/algebra/simplify/resolve' +import { createSimplifyConstant } from './function/algebra/simplify/simplifyConstant' +import { createSimplifyCore } from './function/algebra/simplify/simplifyCore' const math = _create() @@ -91,49 +196,27 @@ export const typeOf = createTypeOf({ typed }) // relational (1) export const equalScalar = createEqualScalar({ typed, config }) -export const Matrix = createMatrixClass() +// class (1) +export const ResultSet = createResultSet() export const BigNumber = createBigNumberClass({ config, on }) -export const Complex = createComplexClass({ config, on }) +export const Complex = createComplexClass({ typed, config, on }) export const Fraction = createFractionClass() +export const Range = createRangeClass() +export const Matrix = createMatrixClass() export const DenseMatrix = createDenseMatrixClass({ typed, type: { Matrix } }) export const SparseMatrix = createSparseMatrixClass({ typed, equalScalar, type: { Matrix } }) -// for backward compatibility -export const type = { - BigNumber, - Complex, - Matrix, - DenseMatrix, - SparseMatrix -} - -// type +// create (1) export const number = createNumber({ typed }) +export const string = createString({ typed }) +export const boolean = createBoolean({ typed }) export const bignumber = createBignumber({ typed, type: { BigNumber } }) export const complex = createComplex({ typed, type: { Complex } }) export const fraction = createFraction({ typed, type: { Fraction } }) export const matrix = createMatrix({ typed, type: { Matrix } }) - -// utils (2) -export const isPrime = createIsPrime({ typed, type: { BigNumber } }) -export const numeric = createNumeric({ typed, number, bignumber, fraction }) +export const sparse = createSparse({ typed, type: { SparseMatrix } }) // arithmetic (1) -export const divideScalar = createDivideScalar({ typed, numeric }) - -// complex (1) -export const conj = () => { throw new Error('Sorry conj is not yet implemented') } // FIXME: load conj - -// matrix (1) -export const identity = () => { throw new Error('Sorry identity is not yet implemented') } // FIXME: load identity -export const inv = () => { throw new Error('Sorry inv is not yet implemented') } // FIXME: load inv -export const zeros = () => { throw new Error('Sorry zeros is not yet implemented') } // FIXME: load zeros - -// relational (2) -export const smaller = createSmaller({ typed, config, matrix, equalScalar, divideScalar, type: { DenseMatrix } }) -export const larger = createLarger({ typed, config, matrix, type: { DenseMatrix } }) - -// arithmetic (2) export const unaryMinus = createUnaryMinus({ typed }) export const unaryPlus = createUnaryPlus({ typed, config, type: { BigNumber } }) export const abs = createAbs({ typed }) @@ -148,32 +231,355 @@ export const fix = createFix({ typed, type: { Complex } }) export const floor = createFloor({ typed }) export const gcd = createGcd({ typed, matrix, equalScalar, type: { BigNumber, DenseMatrix } }) export const lcm = createLcm({ typed, matrix, equalScalar }) -export const log = createLog({ typed, config, divideScalar, type: { Complex } }) export const log10 = createLog10({ typed, config, type: { Complex } }) -export const log1p = createLog1p({ typed, config, divideScalar, log, type: { Complex } }) export const log2 = createLog2({ typed, config, type: { Complex } }) export const mod = createMod({ typed, matrix, equalScalar, type: { DenseMatrix } }) export const multiplyScalar = createMultiplyScalar({ typed }) export const multiply = createMultiply({ typed, matrix, addScalar, multiplyScalar, equalScalar }) export const nthRoot = createNthRoot({ typed, matrix, equalScalar, type: { BigNumber } }) -export const nthRoots = createNthRoots({ typed, config, divideScalar, type: { Complex } }) -export const pow = createPow({ typed, config, identity, multiply, matrix, number, fraction, type: { Complex } }) -export const round = createRound({ typed, matrix, equalScalar, zeros, type: { BigNumber, DenseMatrix } }) export const sign = createSign({ typed, type: { BigNumber, Fraction } }) export const sqrt = createSqrt({ config, typed, type: { Complex } }) export const square = createSquare({ typed }) export const subtract = createSubtract({ typed, matrix, equalScalar, addScalar, unaryMinus, type: { DenseMatrix } }) export const xgcd = createXgcd({ typed, config, matrix, type: { BigNumber } }) -export const divide = createDivide({ typed, matrix, multiply, equalScalar, divideScalar, inv }) -export const hypot = createHypot({ typed, abs, addScalar, divideScalar, multiplyScalar, sqrt, smaller, isPositive }) -export const norm = createNorm({ typed, abs, add, pow, conj, sqrt, multiply, equalScalar, larger, smaller, matrix }) export const dotMultiply = createDotMultiply({ typed, matrix, equalScalar, multiplyScalar }) + +// bitwise (1) +export const bitAnd = createBitAnd({ typed, matrix, equalScalar }) +export const bitNot = createBitNot({ typed }) +export const bitOr = createBitOr({ typed, matrix, equalScalar, type: { DenseMatrix } }) +export const bitXor = createBitXor({ typed, matrix, type: { DenseMatrix } }) + +// complex (1) +export const arg = createArg({ typed, type: { BigNumber } }) +export const conj = createConj({ typed }) +export const im = createIm({ typed }) +export const re = createRe({ typed }) + +// logical (1) +export const not = createNot({ typed }) +export const or = createOr({ typed, matrix, equalScalar, type: { DenseMatrix } }) +export const xor = createXor({ typed, matrix, type: { DenseMatrix } }) + +// matrix (1) +export const concat = createConcat({ typed, matrix, isInteger }) +export const cross = createCross({ typed, matrix, subtract, multiply }) +export const diag = createDiag({ typed, matrix, type: { Matrix } }) +export const dot = createDot({ typed, add, multiply }) +export const eye = createEye({ typed, matrix }) +export const filter = createFilter({ typed, matrix }) +export const flatten = createFlatten({ typed, matrix }) +export const forEach = createForEach({ typed }) +export const getMatrixDataType = createGetMatrixDataType({ typed }) +export const identity = createIdentity({ typed, config, matrix, type: { BigNumber, Matrix } }) +export const kron = createKron({ typed, matrix, multiplyScalar }) +export const map = createMap({ typed }) +export const ones = createOnes({ typed, config, matrix, type: { BigNumber } }) +export const range = createRange({ typed, config, matrix, type: { BigNumber } }) +export const reshape = createReshape({ typed, isInteger, matrix }) +export const resize = createResize({ config, matrix }) +export const size = createSize({ typed, config, matrix }) +export const squeeze = createSqueeze({ typed, matrix }) +export const subset = createSubset({ typed, matrix }) +export const trace = createTrace({ typed, matrix, add }) +export const transpose = createTranspose({ typed, matrix }) +export const ctranspose = createCtranspose({ typed, transpose, conj }) +export const zeros = createZeros({ typed, config, matrix, type: { BigNumber } }) + +// statistics (1) +export const mode = createMode({ typed, isNaN, isNumeric }) +export const prod = createProd({ typed, multiply }) +export const sum = createSum({ typed, config, add, type: { BigNumber, Fraction } }) + +// string (1) +export const format = createFormat({ typed }) +export const print = createPrint({ typed }) + +// utils (2) +export const isPrime = createIsPrime({ typed, type: { BigNumber } }) +export const numeric = createNumeric({ typed, number, bignumber, fraction }) + +// arithmetic (2) +export const divideScalar = createDivideScalar({ typed, numeric }) +export const pow = createPow({ typed, config, identity, multiply, matrix, number, fraction, type: { Complex } }) +export const round = createRound({ typed, matrix, equalScalar, zeros, type: { BigNumber, DenseMatrix } }) +export const log = createLog({ typed, config, divideScalar, type: { Complex } }) +export const log1p = createLog1p({ typed, config, divideScalar, log, type: { Complex } }) +export const nthRoots = createNthRoots({ typed, config, divideScalar, type: { Complex } }) export const dotPow = createDotPow({ typed, equalScalar, matrix, pow, type: { DenseMatrix } }) export const dotDivide = createDotDivide({ typed, matrix, equalScalar, divideScalar, type: { DenseMatrix } }) +// algebra (2) +export const lsolve = createLsolve({ typed, matrix, divideScalar, multiplyScalar, subtract, equalScalar, type: { DenseMatrix } }) +export const usolve = createUsolve({ typed, matrix, divideScalar, multiplyScalar, subtract, equalScalar, type: { DenseMatrix } }) + +// bitwise (2) +export const leftShift = createLeftShift({ typed, matrix, equalScalar, zeros, type: { DenseMatrix } }) +export const rightArithShift = createRightArithShift({ typed, matrix, equalScalar, zeros, type: { DenseMatrix } }) +export const rightLogShift = createRightLogShift({ typed, matrix, equalScalar, zeros, type: { DenseMatrix } }) + +// logical (2) +export const and = createAnd({ typed, matrix, equalScalar, zeros, not }) + +// relational (2) +export const compare = createCompare({ typed, config, equalScalar, matrix, type: { BigNumber, Fraction, DenseMatrix } }) +export const compareNatural = createCompareNatural({ typed, compare }) +export const compareText = createCompareText({ typed, config, matrix }) +export const equal = createEqual({ typed, matrix, equalScalar, type: { DenseMatrix } }) +export const equalText = createEqualText({ typed, compareText, isZero }) +export const smaller = createSmaller({ typed, config, matrix, equalScalar, divideScalar, type: { DenseMatrix } }) +export const smallerEq = createSmallerEq({ typed, config, matrix, type: { DenseMatrix } }) +export const larger = createLarger({ typed, config, matrix, type: { DenseMatrix } }) +export const largerEq = createLargerEq({ typed, config, matrix, type: { DenseMatrix } }) +export const deepEqual = createDeepEqual({ typed, equal }) +export const unequal = createUnequal({ typed, config, matrix, type: { DenseMatrix } }) + +// matrix (2) +export const partitionSelect = createPartitionSelect({ typed, isNumeric, isNaN, compare }) +export const sort = createSort({ typed, matrix, compare, compareNatural }) + +// statistics (2) +export const max = createMax({ typed, larger }) +export const min = createMin({ typed, smaller }) +export const quantileSeq = createQuantileSeq({ typed, add, multiply, partitionSelect, compare, type: { BigNumber } }) + +// class (2) +export const ImmutableDenseMatrix = createImmutableDenseMatrixClass({ smaller, type: { DenseMatrix } }) +export const Index = createIndexClass({ type: { ImmutableDenseMatrix } }) +export const FibonacciHeap = createFibonacciHeapClass({ smaller, larger }) +export const Spa = createSpaClass({ addScalar, equalScalar, type: { FibonacciHeap } }) +export const Unit = createUnitClass({ + config, + on, + addScalar, + subtract, + multiplyScalar, + divideScalar, + pow, + abs, + fix, + round, + equal, + isNumeric, + format, + number, + type: { Complex, BigNumber, Fraction } +}) + +// type (2) +export const unit = createUnit({ typed, type: { Unit } }) + +// arithmetic (3) +export const hypot = createHypot({ typed, abs, addScalar, divideScalar, multiplyScalar, sqrt, smaller, isPositive }) +export const norm = createNorm({ typed, abs, add, pow, conj, sqrt, multiply, equalScalar, larger, smaller, matrix }) + +// matrix (3) +export const index = createIndex({ typed, type: { Index } }) + +// FIXME: import all functions in math2 +const math2 = { + abs +} +const math2WithTransform = Object.assign({}, math2) + +// expression (3) +export const Node = createNode({ expression: { mathWithTransform: math2WithTransform } }) +export const AccessorNode = createAccessorNode({ subset, expression: { node: { Node } } }) +export const ArrayNode = createArrayNode({ expression: { node: { Node } } }) +export const AssignmentNode = createAssignmentNode({ subset, matrix, expression: { node: { Node } } }) +export const BlockNode = createBlockNode({ type: { ResultSet }, expression: { node: { Node } } }) +export const ConditionalNode = createConditionalNode({ expression: { node: { Node } } }) +export const ConstantNode = createConstantNode({ expression: { node: { Node } } }) +export const FunctionAssignmentNode = createFunctionAssignmentNode({ typed, expression: { node: { Node } } }) +export const IndexNode = createIndexNode({ type: { Range }, expression: { node: { Node } } }) +export const ObjectNode = createObjectNode({ expression: { node: { Node } } }) +export const OperatorNode = createOperatorNode({ expression: { node: { Node } } }) +export const ParenthesisNode = createParenthesisNode({ expression: { node: { Node } } }) +export const RangeNode = createRangeNode({ expression: { node: { Node } } }) +export const RelationalNode = createRelationalNode({ expression: { node: { Node } } }) +export const SymbolNode = createSymbolNode({ math: math2, type: { Unit }, expression: { node: { Node } } }) +export const FunctionNode = createFunctionNode({ math: math2, expression: { node: { Node, SymbolNode } } }) +const parseExpression = createParseExpression({ + numeric, + config, + expression: { + node: { + AccessorNode, + ArrayNode, + AssignmentNode, + BlockNode, + ConditionalNode, + ConstantNode, + FunctionAssignmentNode, + FunctionNode, + IndexNode, + ObjectNode, + OperatorNode, + ParenthesisNode, + RangeNode, + RelationalNode, + SymbolNode + } + } +}) +export const parse = createParse({ typed, expression: { parse: parseExpression } }) +export const compile = createCompile({ typed, expression: { parse: parseExpression } }) +export const evaluate = createEval({ typed, expression: { parse: parseExpression } }) +export const Parser = createParserClass({ expression: { parse: parseExpression } }) + +// algebra (3) +export const lup = createLup({ + typed, + matrix, + abs, + addScalar, + divideScalar, + multiplyScalar, + subtract, + larger, + equalScalar, + unaryMinus, + type: { DenseMatrix, SparseMatrix, Spa } +}) +export const qr = createQr({ + typed, + matrix, + zeros, + identity, + isZero, + unequal, + sign, + sqrt, + conj, + unaryMinus, + addScalar, + divideScalar, + multiplyScalar, + subtract +}) +export const slu = createSlu({ typed, abs, add, multiply, transpose, divideScalar, subtract, larger, largerEq, type: { SparseMatrix } }) +export const lusolve = createLusolve({ typed, matrix, lup, slu, usolve, lsolve, type: { DenseMatrix } }) + +// class (3) +export const Chain = createChainClass({ on, math: math2 }) + +// type (3) +export const chain = createChain({ typed, type: { Chain } }) + +// matrix (4) +export const det = createDet({ typed, matrix, subtract, multiply, unaryMinus, lup }) +export const inv = createInv({ typed, matrix, divideScalar, addScalar, multiply, unaryMinus, det, identity, abs }) +export const expm = createExpm({ typed, abs, add, identity, inv, multiply }) +export const sqrtm = createSqrtm({ typed, abs, add, multiply, sqrt, subtract, inv, size, max, identity }) + +// arithmetic (4) +export const divide = createDivide({ typed, matrix, multiply, equalScalar, divideScalar, inv }) + +// statistics (4) +export const mean = createMean({ typed, add, divide }) +export const median = createMedian({ typed, add, divide, compare, partitionSelect }) +export const mad = createMad({ typed, abs, map, median, subtract }) +export const variance = createVariance({ typed, add, subtract, multiply, divide, isNaN }) +export const std = createStd({ typed, sqrt, variance }) + +// algebra (4) +const simplifyCore = createSimplifyCore({ + equal, + isZero, + add, + subtract, + multiply, + divide, + pow, + expression: { + node: { + ConstantNode, + OperatorNode, + FunctionNode, + ParenthesisNode + } + } +}) +const simplifyConstant = createSimplifyConstant({ + typed, + config, + math: math2, + fraction, + bignumber, + expression: { + node: { + ConstantNode, + OperatorNode, + FunctionNode, + SymbolNode + } + } +}) +const resolve = createResolve({ expression: { parse, node: { Node, FunctionNode, OperatorNode, ParenthesisNode } } }) +export const simplify = createSimplify({ + typed, + math: math2, + parse, + equal, + algebra: { + simplify: { + simplifyConstant, + simplifyCore, + resolve + } + }, + expression: { + node: { + ConstantNode, + FunctionNode, + OperatorNode, + ParenthesisNode, + SymbolNode + } + } +}) +export const derivative = createDerivative({ + typed, + config, + parse, + simplify, + equal, + isZero, + numeric, + expression: { + node: { + ConstantNode, + FunctionNode, + OperatorNode, + ParenthesisNode, + SymbolNode + } + } +}) +export const rationalize = createRationalize({ + typed, + parse, + simplify, + algebra: { + simplify: { + simplifyConstant, + simplifyCore + } + }, + expression: { + node: { + ConstantNode, + OperatorNode, + SymbolNode + } + } +}) + // TODO: export constants // TODO: export physical constants export const expression = { docs: createEmbeddedDocs() } + +// TODO: create an export default for backward compatibility, with the whole old structure diff --git a/src/type/complex/Complex.js b/src/type/complex/Complex.js index e7d7ea530..ad0d59973 100644 --- a/src/type/complex/Complex.js +++ b/src/type/complex/Complex.js @@ -6,9 +6,9 @@ import { isUnit, isNumber } from '../../utils/is' import { factory } from '../../utils/factory' const name = 'type.Complex' -const dependencies = ['config', 'on'] +const dependencies = ['typed', 'config', 'on'] -export const createComplexClass = factory(name, dependencies, ({ config, on }) => { +export const createComplexClass = factory(name, dependencies, ({ typed, config, on }) => { /** * Attach type information */ @@ -191,5 +191,11 @@ export const createComplexClass = factory(name, dependencies, ({ config, on }) = return 0 } + // register with typed + typed.type.Complex = Complex + return Complex }) + +// no lazy loading, we need to register with typed.type +createComplexClass.lazy = false diff --git a/test/function/arithmetic/abs.test.js b/test/function/arithmetic/abs.test.js index 272235053..f62c3d230 100644 --- a/test/function/arithmetic/abs.test.js +++ b/test/function/arithmetic/abs.test.js @@ -1,109 +1,109 @@ // test abs import assert from 'assert' -import math from '../../../src/main' +import { abs, bignumber, complex, fraction, matrix, Matrix, unit, parse } from '../../../src/mainAll' describe('abs', function () { it('should return the abs value of a boolean', function () { - assert.strictEqual(math.abs(true), 1) - assert.strictEqual(math.abs(false), 0) + assert.strictEqual(abs(true), 1) + assert.strictEqual(abs(false), 0) }) it('should not support null', function () { - assert.throws(function () { math.abs(null) }, /Unexpected type of argument/) + assert.throws(function () { abs(null) }, /Unexpected type of argument/) }) it('should return the abs value of a number', function () { - assert.strictEqual(math.abs(-4.2), 4.2) - assert.strictEqual(math.abs(-3.5), 3.5) - assert.strictEqual(math.abs(100), 100) - assert.strictEqual(math.abs(0), 0) + assert.strictEqual(abs(-4.2), 4.2) + assert.strictEqual(abs(-3.5), 3.5) + assert.strictEqual(abs(100), 100) + assert.strictEqual(abs(0), 0) }) it('should return the absolute value of a big number', function () { - assert.deepStrictEqual(math.abs(math.bignumber(-2.3)), math.bignumber(2.3)) - assert.deepStrictEqual(math.abs(math.bignumber('5e500')), math.bignumber('5e500')) - assert.deepStrictEqual(math.abs(math.bignumber('-5e500')), math.bignumber('5e500')) + assert.deepStrictEqual(abs(bignumber(-2.3)), bignumber(2.3)) + assert.deepStrictEqual(abs(bignumber('5e500')), bignumber('5e500')) + assert.deepStrictEqual(abs(bignumber('-5e500')), bignumber('5e500')) }) it('should return the absolute value of a complex number', function () { - assert.strictEqual(math.abs(math.complex(3, -4)), 5) - assert.strictEqual(math.abs(math.complex(1e200, -4e200)), 4.12310562561766e+200) + assert.strictEqual(abs(complex(3, -4)), 5) + assert.strictEqual(abs(complex(1e200, -4e200)), 4.12310562561766e+200) }) it('should return the absolute value of a fraction', function () { - const a = math.fraction('-1/3') - assert.strictEqual(math.abs(a).toString(), '0.(3)') + const a = fraction('-1/3') + assert.strictEqual(abs(a).toString(), '0.(3)') assert.strictEqual(a.toString(), '-0.(3)') - assert.strictEqual(math.abs(math.fraction('1/3')).toString(), '0.(3)') + assert.strictEqual(abs(fraction('1/3')).toString(), '0.(3)') }) it('should convert a string to a number', function () { - assert.strictEqual(math.abs('-2'), 2) + assert.strictEqual(abs('-2'), 2) }) it('should return the absolute value of all elements in an Array', function () { - let a1 = math.abs([1, -2, 3]) + let a1 = abs([1, -2, 3]) assert.ok(Array.isArray(a1)) assert.deepStrictEqual(a1, [1, 2, 3]) - a1 = math.abs([-2, -1, 0, 1, 2]) + a1 = abs([-2, -1, 0, 1, 2]) assert.ok(Array.isArray(a1)) assert.deepStrictEqual(a1, [2, 1, 0, 1, 2]) }) it('should return the absolute number of a complex number with zero', function () { - assert.strictEqual(math.abs(math.complex(1, 0)), 1) - assert.strictEqual(math.abs(math.complex(0, 1)), 1) - assert.strictEqual(math.abs(math.complex(0, 0)), 0) - assert.strictEqual(math.abs(math.complex(-1, 0)), 1) - assert.strictEqual(math.abs(math.complex(0, -1)), 1) + assert.strictEqual(abs(complex(1, 0)), 1) + assert.strictEqual(abs(complex(0, 1)), 1) + assert.strictEqual(abs(complex(0, 0)), 0) + assert.strictEqual(abs(complex(-1, 0)), 1) + assert.strictEqual(abs(complex(0, -1)), 1) }) it('should return the absolute value of all elements in a matrix', function () { - let a1 = math.abs(math.matrix([1, -2, 3])) - assert.ok(a1 instanceof math.type.Matrix) + let a1 = abs(matrix([1, -2, 3])) + assert.ok(a1 instanceof Matrix) assert.deepStrictEqual(a1.size(), [3]) assert.deepStrictEqual(a1.valueOf(), [1, 2, 3]) - a1 = math.abs(math.matrix([-2, -1, 0, 1, 2])) - assert.ok(a1 instanceof math.type.Matrix) + a1 = abs(matrix([-2, -1, 0, 1, 2])) + assert.ok(a1 instanceof Matrix) assert.deepStrictEqual(a1.size(), [5]) assert.deepStrictEqual(a1.valueOf(), [2, 1, 0, 1, 2]) }) it('should return the absolute value of a unit', function () { - let u = math.abs(math.unit('5 m')) + let u = abs(unit('5 m')) assert.strictEqual(u.toString(), '5 m') - u = math.abs(math.unit('-5 m')) + u = abs(unit('-5 m')) assert.strictEqual(u.toString(), '5 m') - u = math.abs(math.unit('-283.15 degC')) + u = abs(unit('-283.15 degC')) assert.strictEqual(u.toString(), '-263.15 degC') - u = math.abs(math.unit(math.fraction(2, 3), 'm')) + u = abs(unit(fraction(2, 3), 'm')) assert.strictEqual(u.toString(), '2/3 m') - u = math.abs(math.unit(math.complex(-4, 3), 'in')) + u = abs(unit(complex(-4, 3), 'in')) assert.strictEqual(u.toString(), '5 in') }) it('should throw an error in case of invalid number of arguments', function () { - assert.throws(function () { math.abs() }, /TypeError: Too few arguments/) - assert.throws(function () { math.abs(1, 2) }, /TypeError: Too many arguments/) + assert.throws(function () { abs() }, /TypeError: Too few arguments/) + assert.throws(function () { abs(1, 2) }, /TypeError: Too many arguments/) }) it('should throw an in case of wrong type of arguments', function () { - assert.throws(function () { math.abs(null) }, /TypeError: Unexpected type of argument/) + assert.throws(function () { abs(null) }, /TypeError: Unexpected type of argument/) }) it('should throw an error in case of unsupported types', function () { - assert.throws(function () { math.abs(new Date()) }, /TypeError: Unexpected type of argument/) - assert.throws(function () { math.abs(null) }, /TypeError: Unexpected type of argument/) - assert.throws(function () { math.abs(undefined) }, /TypeError: Unexpected type of argument/) + assert.throws(function () { abs(new Date()) }, /TypeError: Unexpected type of argument/) + assert.throws(function () { abs(null) }, /TypeError: Unexpected type of argument/) + assert.throws(function () { abs(undefined) }, /TypeError: Unexpected type of argument/) }) it('should LaTeX abs', function () { - const expression = math.parse('abs(-1)') + const expression = parse('abs(-1)') assert.strictEqual(expression.toTex(), '\\left|-1\\right|') }) })