diff options
Diffstat (limited to 'src/algebra')
| -rw-r--r-- | src/algebra/outform.spad.pamphlet | 14 | ||||
| -rw-r--r-- | src/algebra/sf.spad.pamphlet | 151 |
2 files changed, 14 insertions, 151 deletions
diff --git a/src/algebra/outform.spad.pamphlet b/src/algebra/outform.spad.pamphlet index 1c340f3e..47486571 100644 --- a/src/algebra/outform.spad.pamphlet +++ b/src/algebra/outform.spad.pamphlet @@ -244,6 +244,9 @@ OutputForm(): SetCategory with ++ outputForm(sf) creates an form for small float sf. empty : () -> % ++ empty() creates an empty form. + doubleFloatFormat : String -> String + ++ change the output format for doublefloats using lisp + ++ format strings --% Sizings width: % -> Integer @@ -486,6 +489,12 @@ OutputForm(): SetCategory with car ==> CAR$Lisp cdr ==> CDR$Lisp + format: String := "~G" + doubleFloatFormat(s:String): String == + ss: String := format + format := s + ss + a, b: % l: List % s: String @@ -507,7 +516,10 @@ OutputForm(): SetCategory with coerce(a):OutputForm == a pretend OutputForm outputForm n == n pretend % outputForm e == e pretend % - outputForm(f:DoubleFloat) == f pretend % + outputForm(f:DoubleFloat) == + -- ??? this really should be rendered in as a sequence of + -- ??? OutputForm bytecodes, not hardcoded here. + FORMAT(NIL$Lisp,format,f)$Lisp outputForm s == sform concat(quote()$Character, concat(s, quote()$Character)) diff --git a/src/algebra/sf.spad.pamphlet b/src/algebra/sf.spad.pamphlet index 5a28b642..3fae80c1 100644 --- a/src/algebra/sf.spad.pamphlet +++ b/src/algebra/sf.spad.pamphlet @@ -204,146 +204,6 @@ FloatingPointSystem(): Category == RealNumberSystem() with @ \section{domain DFLOAT DoubleFloat} -Greg Vanuxem has added some functionality to allow the user to modify -the printed format of floating point numbers. The format of the numbers -follows the common lisp format specification for floats. First we include -Greg's email to show the use of this feature: -\begin{verbatim} -PS: For those who use the Doublefloat domain - there is an another (undocumented) patch that adds a - lisp format to the DoubleFloat output routine. Copy - int/algebra/DFLOAT.spad to your working directory, - patch it, compile it and ")lib" it when necessary. - - -(1) -> )boot $useBFasDefault:=false - -(SPADLET |$useBFasDefault| NIL) -Value = NIL -(1) -> a:= matrix [ [0.5978,0.2356], [0.4512,0.2355] ] - - + 0.5978 0.2356 + - (1) | | - +0.45119999999999999 0.23549999999999999+ - Type: Matrix DoubleFloat -(2) -> )lib DFLOAT - DoubleFloat is now explicitly exposed in frame initial - DoubleFloat will be automatically loaded when needed -from /home/greg/Axiom/DFLOAT.NRLIB/code -(2) -> doubleFloatFormat("~,4,,F") - - (2) "~G" - Type: String -(3) -> a - - +0.5978 0.2356+ - (3) | | - +0.4512 0.2355+ - Type: Matrix DoubleFloat - -\end{verbatim} -So it is clear that he has added a new function called -{\tt doubleFloatFormat} which takes a string argument that -specifies the common lisp format control string (\"{}\~{},4,,F\"{}). -For reference we quote from the common lisp manual \cite{1}. -On page 582 we find: - -\begin{quote} -A format directive consists of a tilde (\~{}), optional prefix -parameters separated by commas, optional colon (:) and at-sign (@) -modifiers, and a single character indicating what kind of directive this is. -The alphabetic case of the directive character is ignored. The prefix -parameters are generally integers, notated as optionally signed decimal -numbers. - -X3J13 voted in June 1987 (80) to specify that if both colon and at-sign -modifiers are present, they may appear in either order; thus \~{}:@R -and \~{}@:R mean the same thing. However, it is traditional to put the -colon first, and all examples in the book put colon before at-signs. -\end{quote} - -\noindent -On page 588 we find: - -\begin{quote} -\~{}F - -{\sl Fixed-format floating-point}. The next {\sl arg} is printed as a -floating point number. - -The full form is {\sl \~{}w,d,k,overfowchar,padchar}F. The parameter -{\sl w} is the width of the filed to be printed; {\sl d} is the number -of digits to print after the decimal point; {\sl k} is a scale factor -that defaults to zero. - -Exactly {\sl w} characters will be output. First, leading copies of the -character {\sl padchar} (which defaults to a space) are printed, if -necessary, to pad the field on the left. If the {\sl arg} is negative, -then a minus sign is printed; if the {\sl arg} is not negative, then -a plus signed is printed if and only if the @ modifier was specified. -Then a sequence of digits, containing a single embedded decimal point, -is printed; this represents the magnitude of the value of {\sl arg} -times $10^k$, rounded to {\sl d} fractional digits. (When rounding up -and rounding down would produce printed values equidistant from the -scaled value of {\sl arg}, then the implementation is free to use -either one. For example, printing the argument 6.375 using the format -\~{}4.2F may correctly produce either 6.37 or 6.38.) Leading zeros are -not permitted, except that a single zero digit is output before the -decimal point if the printed value is less than 1, and this single zero -digit is not output after all if $w = d + 1$. - -If it is impossible to print the value in the required format in the -field of width {\sl w}, then one of two actions is taken. If the -parameter {\sl overflowchar} is specified, then {\sl w} copies of that -parameter are printed instead of the scaled value of {\sl arg}. If the -{\sl overflowchar} parameter is omitted, then the scaled value is -printed using more than {\sl w} characters, as many more as may be -needed. - -If the {\sl w} parameter is omitted, then the field is of variable width. -In effect, a value is chosen for {\sl w} in such a way that no leading pad -characters need to be printed and exactly {\sl d} characters will follow -the decimal point. For example, the directive \~{},2F will print exactly -two digits after the decimal point and as many as necessary before the -decimal point. - -If the parameter {\sl d} is omitted, then there is no constraint on the -number of digits to appear after the decimal point. A value is chosen -for {\sl d} in such a way that as many digits as possible may be printed -subject to the width constraint imposed by the parameter {\sl w} and the -constraint that no trailing zero digits may appear in the fraction, except -that if the fraction to be printed is zero, then a single zero digit should -appear after the decimal point if permitted by the width constraint. - -If both {\sl w} and {\sl d} are omitted, then the effect is to print the -value using ordinary free-format output; {\tt prin1} uses this format -for any number whose magnitude is either zero or between $10^{-3}$ -(inclusive) and $10^7$ (exclusive). - -If {\sl w} is omitted, then if the magnitude of {\sl arg} is so large -(or, if {\sl d} is also omitted, so small) that more than 100 digits -would have to be printed, then an implementation is free, at its -discretion, to print the number using exponential notation instead, -as if by the directive \~{}E (with all parameters of \~{}E defaulted, -not taking their valued from the \~{}F directive). - -If {\sl arg} is a rational number, then it is coerced to be a -{\tt single-float} and then printed. (Alternatively, an implementation -is permitted to process a rational number by any other method that has -essentially the same behavior but avoids such hazards as loss of -precision or overflow because of the coercion. However, note that if -{\sl w} and {\sl d} are unspecified and the number has no exact decimal -representation, for example 1/3, some precision cutoff must be chosen -by the implementation; only a finite number of digits may be printed.) - -If {\sl arg} is a complex number or some non-numeric object, then it -is printed using the format directive {\sl \~{}w}D, thereby printing -it in decimal radix and a minimum field width of {\sl w}. (If it is -desired to print each of the real part and imaginary part of a -complex number using a \~{}F directive, then this must be done explicitly -with two \~{}F directives and code to extract the two parts of the -complex number.) - \end{quote} <<domain DFLOAT DoubleFloat>>= @@ -409,8 +269,6 @@ DoubleFloat(): Join(FloatingPointSystem, DifferentialRing, OpenMath, ++ Gamma(x) is the Euler Gamma function. Beta : (%,%) -> % ++ Beta(x,y) is \spad{Gamma(x) * Gamma(y)/Gamma(x+y)}. - doubleFloatFormat : String -> String - ++ change the output format for doublefloats using lisp format strings rationalApproximation: (%, NonNegativeInteger) -> Fraction Integer ++ rationalApproximation(f, n) computes a rational approximation ++ r to f with relative error \spad{< 10**(-n)}. @@ -420,16 +278,10 @@ DoubleFloat(): Join(FloatingPointSystem, DifferentialRing, OpenMath, ++ (that is, \spad{|(r-f)/f| < b**(-n)}). == add - format: String := "~G" MER ==> Record(MANTISSA:Integer,EXPONENT:Integer) manexp: % -> MER - doubleFloatFormat(s:String): String == - ss: String := format - format := s - ss - OMwrite(x: %): String == s: String := "" sp := OM_-STRINGTOSTRINGPTR(s)$Lisp @@ -487,8 +339,7 @@ DoubleFloat(): Join(FloatingPointSystem, DifferentialRing, OpenMath, -- rational approximation to e accurate to 23 digits exp1() == FLOAT(534625820200,_$DoubleFloatMaximum$Lisp)$Lisp / FLOAT(196677847971,_$DoubleFloatMaximum$Lisp)$Lisp pi() == PI$Lisp - coerce(x:%):OutputForm == - outputForm(FORMAT(NIL$Lisp,format,x)$Lisp pretend DoubleFloat) + coerce(x:%):OutputForm == outputForm x convert(x:%):InputForm == convert(x pretend DoubleFloat)$InputForm x < y == (x<y)$Lisp - x == (-x)$Lisp |