hg/stx-libbasic: comparison ShortFloat.st

equal deleted inserted replaced

-:fdf3a5b2f6b6
+:0b3c34125507
 to bothe VisualWorks and other Smalltalks, which use C-doubles for the Float class
 (i.e. VisualST and V'Age).
 Thus, STX's Float precision is not worse than that of other ST's.
 WARNING:
-The layout of shortFloat instances is known by the runtime system and the compiler;
+	The layout of shortFloat instances is known by the runtime system and the compiler;
-you may not add instance variables here.
+	you may not add instance variables here.
-Also, subclassing is complicated by the fact, that the VM creates floats/shortFloats,
+	Also, subclassing is complicated by the fact, that the VM creates floats/shortFloats,
-and does some of its float-checks by an identity compare with the ShortFloat-class.
+	and does some of its float-checks by an identity compare with the ShortFloat-class.
-(i.e. your subclasses instances may not be recognized as float-like objects,
+	(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).
+	 thus mixed mode arithmetic will always coerce them, effectively slowing things down).
-This may be changed, to use a flag bit in the class.
+	This may be changed, to use a flag bit in the class.
 Mixed mode arithmetic:
-shortFloat op shortFloat   -> shortFloat
+	shortFloat op shortFloat   -> shortFloat
-shortFloat op fix         -> shortFloat
+	shortFloat op fix         -> shortFloat
-shortFloat op fraction    -> shortFloat
+	shortFloat op fraction    -> shortFloat
-shortFloat op integer     -> shortFloat
+	shortFloat op integer     -> shortFloat
-shortFloat op longFloat   -> longFloat
+	shortFloat op longFloat   -> longFloat
-shortFloat op float       -> float
+	shortFloat op float       -> float
-shortFloat op complex     -> complex
+	shortFloat op complex     -> complex
 Representation:
-32bit single precision IEEE floats
+	    32bit single precision IEEE floats
-23 bit mantissa + 1 hidden bit, providing a precision of 24bits,
+	    23 bit mantissa + 1 hidden bit, providing a precision of 24bits,
-8 bit exponent,
+	    8 bit exponent,
-6 decimal digits (approx.)
+	    6 decimal digits (approx.)
 Range and Precision of Storage Formats: see LimitedPrecisionReal >> documentation
 [author:]
-Claus Gittinger
+	Claus Gittinger
 [see also:]
-Number
+	Number
-Float LongFloat Fraction FixedPoint Integer Complex
+	Float LongFloat Fraction FixedPoint Integer Complex
-FloatArray DoubleArray
+	FloatArray DoubleArray
 "
 ! !
 !ShortFloat class methodsFor:'instance creation'!
 No spaces are skipped.
 Raises an exception, if the startIndex is not valid.
 Returns garbage if the argument string is not a valid float number.
 This is a specially tuned entry (using a low-level C-call to atof).
 It has been added to allow high speed string decomposition
 into numbers, especially for mass-data (reading millions of floats)."
 %{   /* NOCONTEXT */
 if (__isStringLike(aString) && __isSmallInteger(startIndex)) {
-char *cp = (char *)(__stringVal(aString));
+	char *cp = (char *)(__stringVal(aString));
-int idx = __intVal(startIndex) - 1;
+	int idx = __intVal(startIndex) - 1;
-if ((unsigned)idx < __stringSize(aString)) {
+	if ((unsigned)idx < __stringSize(aString)) {
 #ifndef NO_STRTOF
-float strtof(const char *, char**);
+	    float strtof(const char *, char**);
-float val = strtof(cp+idx, NULL);
+	    float val = strtof(cp+idx, NULL);
 #else
-double atof(const char *);
+# ifndef NO_STRTOD
-double val = atof(cp + idx);
+	    double strtod(const char *, char**);
-#endif
+	    double val = strtod(cp+idx, NULL);
-RETURN (__MKSFLOAT(val));
+# else
-}
+	    double atof(const char *);
+	    double val = atof(cp + idx);
+# endif
+#endif
+	    RETURN (__MKSFLOAT(val));
+	}
 }
 %}.
 self primitiveFailed.
 "
 ShortFloat fastFromString:'hello123.45E4' at:1
 "
 "
 Time millisecondsToRun:[
-1000000 timesRepeat:[
+	1000000 timesRepeat:[
-ShortFloat readFrom:'123.45'
+	    ShortFloat readFrom:'123.45'
-]
+	]
 ]
 "
 "
 Time millisecondsToRun:[
-1000000 timesRepeat:[
+	1000000 timesRepeat:[
-ShortFloat fastFromString:'123.45' at:1
+	    ShortFloat fastFromString:'123.45' at:1
-]
+	]
 ]
 "
 "Modified (comment): / 27-10-2018 / 08:58:13 / Claus Gittinger"
 !
 !ShortFloat class methodsFor:'accessing'!
 defaultPrintFormat
 "/ by default, I will print 7 digits
 "/  ShortFloat pi   -> 3.141593
 "/  Float pi        -> 3.14159265358979
 "/  LongFloat pi    -> 3.141592653589793239
 ^ DefaultPrintFormat
 !
 defaultPrintFormat:aString
 NaN
 "return a shortFloat which represents not-a-Number (i.e. an invalid number)"
 NaN isNil ifTrue:[
-NaN := super NaN
+	NaN := super NaN
 ].
 ^ NaN
 "
 self NaN
 ].
 ^ E
 !
 eBias
 "Answer the exponent's bias;
 that is the offset of the zero exponent when stored"
 ^ 127
 !
 infinity
 "return a shortFloat which represents positive infinity (for my instances)"
 PositiveInfinity isNil ifTrue:[
-PositiveInfinity := Float infinity asShortFloat
+	PositiveInfinity := Float infinity asShortFloat
 ].
 ^ PositiveInfinity
 "Created: / 20-06-2017 / 13:44:45 / cg"
 "Modified (comment): / 08-06-2019 / 14:32:27 / Claus Gittinger"
 ln2
 "return the natural logarithm of 2 as a shortFloat"
 Ln2 isNil ifTrue:[
-Ln2 := Float ln2 asShortFloat
+	Ln2 := Float ln2 asShortFloat
 ].
 ^ Ln2
 "
 self ln2
 "return a shortFloat which represents negative infinity (for my instances).
 Warning: do not compare equal against infinities;
 instead, check using isFinite or isInfinite"
 NegativeInfinity isNil ifTrue:[
-NegativeInfinity := Float negativeInfinity asShortFloat
+	NegativeInfinity := Float negativeInfinity asShortFloat
 ].
 ^ NegativeInfinity
 "Created: / 20-06-2017 / 13:45:08 / cg"
 "Modified (comment): / 09-06-2019 / 12:57:11 / Claus Gittinger"
 phi
 "return the constant phi as ShortFloat"
 Phi isNil ifTrue:[
-Phi := Float phi asShortFloat
+	Phi := Float phi asShortFloat
 ].
 ^ Phi
 !
 pi
 epsilon
 "return the maximum relative spacing of instances of mySelf
 (i.e. the value-delta of the least significant bit)"
 Epsilon isNil ifTrue:[
-Epsilon := self computeEpsilon.
+	Epsilon := self computeEpsilon.
 ].
 ^ Epsilon
 "
 self epsilon
 !
 numBitsInExponent
 "answer the number of bits in the exponent
 This is an IEEE float, where 8 bits are available:
