Smalltalk/X Webserver

Documentation of class 'Number':

Class: Number

Inheritance
Description
Class protocol
Instance protocol

Inheritance:

   Object
   |
   +--Magnitude
      |
      +--ArithmeticValue
         |
         +--Number
            |
            +--Complex
            |
            +--FixedDecimal
            |
            +--Fraction
            |
            +--Integer
            |
            +--LimitedPrecisionReal
            |
            +--MetaNumber

Package:: stx:libbasic

Category:: Magnitude-Numbers

Version:: rev: 1.475 date: 2024/04/25 13:49:01; user: stefan; file: Number.st directory: libbasic; module: stx stc-classLibrary: libbasic

Description:

abstract superclass for all kinds of numbers

[class variables:]
    DecimalPointCharacterForPrinting          <Character>                     used when printing
    DecimalPointCharactersForReading          <Collection of Character>       accepted as decimalPointChars when reading

    DefaultDisplayRadix     the radix in which integers present their
                            displayString (which is used in inspectors)
                            If you are to look at many hex numbers, bitmasks
                            etc. you may set this to 2 or 16.
                            (avoids typing printStringRadix:.. all the time
                             - I know - I am lazy ;-). Default is 10.

copyrightCOPYRIGHT (c) 1988 by Claus Gittinger
             All Rights Reserved

This software is furnished under a license and may be used
only in accordance with the terms of that license and with the
inclusion of the above copyright notice.   This software may not
be provided or otherwise made available to, or used by, any
other person.  No title to or ownership of the software is
hereby transferred.

Class protocol:

Compatibility-VW

readIntegerFrom: aStream radix: radix: for VisualWorks compatibility

Javascript support

MAX_VALUE
( an extension from the stx:libjavascript package )

this is for JavaScript's Number.MAX_VALUE.
In expecco/stx-JS, there is no MAX_VALUE;
return something useful (simulate 64bits)

Usage example(s):

     JavaScriptParser
        evaluate:'Number.MAX_VALUE;'

MIN_VALUE
( an extension from the stx:libjavascript package )

this is for JavaScript's Number.MIN_VALUE.
In expecco/stx-JS, there is no MIN_VALUE;
return something useful (simulate 64bits)

Usage example(s):

     JavaScriptParser
        evaluate:'Number.MIN_VALUE;'

NEGATIVE_INFINITY
( an extension from the stx:libjavascript package )

this is for JavaScript's Number.NEGATIVE_INFINITY.
Return a special 'negative infinity' float value

Usage example(s):

     JavaScriptParser
        evaluate:'Number.NEGATIVE_INFINITY;'

NaN
( an extension from the stx:libjavascript package )

return the special 'not a number' float value

Usage example(s):

     JavaScriptParser
        evaluate:'Number.NaN;'

POSITIVE_INFINITY
( an extension from the stx:libjavascript package )

this is for JavaScript's Number.POSITIVE_INFINITY.
Return the special 'positive infinity' float value

Usage example(s):

     JavaScriptParser
        evaluate:'Number.POSITIVE_INFINITY;'

isFinite: aNumber
( an extension from the stx:libjavascript package )

this is for JavaScript's Number.isFinite().
In Smalltalk, you would ask the number.
Return true if the argument is not infinite

isInteger: something
( an extension from the stx:libjavascript package )

this is for JavaScript's Number.isInteger().
Return true, if something is an integer (or a float which is equal to its truncated value).
Slightly different from Smalltalk's isInteger instance message.
For JS compatibility

isNaN: aNumber
( an extension from the stx:libjavascript package )

this is for JavaScript's Number.isNaN().
Return true if the argument is NaN

js_new: argument
( an extension from the stx:libjavascript package )

this is for JavaScript's new Number().

parseFloat: aString
( an extension from the stx:libjavascript package )

this is for JavaScript's Number.parseFloat().
Read a float from aString.
Reads up to the first non-number character.
If there is no number at all at the beginning of aString, returns NaN

parseInt: aString
( an extension from the stx:libjavascript package )

this is for JavaScript's Number.parseInt().
Read an integer from aString.
Reads up to the first non-number character.
If there is no number at all at the beginning of aString, returns NaN

coercing & converting

