arnog left a comment

- Fixes the return value of 'sgn' for BoxedNumbers with a value of  'NaN': as a corollary fixes & now correctly computes return-value of  getter `BoxedSymbol.isNaN`, too.- Fix: for consistency, 'isNaN' & 'isInfinity' now trigger definition  binding (canonicalization), in similar manner to 'isOdd', 'isEven',  'isInteger'...  (This is appropriate because these may be considered  direct 'value inquiry' getters, similarly to these sibling properties)- Adds missing getter 'isFinite': computing the result using 'sgn' like  its sign-checking siblings 'isPositive', 'isNegative'...- Fix: several properties/getters now return a boolean in cases where  'undefined' should be returned (because, the symbol is unbound and  therefore not enough information is known). ^Notably, this is  restricted to the aforementioned - 'sgn' referencing - properties  'is(NaN/Infinity)' et cetera.- Fix: revise getter 'isInfinity' to now account for 'complex-infinity'Also includes various extra doc., including some corrections

Before: - ce.parse('\\sqrt{x}').root(3) -> '\\sqrt[5]{x}'Now - '\\sqrt[6]{x}

(Also, re-declares getter 'value' for BoxedNumbers, for purposes ofrefining its return-type)

'numberForm' now longer simply requests the 'canonical' version/propertyof boxed-numbers: these notably now being obsolete on account ofBoxedNumber instances always now being being required to be constructedcanonically.Instead, the 'structural' number-cast operations present in'boxFunction' - such as casting 'Rational' as a number where appropriate- are co-present in this function: albeit applicable morenarrowly to 'BoxedExpression' (only).Prior to this change, for a while now, 'numberForm' has therefore beenredundant.Notably also, 'boxFunction' now applies these operations during fullcanonicalization only, and not when just the 'Number' canonical-form isrequested.

- Fixes sign comp. functions 'is(Non)Positive/Negative' to account for  wider range of 'Sign' (type) values: and to also *consistently return  'undefined'* when comparing against complex-number signs.  Consequently, corresponding BoxedExpr methods now correctly compute  the sign for a wider range of values: particularly complex numbers  (including ComplexInfinity), and in some cases zero.  ^This fix may also be consider a *breaking* change, in that  'isPositive/Negative' et cet. will return 'undefined' for boxed  complex-numbers (i.e. indiciating inapplicability): whereas before  these would return 'false'.- Fixes, via broadening range of returned values, 'sgn' for  BoxedNumbers: this now accounting for all Infinity sign values.  Naturally, this also affects computation of 'sgn' for symbols with  values.  An '...-infinity' sign value is now correctly returned for +/-/~  Infinity for both BoxedNumbers, and symbols with these values.

… FN's now -> undefined; rectify BoxedFunction.isPure- WRT repeat evaluation of impure FN's (such as 'Random'): -Before: `expr.evaluate/N() -> Result1, Result1, Result1...` (i.e. essentially behaving as idempotent). -After:  `  ...             -> Result1, Result2, Result3...` (new results unrelated to previous)-`get value` (i.e. 'N().valueOf()') for boxed impure functions nowreturns 'undefined'. This contrasts from before in both senses of now returning 'undefined' instead of computing a value, and also by returning the same, first-call cached value on reach request.- 'isPure' (BoxedFunction) now returns a non-undefined/boolean result  for _non-canonical_/unbound functions.

Fundamental fixes:- 'powerForm' now calls 'canonicalPower', instead of 'a.pow(b)'- 'canonicalPower' - No longer casts passed args./exprs. as fully canonical - Generally, no longer performs operations wherein an operand, esp. the   exponent, is a function expression: e.g. '1^(2+3)' will no longer   simplify (but '1^5' still will do so).    -^There are reasonable exceptions, e.g. 'a^1' will always simplify    -^As will 'a^{-1}' - Values, including those temporarily assigned from assumptions, are no   longer looked to from symbols unless these are *non-constant*.   (Before, inadvertently, this could be the case) - More consistently, checks for _constant_ symbol values for   operations, such as whether 'b' is '1' in 'a^b'    -**warning**: this may be *incorrect* behaviour: since the    'holdUntil' attribute is not looked to (and this may be desirable).    Furthermore, if this is an oversight, then it may be the case that    symbols with a 'never' holdUntil value will be substituted with    their values before canonicalization/canonical-forms: therefore    accounting for symbol values here, or within any other    canonical-form, may be unnecessary & inappropriate. - One or two operation fixes, here & there (forgotten now) - More careful type-checking throughout: i.e. particularly   discriminating between 'real' & 'non-finite' numbers; in some cases   'complex', too...Changes:- Should be, significantly more optimized- !Currently, does not include the collapsing of multi-level exponents, e.g.  '{a^b}^{c} -> a^{b*c}'- Heavier with inversion- Several instances of accounting for wider ranges of values (mainly for  exponents): particularly for 'a^Infinity'.-Notes:- Now, canonicalPower only returns a new boxed-function with 'canonical:  true' when given args. are canonical.- !Function 'pow' - the first half more or less - is a replication of  what now takes place within canonicalPower: but is less thorough, and  may contain a few inaccuracies. Likely, would benefit from replacing  its first half with a call to 'canonicalPower'; which it anyway  replicates.

… controls for 'check'

This reverts commita8f85fa.This property/getter is largely unnecessary: because 'value' largely is  'constantValue' (the exception is for symbols: in which for non-constants its value may vary arbitrarily, or with assumptions).Note:- This *could* be introduced, perhaps exclusively for symbols; or its overall definition could be adjusted slightly such that it is useful for boxed-functions too.I.e., for a boxed-function, only return a value if 'isConstant' && 'isPure'. ('value' differs in that returns non-undefined if 'isPure', *only*...)