-seeeeeee emmmmmmm mmmmmmmm mmmmmmmm
+	seeeeeee emmmmmmm mmmmmmmm mmmmmmmm
 "
 ^ 8
 "
 For background information why floats need this
 read: http://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/
 "
 Epsilon isNil ifTrue:[
-Epsilon := self class computeEpsilon.
+	Epsilon := self class computeEpsilon.
 ].
 %{  /* NOCONTEXT */
 /*
 * (see the message send at the bottom)
 */
 INT32 ulpDiff;
 union {
-float f;
+	float f;
-INT32 i;
+	INT32 i;
 } myself, otherFloat;
 int nEpsilon;
 float scaledEpsilon;
 if (!__isSmallInteger(nE)) {
-goto tryHarder;
+	goto tryHarder;
 }
 nEpsilon =  __intVal(nE);
 scaledEpsilon = nEpsilon *__shortFloatVal(@global(Epsilon));
 if (__isSmallInteger(aNumber)) {
-otherFloat.f = (float)(__intVal(aNumber));
+	otherFloat.f = (float)(__intVal(aNumber));
 } else if (aNumber == nil) {
-RETURN(false)
+	RETURN(false)
 } else if (__qIsFloatLike(aNumber)) {
-otherFloat.f = (float)(__floatVal(aNumber));
+	otherFloat.f = (float)(__floatVal(aNumber));
 } else if (__qIsShortFloat(aNumber)) {
-otherFloat.f = __shortFloatVal(aNumber);
+	otherFloat.f = __shortFloatVal(aNumber);
 //    } else if (__qIsLongFloat(aNumber)) {
 //        otherFloat.f = (float)(__longFloatVal(aNumber));
 } else {
-goto tryHarder;
+	goto tryHarder;
 }
 myself.f = __shortFloatVal(self);
 // Check if the numbers are really close -- needed
 // when comparing numbers near zero (ULP method below fails for numbers near 0!).
 # ifdef NO_ABSF
 if (fabs((double)(myself.f - otherFloat.f)) <= scaledEpsilon) {
-RETURN(true);
+	RETURN(true);
 }
 # else
 // fprintf(stderr, "%.10f %.10f\n", fabsf(myself.f - otherFloat.f), scaledEpsilon);
 if (fabsf(myself.f - otherFloat.f) <= scaledEpsilon) {
-RETURN(true);
+	RETURN(true);
 }
 #endif
 // if the signs differ, the numbers are different
 if ((myself.f >= 0) != (otherFloat.f >= 0)) {
-RETURN(false);
+	RETURN(false);
 }
 // compute the difference of the 'units in the last place" ULP
 // (if ulpDiff == 1, two floats are adjecant)
 ulpDiff = myself.i - otherFloat.i;
 if (ulpDiff < 0) ulpDiff = -ulpDiff;
 if (ulpDiff <= nEpsilon) {
-RETURN(true);
+	RETURN(true);
 } else {
-RETURN(false)
+	RETURN(false)
 }
 tryHarder:;
 %}.
 ^ aNumber isAlmostEqualToFromShortFloat:self nEpsilon:nE
 "
