feat: #startfloat and Format floatprecision syntax

- #StartFloat <precision>(b/d), MZV = <weight>, with precision either in bits (b) or digits (d).
- Format floatprecision <precision>(b/d).

fix: PrintFloat
- PrintFloat returns correct number of characters and proper Mathematica format
- Trailing zeroes in floats are also removed when precision set by Format floatprecision is less then precision of #startfloat.

test: updated and expanded float tests for new syntax

doc: updated manual for #StartFloat syntax and added entries/documentation for #startfloat, #endfloat, evaluate, tofloat, torational and format floatprecision.

Author: cbmarini

check/features.frm

@@ -3926,7 +3926,7 @@ assert succeeded?
 assert result("F") =~ expr("0")
 *--#] Issue642 :
 *--#[ Issue646 :
-#StartFloat 30
+#StartFloat 9d
 Local F = mzv_+euler_+mzvhalf_;
 Evaluate;
 Print;
@@ -3937,14 +3937,14 @@ assert result("F") =~ expr("mzv_ + euler_ + mzvhalf_")
 *--#] Issue646 :
 *--#[ Issue664 :
 #-
-#StartFloat 64
+#StartFloat 64b
 Evaluate 1;
 .end
 #pend_if wordsize == 2
 assert compile_error?("should be a built in function that can be evaluated numerically.")
 *--#] Issue664 :
 *--#[ Issue695_1 :
-#StartFloat 20
+#StartFloat 20b
 CFunction f;
 Local F1 = f(1.0)+f(1.0);
 Local F2 = f(1.0)/3+f(1.0)*2.0;
@@ -3962,7 +3962,7 @@ assert result("F4") =~ expr("f(1.0e+00) + f(1.1e+00)")
 assert result("F5") =~ expr("f(1/2) + f(5.0e-01)")
 *--#] Issue695_1 :
 *--#[ Issue695_2 :
-#StartFloat 30
+#StartFloat 9d
 Symbol a,b;
 CFunction f;
 Local F = 1.0*f(a);

check/fixes.frm

@@ -3,7 +3,7 @@ \chapter{Floating point}
 \label{floatingpoint}
 
 Starting with version 5.0 \FORM\ is equiped with arbitrary floating point 
-capacity. The low level routines are part of the GMP and mpfr libraries 
+capability. The low level routines are part of the GMP and mpfr libraries 
 which should be available on most systems. If not they can be picked up 
 easily from the internet. The main commands involving the floating point 
 system are
@@ -12,11 +12,13 @@ \chapter{Floating point}
 point system. Invoking it will allocate a number of arrays. The instruction 
 has either one or two arguments:
 \begin{verbatim}
-    #startfloat numberofbits <,maximumweight>
+    #startfloat <precision> [,MZV=<maximumweight>]
 \end{verbatim}
-The first argument is mandatory. It tells how many bits of accuracy are 
-required. \FORM{} will round to at least this precision. Because the internal 
-routines work with WORDs the precision will be rounded up to the nearest 
+The first argument is mandatory and specifies the desired precision. It must 
+be a positive integer followed by either \texttt{b} (for precision in bits) 
+or \texttt{d} (for precision in decimal digits).
+\FORM{} will round to at least this precision. Because the internal 
+routines work with WORDs, the precision (in bits) will internally be rounded up to the nearest 
 integer number of WORDs. The second argument is optional for when one wants 
 to work with multiple zeta values (MZVs) or Euler sums. It specifies the 
 maximum weight that will be used. The evaluation of the sums requires a 
@@ -49,6 +51,27 @@ \chapter{Floating point}
 arguments are the functions mzv\_, euler\_, sqrt\_ and mzvhalf\_. If any 
 (or more than one) of these are specified only those functions will be 
 evaluated.