nonFiniteCoercionFrom: aNumber to: rslt: conversion resulted in a non-finite result.
This common code handles NaN and infinities,
and raises an error otherwise.
If the error is proceeded, the non-finite result is returned.

constants

e

return the closest approximation of the irrational number e

** This method must be redefined in concrete classes (subclassResponsibility) **

eDigits

return th printString of the irrational number e,
with enough digits so that instances with different precision can read from it

halfPi

return Pi/2 in my representation (and accuracy).

halfPiDigits

return the printString of the irrational number pi/2,
with enough digits so that instances with different precision can read from it

halfPiNegative

return -Pi/2 in my representation (and accuracy).

halfpi

obsolete name for backward compatibility
return -Pi/2 in my representation (and accuracy).

halfpiNegative

obsolete name for backward compatibility
return -Pi/2 in my representation (and accuracy).

i

return the imaginary unit i

Usage example(s):

     1 + Number i          -> (1+1i)
     Number i + 10         -> (10+1i)
     Number i * Number i   -> -1

Usage example(s):

Modified (format): / 10-12-2020 / 22:22:55 / cg

ln10

return ln(10) in my representation (and accuracy).

** This method must be redefined in concrete classes (subclassResponsibility) **

ln10Digits

return th printString of the irrational number ln(10),
with enough digits so that instances with different precision can read from it

ln2

return ln(2) in my representation (and accuracy).

** This method must be redefined in concrete classes (subclassResponsibility) **

ln2Digits

return th printString of the irrational number ln(2),
with enough digits so that instances with different precision can read from it

negativeZero

if my concrete class supports it, return a zero with negative sign.
Otherwise just return zero

Usage example(s):

     FloatE negativeZero
     FloatD negativeZero
     FloatQ negativeZero
     LargeFloat negativeZero

phi

return Phi in my representation (and accuracy).

Usage example(s):

phi is (1+5 sqrt)/2

Usage example(s):

     Float phix
     LongFloat phix
     LargeFloat phix
     QuadFloat phix

phiDigits

return the printString of the irrational number phi,
with enough digits so that instances with different precision can read from it

pi

return Pi in my representation (and accuracy).
This is a fallback for all classes which have no special
representation for Pi (or which cannot represent it)

piDigits

return th printString of the irrational number pi,
with enough digits so that instances with different precision can read from it

piNegative

return -Pi in my representation (and accuracy).

sqrt2

return sqrt(2) in my representation (and accuracy).

** This method must be redefined in concrete classes (subclassResponsibility) **

sqrt2Digits

return th printString of the irrational number sqrt(2),
with enough digits so that instances with different precision can read from it

sqrt3

return sqrt(3) in my representation (and accuracy).

** This method must be redefined in concrete classes (subclassResponsibility) **

sqrt3Digits

return th printString of the irrational number sqrt(3),
with enough digits so that instances with different precision can read from it

twoPi

return Pi*2 in my representation (and accuracy).

twoPiNegative

return -Pi*2 in my representation (and accuracy).

constants & defaults

decimalPointCharacter

printed

** This is an obsolete interface - do not use it (it may vanish in future versions) **

decimalPointCharacter: aCharacter

printed

** This is an obsolete interface - do not use it (it may vanish in future versions) **

decimalPointCharacterForPrinting

printed

decimalPointCharacterForPrinting: aCharacter

printed

Usage example(s):

     1.5 printString

     Number decimalPointCharacterForPrinting:$,.
     1.5 printString
     Number decimalPointCharacterForPrinting:$..

decimalPointCharacters

accepted when converting from a string

** This is an obsolete interface - do not use it (it may vanish in future versions) **

decimalPointCharacters: aCollectionOfCharacters

accepted when converting from a string

** This is an obsolete interface - do not use it (it may vanish in future versions) **

decimalPointCharactersForReading

default when converting from a string

Usage example(s):

     1.5 printString

     Number decimalPointCharactersForReading:#( $. $,) .
     Number fromString:'1.5'.
     Number fromString:'1,5'.
     Number decimalPointCharactersForReading:#( $. ).

decimalPointCharactersForReading: aCollectionOfCharacters

accepted when converting from a string