-67329.234 asShortFloat isAlmostEqualTo:67329.23401 asShortFloat nEpsilon:1
+	67329.234 asShortFloat isAlmostEqualTo:67329.23401 asShortFloat nEpsilon:1
-1.0 asShortFloat isAlmostEqualTo:1.0000001 asShortFloat nEpsilon:1
+	1.0 asShortFloat isAlmostEqualTo:1.0000001 asShortFloat nEpsilon:1
-1.0 asShortFloat isAlmostEqualTo:1.0000001  nEpsilon:1
+	1.0 asShortFloat isAlmostEqualTo:1.0000001  nEpsilon:1
-1.0 asShortFloat isAlmostEqualTo:-1.0 nEpsilon:1
+	1.0 asShortFloat isAlmostEqualTo:-1.0 nEpsilon:1
-1.0 asShortFloat isAlmostEqualTo:1 nEpsilon:1
+	1.0 asShortFloat isAlmostEqualTo:1 nEpsilon:1
-0.0 asShortFloat isAlmostEqualTo:0.0000001 asShortFloat nEpsilon:1
+	0.0 asShortFloat isAlmostEqualTo:0.0000001 asShortFloat nEpsilon:1
-0.0 asShortFloat isAlmostEqualTo:0.000001 asShortFloat nEpsilon:1
+	0.0 asShortFloat isAlmostEqualTo:0.000001 asShortFloat nEpsilon:1
-0.0 asShortFloat isAlmostEqualTo:self epsilon nEpsilon:1
+	0.0 asShortFloat isAlmostEqualTo:self epsilon nEpsilon:1
-0.0 asShortFloat - 1.192093e-07 asShortFloat
+	0.0 asShortFloat - 1.192093e-07 asShortFloat
 "
 "Modified: / 10-05-2018 / 00:47:22 / stefan"
 !
 char buffer[256];
 OBJ s;
 int len;
 if (__isStringLike(formatString)) {
-/*
+	/*
-* actually only needed on sparc: since thisContext is
+	 * actually only needed on sparc: since thisContext is
-* in a global register, which gets destroyed by printf,
+	 * in a global register, which gets destroyed by printf,
-* manually save it here - very stupid ...
+	 * manually save it here - very stupid ...
-*/
+	 */
-__BEGIN_PROTECT_REGISTERS__
+	__BEGIN_PROTECT_REGISTERS__
-len = snprintf(buffer, sizeof(buffer), __stringVal(formatString), __shortFloatVal(self));
+	len = snprintf(buffer, sizeof(buffer), __stringVal(formatString), __shortFloatVal(self));
-__END_PROTECT_REGISTERS__
+	__END_PROTECT_REGISTERS__
-if (len < 0) goto fail;
+	if (len < 0) goto fail;
-if (len >= sizeof(buffer)) goto fail;
+	if (len >= sizeof(buffer)) goto fail;
-s = __MKSTRING_L(buffer, len);
+	s = __MKSTRING_L(buffer, len);
-if (s != nil) {
+	if (s != nil) {
-RETURN (s);
+	    RETURN (s);
-}
+	}
 }
 fail: ;
 #endif /* not __SCHTEAM__ */
 %}.
 ^ super printfPrintString:formatString
 // should we?
 if (!isnanf(myVal) && isfinitef(myVal))
 #endif
 {
 #if defined(__i386__) && defined(__GNUC__)
-float frac = frexpf(myVal, &exp);
+	float frac = frexpf(myVal, &exp);
-RETURN (__MKSFLOAT(frac));
+	RETURN (__MKSFLOAT(frac));
 #else
-double frac = frexp( (double)(myVal), &exp);
+	double frac = frexp( (double)(myVal), &exp);
-RETURN (__MKFLOAT(frac));
+	RETURN (__MKFLOAT(frac));
 #endif
 }
 %}.
 ^ super mantissa
 if (isfinitef(fV)) { RETURN (true); }
 %}.
 ^ false
 "
