eXept Software AG Logo

Smalltalk/X Webserver

Documentation of class 'Float':

Home

Documentation
www.exept.de
Everywhere
for:
[back]

Class: Float


Inheritance:

   Object
   |
   +--Magnitude
      |
      +--ArithmeticValue
         |
         +--Number
            |
            +--LimitedPrecisionReal
               |
               +--Float

Package:
stx:libbasic
Category:
Magnitude-Numbers
Version:
rev: 1.261 date: 2018/05/09 23:24:05
user: stefan
file: Float.st directory: libbasic
module: stx stc-classLibrary: libbasic
Author:
Claus Gittinger

Description:


Floats represent rational numbers with limited precision.
They use the C-compilers 'double' format, which is usually the 8byte IEEE double float format.

Floats give you 64 bit floats.
In contrast to ShortFloats (32bit) and LongFloats (>=64bit).

WARNING:
    The layout of Float instances is known by the runtime system and the compiler;
    you may not add instance variables here.
    Also, subclassing is complicated by the fact, that the VM creates floats/shortFloats,
    and does some float-checks by an identity compare with the Float-class.
    (i.e. your subclasses instances may not be recognized as float-like objects,
     thus mixed mode arithmetic will always coerce them, effectively slowing things down).

Notice, that Floats are defined as Byte-array to prevent the garbage collector
from going into the value ... otherwise I needed a special case in many places.

Also notice, that ST/X Floats are what Doubles are in ST-80. The reason for doing this
was to be compatible to both Digitalk, Squeak AND ParcPlace smalltalk implementations
(ParcPlace uses a 4-byte Float and an 8-byte Double class, in contrast to
 Digitalk and Squeak, which have an 8-byte Float class).
Thus, by providing an 8-byte Float class, code would not loose precicion
(although some memory is wasted when porting from VW).
Notice that ST/X provides an alias called Double, and an extra ShortFloat class, which has 4-byte
instances.

Mixed mode arithmetic:
    float op float       -> float
    float op fix         -> float
    float op fraction    -> float
    float op integer     -> float
    float op shortFloat  -> float
    float op longFloat   -> longFloat
    float op complex     -> complex

Representation:
        64bit double precision IEEE floats
        53 bit mantissa,
        11 bit exponent,
        15 decimal digits (approx)

Range and Precision of Storage Formats: see LimitedPrecisionReal >> documentation


Related information:

    Number
    ShortFloat
    LongFloat
    Fraction
    FixedPoint
    Integer
    Complex
    FloatArray
    DoubleArray

Class protocol:

accessing
o  defaultPrintFormat

o  defaultPrintFormat: something

o  defaultPrintfFormat

o  defaultPrintfFormat: something

o  epsilon
return the maximum relative spacing of instances of mySelf
(i.e. the value-delta of the least significant bit)

binary storage
o  readBinaryIEEEDoubleFrom: aStream
read a float from the binary stream, aStream,
interpreting the next bytes as an IEEE formatted 8-byte float.
The bytes are read in the native byte order (i.e.lsb on intel)

o  readBinaryIEEEDoubleFrom: aStream MSB: msbFirst
read a float from the binary stream, aStream,
interpreting the next bytes as an IEEE formatted 8-byte float.
The bytes are read in the specified byte order

o  readBinaryIEEEDoubleFrom: aStream into: aBasicNewFloat
read the receiver's value from the binary stream, aStream,
interpreting the next bytes as an IEEE formatted 8-byte float.
The bytes are read in the native byte order (i.e.lsb on intel)

o  readBinaryIEEEDoubleFrom: aStream into: aFloat MSB: msb
read the receiver's value from the binary stream, aStream,
interpreting the next bytes as an IEEE formatted 8-byte float.
If msb is true, the stream bytes are most-significant-first.

o  storeBinaryIEEEDouble: aFloat on: aStream
store aFloat as an IEEE formatted 8-byte float
onto the binary stream, aStream.
The bytes are written in the native byte order (i.e.lsb on intel)

o  storeBinaryIEEEDouble: aFloat on: aStream MSB: msb
store aFloat as an IEEE formatted 8-byte float
onto the binary stream, aStream.
If msb is true, the stream bytes are written most-significant-first.