Usage example(s):

     Number decimalPointCharactersForReading:#( $. $,) .
     Number fromString:'1.5'.
     Number fromString:'1,5'.
     Number decimalPointCharactersForReading:#( $. ).

nameOfInf

adjustable printname of infinity;
some prefer INF, some inf.
You can configure this by setting this variable

nameOfNaN

adjustable printname of NaN;
some prefer NAN, some nan and some even NaN.
You can configure this by setting this variable

error reporting

errorInfiniteArgument: receiver selector: selector

Number errorInfiniteArgument:Float infinity selector:'ln'

errorNaNArgument: receiver selector: selector

Number errorNaNArgument:Float NaN selector:'ln'

errorUnsupported

you may proceed from this error, to get an alternative representation result
(of course, maybe with with less than the expected precision)

raise: aSignalSymbolOrErrorClass receiver: someNumber selector: sel arg: arg errorString: text

ST-80 compatible signal raising. Provided for public domain numeric classes

Usage example(s):

     Number
        raise:#domainErrorSignal
        receiver:1.0
        selector:#sin
        arg:nil
        errorString:'foo bar test'

raise: aSignalSymbolOrErrorClass receiver: someNumber selector: sel errorString: text

ST-80 compatible signal raising. Provided for public domain numeric classes.
aSignalSymbolOrErrorClass is either an Error-subclass, or
the selector which is sent to myself, to retrieve the Exception class / Signal.

Usage example(s):

     Number
        raise:#domainErrorSignal
        receiver:1.0
        selector:#foo
        errorString:'foo bar test'

instance creation

coerce: aNumber

convert the argument aNumber into an instance of the receiver (class) and return it.

fastFromString: aString

return the next Float, Integer or ShortFloat from the string.
No spaces are skipped.

This is a specially tuned entry (using a low-level C-call), which
returns garbage if the argument string is not a valid float number.
It has been added to allow high speed string decomposition into numbers,
especially for mass-data.

Usage example(s):

     Float fromString:'12345.0'
     Float fastFromString:'12345.0'

     Integer fromString:'12345'
     Integer fastFromString:'12345'

     should be roughly 10times faster than the general method:

     Time millisecondsToRun:[
        100000 timesRepeat:[ Float fromString:'12345.0' ]
     ].
     Time millisecondsToRun:[
        100000 timesRepeat:[ Float fastFromString:'12345.0' ]
     ].

     Time millisecondsToRun:[
        100000 timesRepeat:[ Integer fromString:'12345' ]
     ].
     Time millisecondsToRun:[
        100000 timesRepeat:[ Integer fastFromString:'12345' ]
     ].

fastFromString: aString at: startIndex

return the next Float, Integer or ShortFloat from the string.
No spaces are skipped.
Returns zero, if there is no valid number at the startIndex.
Redefined for speed in subclasses.

This is the fallback handling nan and inf for the specially tuned entries (using a low-level C-call), which
which return garbage if the argument string is not a valid number.

Usage example(s):

     Integer fromString:'nan'  
     Integer fastFromString:'nan' at:1   
     Integer fastFromString:'inf' at:1   

     Float fromString:'12345.0'
     Float fastFromString:'xxx12345.0' at:4

     FixedPoint fromString:'12345.4'
     FixedPoint fastFromString:'xxx12345.4' at:4

     Fraction fromString:'12345.4'
     Fraction fastFromString:'xxx12345.4' at:4

     Integer fromString:'12345'
     Integer fastFromString:'xxx12345' at:4

     should be roughly 10times faster than the general method:

     Time millisecondsToRun:[
        100000 timesRepeat:[ Float fromString:'12345.0' ]
     ].
     Time millisecondsToRun:[
        100000 timesRepeat:[ Float fastFromString:'12345.0' ]
     ].

     Time millisecondsToRun:[
        100000 timesRepeat:[ Integer fromString:'12345' ]
     ].
     Time millisecondsToRun:[
        100000 timesRepeat:[ Integer fastFromString:'12345' ]
     ].

forNonFiniteNumber: aNumber

common code to create an instance corresponding to aNumber,
which must be one of NaN, +inf or -inf.

fromNumber: aNumber

return aNumber coerced to myself

fromString: aString