-1.0 asShortFloat isFinite
+	1.0 asShortFloat isFinite
-(0.0 asShortFloat uncheckedDivide: 0.0) isFinite
+	(0.0 asShortFloat uncheckedDivide: 0.0) isFinite
-(1.0 asShortFloat uncheckedDivide: 0.0) isFinite
+	(1.0 asShortFloat uncheckedDivide: 0.0) isFinite
 "
 !
 isNaN
 "return true, if the receiver is an invalid float (NaN - not a number).
 #endif
 /*
 * ST-80 (and X3J20) returns integer.
 */
 if ((fVal >= (float)_MIN_INT) && (fVal <= (float)_MAX_INT)) {
-RETURN ( __mkSmallInteger( (INT) fVal ) );
+	RETURN ( __mkSmallInteger( (INT) fVal ) );
 }
 __qMKSFLOAT(val, fVal);
 %}.
 ^ val asInteger
 #endif
 /*
 * ST-80 (and X3J20) returns integer.
 */
 if ((fVal >= (float)_MIN_INT) && (fVal <= (float)_MAX_INT)) {
-RETURN ( __mkSmallInteger( (INT) fVal ) );
+	RETURN ( __mkSmallInteger( (INT) fVal ) );
 }
 __qMKSFLOAT(val, fVal);
 %}.
 ^ val asInteger
 float fVal;
 fVal = __shortFloatVal(self);
 #if (defined(__i386__) || defined(__x86_64__)) && defined(__GNUC__)
 if (fVal < 0.0) {
-fVal = ceilf(fVal - (float)0.5);
+	fVal = ceilf(fVal - (float)0.5);
 } else {
-fVal = floorf(fVal + (float)0.5);
+	fVal = floorf(fVal + (float)0.5);
 }
 #else
 if (fVal < 0.0) {
-fVal = (float)ceil((double)fVal - 0.5);
+	fVal = (float)ceil((double)fVal - 0.5);
 } else {
-fVal = (float)floor((double)fVal + 0.5);
+	fVal = (float)floor((double)fVal + 0.5);
 }
 #endif
 /*
 * ST-80 (and X3J20) return integer.
 */
 if ((fVal >= (float)_MIN_INT) && (fVal <= (float)_MAX_INT)) {
-RETURN ( __mkSmallInteger( (INT) fVal ) );
+	RETURN ( __mkSmallInteger( (INT) fVal ) );
 }
 __qMKSFLOAT(val, fVal);
 %}.
 ^ val asInteger
 OBJ v;
 fVal = __shortFloatVal(self);
 #if (defined(__i386__) || defined(__x86_64__)) && defined(__GNUC__)
 if (fVal < 0.0) {
-fVal = ceilf(fVal - (float)0.5);
+	fVal = ceilf(fVal - (float)0.5);
 } else {
-fVal = floorf(fVal + (float)0.5);
+	fVal = floorf(fVal + (float)0.5);
 }
 #else
 if (fVal < 0.0) {
-fVal = (float)ceil((double)fVal - 0.5);
+	fVal = (float)ceil((double)fVal - 0.5);
 } else {
-fVal = (float)floor((double)fVal + 0.5);
+	fVal = (float)floor((double)fVal + 0.5);
 }
 #endif
 __qMKSFLOAT(v, fVal);
 RETURN (v);
 %}
 float fVal;
 fVal = __shortFloatVal(self);
 #if (defined(__i386__) || defined(__x86_64__)) && defined(__GNUC__)
 if (fVal < 0.0) {
-fVal = ceilf(fVal);
+	fVal = ceilf(fVal);
 } else {
-fVal = floorf(fVal);
+	fVal = floorf(fVal);
 }
 #else
 if (fVal < 0.0) {
-fVal = (float)ceil((double)fVal);
+	fVal = (float)ceil((double)fVal);
 } else {
-fVal = (float)floor((double)fVal);
+	fVal = (float)floor((double)fVal);
 }
 #endif
 /*
 * ST-80 (and X3J20) returns integer.
 */
 if ((fVal >= (float)_MIN_INT) && (fVal <= (float)_MAX_INT)) {
-RETURN ( __mkSmallInteger( (INT) fVal ) );
+	RETURN ( __mkSmallInteger( (INT) fVal ) );
 }
 __qMKSFLOAT(val, fVal);
 %}.
 ^ val asInteger
 OBJ v;
 fVal = __shortFloatVal(self);
 #if (defined(__i386__) || defined(xx__x86_64__)) && defined(__GNUC__)
 if (fVal < 0.0) {
-fVal = ceilf(fVal);
+	fVal = ceilf(fVal);
 } else {
-fVal = floorf(fVal);
+	fVal = floorf(fVal);
 }
 #else
 if (fVal < 0.0) {
-fVal = (float)ceil((double)fVal);
+	fVal = (float)ceil((double)fVal);
 } else {
-fVal = (float)floor((double)fVal);
+	fVal = (float)floor((double)fVal);
 }
 #endif
 __qMKSFLOAT(v, fVal);
 RETURN (v);
 %}

changeset 24976	0b3c34125507
parent 24975	fdf3a5b2f6b6
child 24986	0ba981e902f9