class initialization
o  initialize
print 15 valid digits
usage example(s):
     Pi := nil.
     self initialize

coercing & converting
o  coerce: aNumber
convert the argument aNumber into an instance of the receiver (class) and return it.

constants
o  NaN
return the constant NaN (not a Number)
usage example(s):
     Float NaN
     Float NaN + 0.0
     Float NaN + Float NaN
     0.0 + Float NaN

     it's a singleton:

     Float NaN == Float NaN

o  e
return the constant e as Float
usage example(s):
don't expect this many valid digits on all machines;
usage example(s):
The actual precision is very CPU specific.

o  emax
Answer the maximum exponent for this representation.

o  emin
Answer the minimum exponent for this representation.

o  halfpi
return the constant pi/2 as Float

o  halfpiNegative
return the constant -pi/2 as Float

o  infinity
return a float which represents positive infinity
usage example(s):
     Float infinity == Float infinity

o  ln10
return the natural logarithm of 10;
will return something like 2.30258509299405

o  ln2
return the natural logarithm of 2

o  maxSmallInteger
return the max. smallInteger value as a float

o  negativeInfinity
return a float which represents positive infinity
usage example(s):
     Float negativeInfinity == Float negativeInfinity

o  pi
return the constant pi as Float

o  sqrt2
don't expect this many valid digits on all machines;

o  unity
return the neutral element for multiplication (1.0) as Float

o  zero
return the neutral element for addition (0.0) as Float