+\item[Format floatprecision] This instruction controls how many digits are 
+displayed when printing floating point numbers. It only affects output 
+formatting and does not influence the internal precision or accuracy of 
+computations. It can be used in three ways: in case of 
+\begin{verbatim}
+    Format floatprecision;
+\end{verbatim}
+\FORM{} prints floats with the number of digits specified by the current 
+\#startfloat instruction. With
+\begin{verbatim}
+    Format floatprecision <precision>;
+\end{verbatim}
+\FORM{} prints the number of digits specified by \texttt{<precision>}. 
+The syntax is the same as for the precision in \#startfloat: a positive 
+integer followed by either \texttt{b} (for bits) or \texttt{d} (for decimal 
+digits). If the requested precision exceeds the precision specified by 
+\#startfloat, only the available digits are printed. Finally, with 
+\begin{verbatim}
+    Format floatprecision off;
+\end{verbatim}
+the floating point numbers are printed in raw internal format. 
 \end{description}
 In addition to the above commands there are the following functions that 
 can be evaluated sqrt\_, ln\_, li2\_, gamma\_, agm\_, sin\_, cos\_, tan\_,
@@ -65,7 +88,7 @@ \chapter{Floating point}
 
 The following example shows some work with Multiple Zeta Values (MZV's):
 \begin{verbatim}
-    #StartFloat 500,15
+    #StartFloat 500b, MZV=15
     L F1 =
     	-mzv_(8,1,1,5)
     	+29056868/39414375*mzv_(2)^6*mzv_(3)

doc/manual/float.tex

@@ -935,6 +935,18 @@ \section{\#enddo}
 do\index{do loop} loop. See the \#do\index{\#do} instruction.
 
 %--#] enddo : 
+%--#[ endfloat :
+
+\section{\#endfloat}
+\label{preendfloat}
+
+\noindent Syntax:
+
+\#endfloat
+
+\noindent See also startfloat (\ref{prestartfloat}) and chapter~\ref{floatingpoint} on the floating point capability.
+ 
+%--#] endfloat : 
 %--#[ endif :
 
 \section{\#endif}
@@ -1960,6 +1972,18 @@ \section{\#sortreallocate}
 \FORM's memory usage as measured by ``resident set size''.
 
 %--#] sortreallocate : 
+%--#[ startfloat :
+
+\section{\#startfloat}
+\label{prestartfloat}
+
+\noindent Syntax:
+
+\#startfloat $<$precision$>$ [,MZV=$<$weight$>$]
+
+\noindent See also endfloat (\ref{preendfloat}) and chapter~\ref{floatingpoint} on the floating point capability.
+ 
+%--#]  startfloat : 
 %--#[ switch :
 
 \section{\#switch}

doc/manual/prepro.tex

@@ -1478,6 +1478,18 @@ \section{endwhile}
 module. \vspace{10mm}
 
 %--#] endwhile : 
+%--#[ evaluate :
+\section{evaluate}
+\label{substaevaluate}
+
+\noindent \begin{tabular}{ll}
+Type & Executable statement\\
+Syntax & evaluate [$<$function name$>$]; \\ 
+\end{tabular} \vspace{4mm}
+
+\noindent See chapter~\ref{floatingpoint} on the floating point capability.
+ 
+%--#] evaluate : 
 %--#[ exit :
 
 \section{exit}
@@ -1902,6 +1914,9 @@ \section{format}
 \rightvitem{13cm}{Output format is switched back to rational numbers (in 
 contrast to floating point output). This is the default.}
 
+\leftvitem{3.5cm}{floatprecision\index{floatprecision}\index{format!floatprecision} \hfill \\ \null{\tt[}$<$off$>\!|\!<$number$>${\tt]}}
+\rightvitem{13cm}{See chapter~\ref{floatingpoint} on the floating point capability.}
+
 \leftvitem{3.5cm}{nospaces\index{nospaces}\index{format!nospaces}}
 \rightvitem{13cm}{The output is printed without the spaces that make the 
 output slightly more readable. This gives a more compact output.}
@@ -5876,6 +5891,18 @@ \section{threadbucketsize}
 `ON,setup;' statement (\ref{substaon} and \ref{setup}). \vspace{10mm}
 
 %--#] threadbucketsize : 
+%--#[ tofloat :
+\section{tofloat}
+\label{substatofloat}
+
+\noindent \begin{tabular}{ll}
+Type & Executable statement\\
+Syntax & tofloat;
+\end{tabular} \vspace{4mm}
+
+\noindent See chapter~\ref{floatingpoint} on the floating point capability.
+ 
+%--#] tofloat : 
 %--#[ topolynomial :
 
 \section{topolynomial}
@@ -5909,6 +5936,18 @@ \section{topolynomial}
 \vspace{10mm}
 
 %--#] topolynomial : 
+%--#[ torational :
+\section{torational}
+\label{substatorational}
+
+\noindent \begin{tabular}{ll}
+Type & Executable statement\\
+Syntax & torational;
+\end{tabular} \vspace{4mm}
+
+\noindent See chapter~\ref{floatingpoint} on the floating point capability.
+ 
+%--#] torational : 
 %--#[ tospectator :
 
 \section{tospectator}

doc/manual/statements.tex

@@ -41,6 +41,7 @@
 #include "comtool.h"
 #ifdef WITHFLOAT
 #include <gmp.h>
+#include <math.h>
 #endif
 
 static KEYWORD formatoptions[] = {
@@ -394,6 +395,13 @@ int CoFormat(UBYTE *s)
 					while ( *s <= '9' && *s >= '0' )
 						AO.FloatPrec = 10*AO.FloatPrec + (*s++ - '0');
 					while ( *s == ' ' || *s == '\t' || *s == ',' ) s++;
+/*
+					The precision can either be in digits or bits. 
+					AO.FloatPrec is in digits. 
+*/
+					if ( tolower(*s) == 'd' ) { s++; }
+					else if ( tolower(*s) == 'b' ) { AO.FloatPrec = AO.FloatPrec*log10(2.0); s++; }
+					else { s = ss; goto WrongOption; }
 					if ( *s ) { s = ss; goto WrongOption; }
 				}
 				else {

sources/compcomm.c

@@ -934,12 +934,13 @@ int SetFloatPrecision(WORD prec)
 	regular Form function and it should never come here because the
 	print routines in sch.c should intercept it.
 	The buffer AO.floatspace is allocated when the precision of the
-	floats is set in the routine SetupMZVTables.
+	floats is set in the routine SetFloatPrecision.
 */
 
 int PrintFloat(WORD *fun,int numdigits)
 {
 	GETIDENTITY
+	UBYTE *s1, *s2;
 	int n = 0;
 	int prec = (AC.DefaultPrecision-AC.MaxWeight-1)*log10(2.0);
 	if ( numdigits > prec || numdigits == 0 ) {
@@ -951,8 +952,7 @@ int PrintFloat(WORD *fun,int numdigits)
 */
 	if ( UnpackFloat(aux4,fun) == 0 )
 		n = gmp_snprintf((char *)(AO.floatspace),AO.floatsize,"%.*Fe",numdigits-1,aux4);
-	if ( numdigits == prec ) {
-		UBYTE *s1, *s2;
+	if ( n > 0 ) {
 		int n1, n2 = n;
 		s1 = AO.floatspace+n;
 		while ( s1 > AO.floatspace && s1[-1] != 'e'
@@ -962,10 +962,28 @@ int PrintFloat(WORD *fun,int numdigits)
 			s2 = s1; n1 = n2;
 			while ( s1[-1] == '0' ) { s1--; n1--; }
 			if ( s1[-1] == '.' ) { s1++; n1++; }
-			while ( n2 < n ) { *s1++ = *s2++; n2++; }
 			n -= (n2-n1);
+			while ( n1 < n ) { *s1++ = *s2++; n1++; }
 			*s1 = 0;
 		}
+		if ( AC.OutputMode == FORTRANMODE ) {
+			s1 = AO.floatspace+n;
+			while ( s1 > AO.floatspace && *s1 != 'e' && *s1 != 'E' ) { 
+				s1--; 
+			}
+			if ( ( AO.DoubleFlag & 2 ) == 2 ) { *s1 = 'Q'; } /* Quadruple precision fortran */
+			else if ( ( AO.DoubleFlag & 1 ) == 1 ) { *s1 = 'D'; } /* Double precision fortran */
+			else { *s1 = 'E'; } /* Single precision fortran */
+		}
+		if ( AC.OutputMode == MATHEMATICAMODE ) {
+			s1 = AO.floatspace+n;
+			s2 = s1+2; *s2-- = 0;
+			while ( s1 > AO.floatspace && *s1 != 'e' && *s1 != 'E' ) { 
+				*s2-- = *s1--; 
+			}
+			*s2-- = '^'; *s2 = '*'; /* Replace 'e' by '^*' */
+			n++;
+		}
 	}
 	return(n);
 }

sources/float.c

@@ -32,6 +32,9 @@
   	#[ Includes :
 */
 #include "form3.h"
+#ifdef WITHFLOAT
+#include "math.h"
+#endif
 
 static UBYTE pushbackchar = 0;
 static int oldmode = 0;
@@ -7680,6 +7683,7 @@ int DoStartFloat(UBYTE *s)
 	GETIDENTITY
 	int error = 0;
 	LONG x;
+	UBYTE *ss;
 	if ( AP.PreSwitchModes[AP.PreSwitchLevel] != EXECUTINGPRESWITCH ) return(0);
 	if ( AP.PreIfStack[AP.PreIfLevel] != EXECUTINGIF ) return(0);
 	if ( AR.PolyFun != 0 ) {
@@ -7691,20 +7695,42 @@ int DoStartFloat(UBYTE *s)
 		error = 1;
 	}
 	while ( *s == ',' || *s == ' ' || *s == '\t' ) s++;
+/*
+	The first parameter is the float precision
+*/
+	ss = s;
 	if ( *s >= '0' && *s <= '9' ) {
 		x = 0;
 		do {
 			x = 10*x + (*s++-'0');
 		} while ( *s >= '0' && *s <= '9' );
-		AC.tDefaultPrecision = x;
+/*
+		The precision can either be in digits or bits. 
+		AC.DefaultPrecision is always in bits. 
+*/
+		if ( tolower(*s) == 'd' ) { AC.tDefaultPrecision = (LONG)ceil(x*log2(10.0)); s++; }
+		else if ( tolower(*s) == 'b' ) { AC.tDefaultPrecision = x; s++; }
+		else goto IllPar;
 		while ( *s == ',' || *s == ' ' || *s == '\t' ) s++;
-		if ( *s >= '0' && *s <= '9' ) {
-			x = 0;
-			do {
-				x = 10*x + (*s++ - '0');
-			} while ( *s >= '0' && *s <= '9' );
-			AC.tMaxWeight = x;
-			while ( *s == ',' || *s == ' ' || *s == '\t' ) s++;
+/*
+		The second parameter is either absent, which implies zero MZV weight, 
+		or of the form MZV = <weight>
+*/
+		if ( tolower(*s) == 'm' && tolower(s[1]) == 'z' && tolower(s[2]) == 'v') {
+			s+=3;
+			while ( *s == ' ' || *s == '\t' ) s++;
+			if ( *s != '=') goto IllPar;
+			s++;
+			while ( *s == ' ' || *s == '\t' ) s++;
+			if ( *s >= '0' && *s <= '9' ) {
+				x = 0;
+				do {
+					x = 10*x + (*s++ - '0');
+				} while ( *s >= '0' && *s <= '9' );
+				AC.tMaxWeight = x;
+				while ( *s == ',' || *s == ' ' || *s == '\t' ) s++;
+			}
+			else goto IllPar;
 		}
 		else {
 			AC.tMaxWeight = 0;
@@ -7713,7 +7739,7 @@ int DoStartFloat(UBYTE *s)
 	}
 	else if ( *s != 0 ) {
 IllPar:
-		MesPrint("@Illegal parameter in %#StartFloat instruction: %s ",s);
+		MesPrint("@Illegal parameter in %#StartFloat: %s ",ss);
 		error = 1;
 	}
 	if ( error == 0 ) {

sources/pre.c

@@ -2019,6 +2019,9 @@ int WriteInnerTerm(WORD *term, WORD first)
 			if ( *ss == FLOATFUN ) {
 				if ( ( FloatChars = PrintFloat(ss,AO.FloatPrec) ) != 0 ) {
 					TokenToLine(AO.floatspace);
+					if ( AC.IsFortran90 == ISFORTRAN90 && AC.Fortran90Kind ) { 
+						AddToLine(AC.Fortran90Kind);
+					}
 					first = 0;
 				}
 				break;