instance creation
o  basicNew
return a new float - here we return 0.0
- floats are usually NOT created this way ...
Its implemented here to allow things like binary store & load
of floats. (but even this support will go away eventually, its not
a good idea to store the bits of a float - the reader might have a
totally different representation - so floats will eventually be
binary stored in a device independent format.

o  fastFromString: aString at: startIndex
return the next Float from the string starting at startIndex.
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 fastFromString:'123.45' at:1
     Float fastFromString:'123.45' at:2
     Float fastFromString:'123.45' at:3
     Float fastFromString:'123.45' at:4
     Float fastFromString:'123.45' at:5
     Float fastFromString:'123.45' at:6

     Float fastFromString:'123.45E4' at:1
     Float fastFromString:'hello123.45E4' at:6
     Float fastFromString:'12345' at:1
     Float fastFromString:'12345' at:2
     Float fastFromString:'12345' at:3
     Float fastFromString:'12345' at:4
     Float fastFromString:'12345' at:5

     Float fastFromString:'12345' at:6          -> error
     Float fastFromString:'12345' at:0          -> error

     Float fastFromString:'hello123.45E4' at:1  -> 0

     Time millisecondsToRun:[
	100000 timesRepeat:[
	    Float readFrom:'123.45'
	]
     ]
usage example(s):
     Time millisecondsToRun:[
	100000 timesRepeat:[
	    Float fastFromString:'123.45' at:1
	]
     ]

o  fromIEEE32Bit: anInteger
creates a double, given the four native float bytes as an integer
usage example(s):
     ShortFloat fromIEEE32Bit:((ShortFloat pi digitBytesMSB:true) asIntegerMSB:true)

o  fromIEEE64Bit: anInteger
creates a double, given the eight native double bytes as an integer
usage example(s):
	Float fromIEEE64Bit:((Float pi digitBytesMSB:true) asIntegerMSB:true)

o  fromInteger: anInteger
return a new float, given an integer value
usage example(s):
     Float fromInteger:123
     Float fromInteger:(100 factorial)
     (100 factorial) asFloat

o  fromNumber: aNumber
return aNumber coerced to Float

o  fromVAXFloatBytes: b1 b2: b2 b3: b3 b4: b4
creates a double, given the four vax F-format float bytes to an ieee double.
For NaNs and Infinity, nil is returned.
To get an idea of how big the floating-point zoo really is,
see: http://www.quadibloc.com/comp/cp0201.htm

misc
o  getFPUControl
get the fpu control word.
usage example(s):
     self getFPUControl

o  setFPUControl
BORLAND only: set the fpu control word for 64 bit precision for long doubles here
usage example(s):
     self setFPUControl

queries
o  exponentCharacter

o  isBuiltInClass
return true if this class is known by the run-time-system.
Here, true is returned for myself, false for subclasses.

o  numBitsInExponent
answer the number of bits in the exponent
This is an IEEE float, where 11 bits are available:
seeeeeee eeeemmmm mmmmmmmm mmmmmmmm mmmmmmmm mmmmmmmm mmmmmmmm mmmmmmmm

o  numBitsInMantissa
answer the number of bits in the mantissa.
This is an IEEE double, where 52 bits (the hidden one is not counted here) are available:
seeeeeee eeeemmmm mmmmmmmm mmmmmmmm mmmmmmmm mmmmmmmm mmmmmmmm mmmmmmmm

o  precision
answer the precision of a Float (in bits)
This is an IEEE double, where only the fraction from the normalized mantissa is stored
and so there is a hidden bit and the mantissa is actually represented
by 53 binary digits (although only 52 are needed in the binary representation)
usage example(s):
     self numBitsInMantissa + 1
     self precision

o  radix
answer the radix of a Floats exponent
This is an IEEE float, which is represented as binary


Instance protocol:

arithmetic
o  * aNumber
return the product of the receiver and the argument.

o  + aNumber
return the sum of the receiver and the argument, aNumber

o  - aNumber
return the difference of the receiver and the argument, aNumber

o  / aNumber
return the quotient of the receiver and the argument, aNumber

o  abs
return the absolute value of the receiver
reimplemented here for speed
usage example(s):
     3.0 abs
     -3.0 abs

o  negated
return the receiver negated

o  rem: aNumber
return the floating point remainder of the receiver and the argument, aNumber

o  uncheckedDivide: aNumber
return the quotient of the receiver and the argument, aNumber.
Do not check for divide by zero (return NaN or Infinity).
This operation is provided for emulators of other languages/semantics,
where no exception is raised for these results (i.e. Java).
It is only defined if the argument's type is the same as the receiver's.
usage example(s):
      0.0 uncheckedDivide:0.0
      1.0 uncheckedDivide:0.0
      -1.0 uncheckedDivide:0.0

coercing & converting
o  asDouble
ST80 compatibility: return a double with the receiver's value.
In ST/X, floats are the equivalent to ST80 doubles

o  asFloat
return a float with same value - that's me

o  asInteger
return an integer with same value - might truncate
usage example(s):
12345.0 asInteger
usage example(s):
1e15 asInteger

o  asLongFloat
return a longFloat with same value as receiver
usage example(s):
     123 asFloat asLongFloat

o  asQDouble
( an extension from the stx:libbasic2 package )
return a QDouble with my value
usage example(s):
     1.0 asQDouble

o  asShortFloat
return a shortFloat with same value as receiver.
CAVEAT: should raise an error if the receiver exceeds the float range.

o  asTrueFraction
Answer a fraction or integer that EXACTLY represents the receiver,
a double precision IEEE floating point number.
Floats are stored in the same form on all platforms.
(Does not handle gradual underflow or NANs.)
By David N. Smith with significant performance
improvements by Luciano Esteban Notarfrancesco.
(Version of 11April97)
usage example(s):
(result asFloat = self) ifFalse: [self error: 'asTrueFraction validation failed'].
usage example(s):
     0.3 asTrueFraction          - as you can see, Float is not able to represent this exactly
     1.25 asTrueFraction         - but this one (it is a sum of powers of two)
     0.25 asTrueFraction
     -0.25 asTrueFraction
     3e37 asTrueFraction
     2e37 asTrueFraction
     1e37 asTrueFraction
     1e30 asTrueFraction
     Float NaN asTrueFraction
     Float infinity asTrueFraction

o  coerce: aNumber
convert the argument aNumber into an instance of the receiver's class and return it.

o  generality
return the generality value - see ArithmeticValue>>retry:coercing:

comparing
o  < aNumber
return true, if the argument is greater

o  <= aNumber
return true, if the argument is greater or equal

o  = aNumber
return true, if the argument represents the same numeric value
as the receiver, false otherwise

o  > aNumber
return true, if the argument is less

o  >= aNumber
return true, if the argument is less or equal

o  hash
return a number for hashing; redefined, since floats compare
by numeric value (i.e. 3.0 = 3), therefore 3.0 hash must be the same
as 3 hash.
usage example(s):
     mhmh take some of my value-bits to hash on
usage example(s):
     3 hash
     3.0 hash
     3.1 hash
     3.14159 hash
     31.4159 hash
     3.141591 hash
     1.234567890123456 hash
     1.234567890123457 hash
     Set withAll:#(3 3.0 99 99.0 3.1415)

o  isAlmostEqualTo: aNumber nEpsilon: nE
return true, if the argument, aNumber represents almost the same numeric value
as the receiver, false otherwise.

nE is the number of minimal float distances, that the numbers may differ and
still be considered equal.
That is an integer, which counts the delta-steps in the mantissa.
Notice, that the absolute value of the epsilon depends on the receiver
(i.e. with a receiver of 10^17, a mantissa-step is much larger than with 10^-17 as receiver)

For background information why floats need this
read: http://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/

usage example(s):
        67329.234 isAlmostEqualTo:67329.23400000001 nEpsilon:1
        1.0 isAlmostEqualTo:1.0001 nEpsilon:1
        1.0 isAlmostEqualTo:-1.0 nEpsilon:1
        1 isAlmostEqualTo:1.000000000000001 nEpsilon:1
        1 isAlmostEqualTo:1.000000000000001 nEpsilon:10
        1.0 isAlmostEqualTo:1 nEpsilon:1
        1.0 isAlmostEqualTo:1 asFraction nEpsilon:1
        0.0 isAlmostEqualTo:0 nEpsilon:1
        0.0 isAlmostEqualTo:self epsilon nEpsilon:1

o  ~= aNumber
return true, if the arguments value are not equal

mathematical functions
o  cbrt
return the cubic root of myself.
usage example(s):
     8 cbrt
     -8 cbrt

o  exp
return e raised to the power of the receiver

o  ldexp: exp
multiply the receiver by an integral power of 2.
I.e. return self * (2 ^ exp)
usage example(s):
     1.0 ldexp:16

o  ln
return the natural logarithm of myself.
Raises an exception, if the receiver is less or equal to zero.

o  log10
return the base-10 logarithm of the receiver.
Raises an exception, if the receiver is less or equal to zero.

o  raisedTo: aNumber
return self raised to the power of aNumber

o  sqrt
return the square root of myself.
Raises an exception, if the receiver is less than zero.
usage example(s):
     10 sqrt
     -10 sqrt

printing & storing
o  printOn: aStream
append a printed representation of the receiver to
the argument, aStream.

I use #printString instead of #printOn: as basic print mechanism.

o  printString
return a printed representation of the receiver;
if not specified otherwise (by setting DefaultPrintFormat),
6 valid digits are printed.
LimitedPrecisonReal and its subclasses use #printString instead of
#printOn: as basic print mechanism.
usage example(s):
	Float pi printString.
	1.0 printString
	1.234 printString
	1e10 printString
	1e-60 printString
	1.2e3 printString
	1.2e30 printString
	(1.0 uncheckedDivide:0) printString
	(0.0 uncheckedDivide:0) printString
	self pi printString.

	DecimalPointCharacter := $,.
	1.234 printString.
	1.0 printString.
	1e10 printString.
	1.2e3 printString.
	1.2e30 printString.
	(1.0 uncheckedDivide:0) printString.
	(0.0 uncheckedDivide:0) printString.
	DecimalPointCharacter := $.

o  printStringWithFormat: format
return a printed representation of the receiver;
fmt must be of the form: .nn, where nn is the number of digits.
To print 6 valid digits, use printStringWithFormat:'.6'
For Floats, the default used in printString, is 15 (because its a double);
for ShortFloats, it is 6 (because it is a float)

o  printfPrintString: formatString
non-standard: return a printed representation of the receiver
as specified by formatString, which is defined by printf.

If you use this, be aware, that specifying doubles differs on
systems; on SYSV machines you have to give something like %lf,
while on BSD systems the format string has to be %F.
Also, the resulting string may not be longer than 255 bytes -
since that's the (static) size of the buffer.

This method is NONSTANDARD and may be removed without notice.
WARNNG: this goes directly to the C-printf function and may therefore me inherently unsafe.
Please use the printf: method, which is safe as it is completely implemented in Smalltalk.
usage example(s):
     Float pi printfPrintString:'%%lg -> %lg'
     Float pi printfPrintString:'%%lf -> %lf'
     Float pi printfPrintString:'%%7.15lg -> %7.15lg'
     Float pi printfPrintString:'%%7.5lf -> %7.5lf'
     Float pi printfPrintString:'%%G -> %G'
     Float pi printfPrintString:'%%F -> %F'
     Float pi printfPrintString:'%%7.5G -> %7.5G'
     Float pi printfPrintString:'%%7.5F -> %7.5F'

     Float pi printfPrintString:'%%7.5f -> %7.5f'
     Float pi printfPrintString:'%%100.98f -> %100.98f'
     Float pi printfPrintString:'%%100.6f -> %100.6f'
     Float pi printfPrintString:'%%300.6f -> %300.6f'

     Float pi printfPrintString:'%%-100.98f -> %-100.98f'
     Float pi printfPrintString:'%%300.298f -> %300.298f'
     Float pi printfPrintString:'%%-300.298f -> %-300.298f'

     Float pi printfPrintString:'%%100.6f -> <%100.6f>'
     Float pi printfPrintString:'%%300.6f -> <%300.6f>'

     Float pi printfPrintString:'%%100.6f -> <%100.6>'
     Float pi printfPrintString:'%%300.6f -> <%300.6>'

o  storeOn: aStream
append a printed representation of the receiver to
the argument, aStream.

I use #storeString instead of #storeOn: as basic store mechanism.

o  storeString
return a printed representation of the receiver;
all valid digits are printed.
LimitedPrecisonReal and its subclasses use #storeString instead of
#storeOn: as basic print mechanism.
usage example(s):
	1.0 storeString
	0.1 storeString
	((Array new:10 withAll:0.1) inject:0 into:[:v :sumSoFar| sumSoFar + v]) storeString
	1.234 storeString
	1e10 storeString
	1.2e3 storeString
	1.2e30 storeString
	Float pi storeString
	(1.0 uncheckedDivide:0) storeString
	(0.0 uncheckedDivide:0) storeString

     notice that the storeString is NOT affected by DecimalPointCharacterForPrinting:

	DecimalPointCharacterForPrinting := $,.
	1.234 storeString.
	1.0 storeString.
	1e10 storeString.
	1.2e3 storeString.
	1.2e30 storeString.
	(1.0 uncheckedDivide:0) storeString.
	(0.0 uncheckedDivide:0) storeString.
	DecimalPointCharacterForPrinting := $.

private
o  absDecimalPrintOn: aStream digits: digits
( an extension from the stx:libbasic2 package )
Place a string representation of the receiver's abs value
on <aStream> using <digits> significant digits, using decimal notation.
This is a helper for printf.

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

o  absPrintOn: aStream digits: digits
( an extension from the stx:libbasic2 package )
Place a string representation of the receiver's abs value on <aStream> using
<digits> significant digits.
This is a helper for printf.

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

o  absScientificPrintOn: aStream digits: digits
( an extension from the stx:libbasic2 package )
Place a string representation of the receiver's abs value on <aStream> using <digits> significant
digits, using scientific notation.
This is a helper for printf.

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

private-accessing
o  basicAt: index
return an internal byte of the float.
The value returned here depends on byte order, float representation etc.
Therefore, this method should be used strictly private.

Notice:
the need to redefine this method here is due to the
inability of many machines to store floats in non-double aligned memory.
Therefore, on some machines, the first 4 bytes of a float are left unused,
and the actual float is stored at index 5 .. 12.
To hide this at one place, this method knows about that, and returns
values as if this filler wasnt present.

o  basicAt: index put: value
set an internal byte of the float.
The value to be stored here depends on byte order, float representation etc.
Therefore, this method should be used strictly private.

Notice:
the need to redefine this method here is due to the
inability of many machines to store floats in non-double aligned memory.
Therefore, on some machines, the first 4 bytes of a float are left unused,
and the actual float is stored at index 5 .. 12.
To hide this at one place, this method knows about that, and returns
values as if this filler wasnt present.

o  basicSize
return the size in bytes of the float.

Notice:
the need to redefine this method here is due to the
inability of many machines to store floats in non-double aligned memory.
Therefore, on some machines, the first 4 bytes of a float are left unused,
and the actual float is stored at index 5 .. 12.
To hide this at one place, this method knows about that, and returns
values as if this filler wasn't present.

o  byteAt: index

o  byteAt: index put: newByte

queries
o  nextFloat: count
answer the next float count places after (or before if count is negative) myself
usage example(s):
     (1.0 nextFloat:1) storeString
     (67329.234 nextFloat:1) storeString
     (67329.234 asShortFloat nextFloat:1) storeString
     Float NaN nextFloat:100000
     Float infinity nextFloat:100000

special access
o  exponent
extract a normalized float's exponent.
The returned value depends on the float-representation of
the underlying machine and is therefore highly unportable.
This is not for general use.
This assumes that the mantissa is normalized to
0.5 .. 1.0 and the float's value is: mantissa * 2^exp
usage example(s):
     1.0 exponent
     2.0 exponent
     3.0 exponent
     4.0 exponent
     0.5 exponent
     0.4 exponent
     0.25 exponent
     0.2 exponent
     0.00000011111 exponent
     0.0 exponent
     1e1000 exponent

o  mantissa
extract a normalized floats mantissa.
The returned value depends on the float-representation of
the underlying machine and is therefore highly unportable.
This is not for general use.
This assumes that the mantissa is normalized to
0.5 .. 1.0 and the floats value is mantissa * 2^exp
usage example(s):
     1.0 exponent
     1.0 mantissa

     0.25 exponent
     0.25 mantissa

     0.00000011111 exponent
     0.00000011111 mantissa

     1e1000 mantissa

testing
o  isFinite
return true, if the receiver is a finite float
i.e. not NaN and not infinite.
usage example(s):
	1.0 isFinite
	self NaN isFinite
	self infinity isFinite
	(0.0 uncheckedDivide: 0.0) isFinite
	(1.0 uncheckedDivide: 0.0) isFinite

o  isInfinite
return true, if the receiver is an infinite float (Inf).
These are not created by ST/X float operations (they raise an exception);
however, inline C-code could produce them ...
Redefined here for speed
usage example(s):
	1.0 isInfinite
	(0.0 uncheckedDivide: 0.0) isInfinite
	(1.0 uncheckedDivide: 0.0) isInfinite
	(-1.0 uncheckedDivide: 0.0) isInfinite

o  isLiteral
return true, if the receiver can be used as a literal constant in ST syntax
(i.e. can be used in constant arrays)

o  isNaN
return true, if the receiver is an invalid float (NaN - not a number).
These are not created by ST/X float operations (they raise an exception);
however, inline C-code could produce them ...
usage example(s):
	self NaN isNaN
	1.0 isNaN
	(0.0 uncheckedDivide: 0.0) isNaN
	(1.0 uncheckedDivide: 0.0) isNaN
	(-1.0 uncheckedDivide: 0.0) isNaN

o  isNegativeZero
many systems have two float.Pnt zeros
usage example(s):
     0.0 isNegativeZero
     -0.0 isNegativeZero
     -1.0 isNegativeZero
     1.0 isNegativeZero

o  negative
return true if the receiver is less than zero.
-0.0 is positive for now.
usage example(s):
	0.0 negative
	-0.0 negative
	1.0 negative
	-1.0 negative
	(1.0 uncheckedDivide: 0.0) negative
	(-1.0 uncheckedDivide: 0.0) negative

o  numberOfBits
return the size (in bits) of the real;
typically, 64 is returned here,
but who knows ...
usage example(s):
     1.2 numberOfBits
     1.2 asShortFloat numberOfBits

o  positive
return true if the receiver is greater or equal to zero (not negative).
0.0 and -0.0 are positive for now.
usage example(s):
	0.0 positive
	-0.0 positive
	1.0 positive
	-1.0 positive
	(1.0 uncheckedDivide: 0.0) positive
	(-1.0 uncheckedDivide: 0.0) positive

o  strictlyPositive
return true if the receiver is greater than zero

tracing
o  traceInto: aRequestor level: level from: referrer
double dispatch into tracer, passing my type implicitely in the selector

trigonometric
o  arcCos
return the arccosine of the receiver (as radians).
Raises an exception, if the receiver is not in -1..1
usage example(s):
     -10 arcCos
     1 arcCos

o  arcCosh
return the hyperbolic arccosine of the receiver.
usage example(s):
     -10.0 arcCosh
     1.0 arcCosh

o  arcSin
return the arcsine of myself (I am interpreted as radians).
Raises an exception, if the receiver is not in -1..1
usage example(s):
     -10 arcSin
     1 arcSin

o  arcSinh
return the hyperbolic arcsine of the receiver.
usage example(s):
     -10.0 arcSinh
     1.0 arcSinh

o  arcTan
return the arctangent of the receiver (as radians)

o  arcTan2: x
return the atan2(self,x)

o  arcTan: denominator
Evaluate the four quadrant arc tangent of the argument denominator (x) and the receiver (y).

o  arcTanh
return the hyperbolic arctangent of the receiver.

o  cos
return the cosine of the receiver (interpreted as radians)

o  cosh
return the hyperbolic cosine of the receiver

o  sin
return the sine of the receiver (interpreted as radians)

o  sinh
return the hyperbolic sine of the receiver

o  tan
return the tangens of the receiver (interpreted as radians)

o  tanh
return the hyperbolic tangens of the receiver

truncation & rounding
o  ceiling
return the smallest integer which is greater or equal to the receiver.

o  ceilingAsFloat
return the smallest integer-valued float greater or equal to the receiver.
This is much like #ceiling, but avoids a (possibly expensive) conversion
of the result to an integer.
It may be useful, if the result is to be further used in another float-operation.
usage example(s):
     0.5 ceilingAsFloat
     -0.5 ceilingAsFloat
     -1.5 ceilingAsFloat

o  floor
return the integer nearest the receiver towards negative infinity.
usage example(s):
     0.5 floor
     0.5 floorAsFloat
     -0.5 floor
     -0.5 floorAsFloat

o  floorAsFloat
return the integer nearest the receiver towards negative infinity as a float.
This is much like #floor, but avoids a (possibly expensive) conversion
of the result to an integer.
It may be useful, if the result is to be further used in another float-operation.
usage example(s):
     0.5 floor
     0.5 floorAsFloat
     -0.5 floor
     -0.5 floorAsFloat

o  fractionPart
extract the after-decimal fraction part.
such that (self truncated + self fractionPart) = self
usage example(s):
     1.6 fractionPart + 1.6 truncated
     -1.6 fractionPart + -1.6 truncated

     1.0 fractionPart
     2.0 fractionPart
     3.0 fractionPart
     4.0 fractionPart
     0.5 fractionPart
     0.25 fractionPart
     3.14159 fractionPart
     12345673.14159 fractionPart
     123456731231231231.14159 fractionPart

     3.14159 fractionPart + 3.14159 truncated

     12345673.14159 fractionPart + 12345673.14159 truncated

     123456731231231231.14159 fractionPart + 123456731231231231.14159 truncated

o  rounded
return the receiver rounded to the nearest integer
usage example(s):
     0.4 rounded
     0.5 rounded
     0.6 rounded
     -0.4 rounded
     -0.5 rounded
     -0.6 rounded

o  roundedAsFloat
return the receiver rounded to the nearest integer as a float.
This is much like #rounded, but avoids a (possibly expensive) conversion
of the result to an integer.
It may be useful, if the result is to be further used in another
float-operation.
usage example(s):
     0.5 rounded
     -0.5 rounded
     0.5 roundedAsFloat
     -0.5 roundedAsFloat

o  truncated
return the receiver truncated towards zero as an integer
usage example(s):
     0.5 truncated
     -0.5 truncated
     0.5 truncatedAsFloat
     -0.5 truncatedAsFloat

o  truncatedAsFloat
return the receiver truncated towards zero as a float.
This is much like #truncated, but avoids a (possibly expensive) conversion
of the result to an integer.
It may be useful, if the result is to be further used in another
float-operation.
usage example(s):
     0.5 truncated
     -0.5 truncated
     0.5 truncatedAsFloat
     -0.5 truncatedAsFloat



ST/X 7.1.0.0; WebServer 1.663 at exept.de:8081; Fri, 22 Mar 2019 10:05:20 GMT