Express a number in decimal as a fixed-length string with leading zeros.
For example, the number 7.125 could be expressed as 00007.125.
print(‘#05.3’.format(7.125))
00007.125
ThePrintString andPrintChar routines was omitted to keep this short. They handle the printing of null-terminated strings.
As an added bonus, this program supports trailing zeroes, but since the example didn't have any it won't get run.
.modelsmall.stack1024.data;data segment is unused in this program.codestart:movax,@codemovds,axmoves,axcld;make lodsb, etc. auto-incrementmoval,byteptr[ds:LeadingZeroes]movcl,almovch,0moval,'0';30hjcxzDonePrintingLeadingZeroes;there are leading zeroes so we won't skip that section. This branch is not taken.printLeadingZeroes:callPrintChar;print ascii 0 to the terminal 4 timesloopprintLeadingZeroesDonePrintingLeadingZeroes:movsi,offsetTestStringcallPrintStringmoval,byteptr[ds:TrailingZeroes]movcl,almovch,0moval,'0';30hjcxzDonePrintingTrailingZeroes;there are none in this example so this branch is always takenprintTrailingZeroes:callPrintCharloopprintTrailingZeroesDonePrintingTrailingZeroes:movax,4C00hint21h;exit to DOSTestStringbyte"7.125",0LeadingZeroesbyte4;number of leading zeroes to printTrailingZeroesbyte0;number of trailing zeroes to print
C:\>prog.exe00007.125C:\>_
7.125"%09.3f"s:strfmt.cr
00007.125
/* ARM assembly AARCH64 Raspberry PI 3B *//* program formatNum64.s *//* use C library printf ha, ha, ha !!! *//*******************************************//* Constantes file *//*******************************************//* for this file see task include a file in language AArch64 assembly*/.include "../includeConstantesARM64.inc"/*******************************************//* Initialized data *//*******************************************/.dataszFormat1: .asciz " %09.3f\n".align 4sfNumber: .double 0f-7125E-3sfNumber1: .double 0f7125E-3/*******************************************//* UnInitialized data *//*******************************************/.bss .align 4/*******************************************//* code section *//*******************************************/.text.global main main: // entry of program ldr x0,qAdrszFormat1 // format ldr x1,qAdrsfNumber // float number address ldr d0,[x1] // load float number in d0 bl printf // call C function !!! ldr x0,qAdrszFormat1 ldr x1,qAdrsfNumber1 ldr d0,[x1] bl printf 100: // standard end of the program mov x0,0 // return code mov x8,EXIT // request to exit program svc 0 // perform the system call qAdrszFormat1: .quad szFormat1qAdrsfNumber: .quad sfNumberqAdrsfNumber1: .quad sfNumber1
-0007.125 00007.125
withAda.Text_Io.Editing;useAda.Text_Io.Editing;withAda.Text_Io;useAda.Text_Io;procedureZero_FillisPic_String:String:="<999999.99>";Pic:Picture:=To_Picture(Pic_String);typeMoneyisdelta0.01digits8;packageMoney_Outputis newDecimal_Output(Money);useMoney_Output;Value:Money:=37.25;beginPut(Item=>Value,Pic=>Pic);endZero_Fill;
000037.25
o_form("/w9s0/\n", 7.125);o_form("/w12d6p6/\n", -12.0625);o_form("/w12d6p6/\n", 7.125);00007.125 -12.0625 7.125
Should work with any ALGOL 68 implementation that implements formatted transput.
Note that when using real patterns, if exponent frames are used, the exponent pattern must specify enough digits for the exponent and if it is negative the exponent pattern must have a sign.
#main:# ( REAL r=exp(pi)-pi; print((r,newline)); printf(($g(-16,4)l$,-r)); printf(($g(-16,4)l$,r)); printf(($g( 16,4)l$,r)); printf(($g( 16,4,1)l$,r)); printf(($-dddd.ddddl$,-r)); printf(($-dddd.ddddl$,r)); printf(($+dddd.ddddl$,r)); printf(($ddddd.ddddl$,r)); printf(($zzzzd.ddddl$,r)); printf(($zzzz-dd.ddddl$,-r)); printf(($zzzz-dd.dddde-ddl$,-r)); printf(($zz-d.dddde+ddl$,-r)); printf(($4z-d.4de+4dl$,r)))
+1.99990999791895e +1 -19.9991 19.9991 +19.9991+19999099.979e-6-0019.9991 0019.9991+0019.999100019.9991 19.9991 -19.9991-199990.9998e-04-199.9910e-01 19999.1000e-0003
For implementations of Algol 68 that don't have formatted transput, the output from the previous sample can be reproduced using thefixed andfloat standard prelude routines.
For the cases where leading zeros are required or partial suppression of leading zeros is wanted, some procedures or operators could be defined to modify the output fromfixed andfloat - possible suitable operators are implemented here.
( OP UNSUPPRESS = ( STRING v )STRING: # replace leading spaces with zeros # IF LWB v > UPB v THEN v # empty string # ELSE STRING result := v; INT p1 := LWB result; IF result[ p1 ] = " " THEN result[ p1 ] := "0" FI; FOR p FROM LWB result + 1 TO UPB result DO CHAR c = result[ p ]; IF c = " " THEN result[ p ] := "0" ELIF c = "-" OR c = "+" THEN result[ p ] := "0"; result[ p1 ] := c ELIF c = "e" THEN p1 := p + 1 FI OD; result FI # UNSUPPRESS # ; OP SUPPRESSPLUS = ( STRING v )STRING: # replace leading space/zero with "+" # IF LWB v > UPB v THEN v ELIF CHAR c = v[ LWB v ]; c = "+" OR c = "0" THEN " " + v[ LWB v + 1 : ] ELSE v FI; PRIO SUPPRESS = 5; # suppress up to d leading zeros # OP SUPPRESS = ( STRING v, INT d )STRING: IF LWB v > UPB v THEN v ELIF CHAR c1 = v[ LWB v ]; c1 /= "+" AND c1 /= "-" AND c1 /= "0" THEN v ELSE INT len = ( UPB v - LWB v ) + 1; INT max p = ( LWB v - 1 ) + IF len > d THEN d ELSE len FI; STRING result := v; CHAR sign char = IF c1 = "0" THEN " " ELSE c1 FI; result[ LWB result ] := " "; BOOL inserted sign := FALSE; FOR p FROM LWB result + 1 TO max p WHILE CHAR c = result[ p ]; IF c /= "0" THEN result[ p - 1 ] := sign char; inserted sign := TRUE FI; NOT inserted sign DO result[ p ] := " " OD; IF NOT inserted sign THEN result[ max p ] := sign char FI; result FI # SUPPRESS # ; REAL r=exp(pi)-pi; print((r,newline)); print((fixed(-r,16,4),newline)); print((fixed(r,-16,4),newline)); print((fixed(r,16,4),newline)); print((float(r,16,4,1),newline)); print((SUPPRESSPLUS UNSUPPRESS fixed(-r,-10,4),newline)); print((SUPPRESSPLUS UNSUPPRESS fixed(r,-10,4),newline)); print((UNSUPPRESS fixed(r,10,4),newline)); print((UNSUPPRESS fixed(ABS r,-10,4),newline)); print((fixed(ABS r,-10,4),newline)); print((SUPPRESSPLUS UNSUPPRESS fixed(-r,12,4) SUPPRESS 5,newline)); print((SUPPRESSPLUS UNSUPPRESS float(-r,16,4,-3) SUPPRESS 5,newline)); print((SUPPRESSPLUS UNSUPPRESS float(-r,-13,4,3),newline)); print((SUPPRESSPLUS UNSUPPRESS float(r,-17,4,5),newline)))
Same as the first sample.
#include<basico.h>#proto padzeros(_X_,_S_,_D_)#proto padmoney(_N_,_D_,_F_,_S_,_P_)algoritmon={},'125,12.39802,0.0003221,-0.0045,457897.789'enlistaren'n'fijarseparador'NL'imprimir("Express a number in decimal as a fixed-length string with leading zeros:\n\n",\#(pad zeros(n,19,5)), "\n\n",\ #(pad zeros(n,19,0)), "\n\n",\ #(pad zeros( (-9873000155.584),19,1)), "\n\n",\ "Bonus track:\n\n",\ #(lpad( " ",20,string(n))), "\n\n",\ #(lpad( " ",20,notation(n))),"\n\n",\ #(pad money(n,1,".",19,"$")),"\n\n",\ #(pad money(1980.67,1,"_",16,"USD$"),NL))terminarsubrutinaspadzeros(n,l,d)decimales'd's=0,sgn=0#( s = string( n * sgn:=(sign(n)) ) )#( sgn = string(sgn) )si(s,esmatriz?)mapear(#(sgn=="-1"),"-",sgn)mapear(#(sgn=="1")," ",sgn)sino#(sgn=="-1"), entonces{ "-",mover a 'sgn' }#(sgn=="1"), entonces{ " ",mover a 'sgn' }finsi#(cat( sgn, lpad( "0",l,s)))decimalesnormalesretornarpadmoney(num,dec,fill,size,prefix)#(cat(prefix,lpad(fill,size,money(dec,num))))retornar
Express a number in decimal as a fixed-length string with leading zeros: 0000000000125.00000 0000000000012.39802 0000000000000.00032-0000000000000.00450 0000000457897.78900 0000000000000000125 0000000000000000012 0000000000000000000-0000000000000000000 0000000000000457898-00000009873000155.6Bonus track: 125 12.398020 0.000322 -0.004500 457897.789000 1.250000e+02 1.239802e+01 3.221000e-04 -4.500000e-03 4.578978e+05$..............125.0$...............12.4$................0.0$...............-0.0$..........457,897.8USD$_________1,980.7
The function RealF can be used to convert a floating point value into a string, with a specified number of decimal digits. But to fit the string into a greater container prepending 0 we must write our own function. (The one here proposed has no a flag for the alignment of the result inside the containing string)
PROC newRealF(es, fl, digit, len=0, zeros=TRUE) DEF s, t, i IF (len = 0) OR (len < (digit+3)) RETURN RealF(es, fl, digit) ELSE s := String(len) t := RealF(es, fl, digit) FOR i := 0 TO len-EstrLen(t)-1 DO StrAdd(s, IF zeros THEN '0' ELSE ' ') StrAdd(s, t) StrCopy(es, s) DisposeLink(s) DisposeLink(t) ENDIFENDPROC esPROC main() DEF s[100] : STRING WriteF('\s\n', newRealF(s, 7.125, 3,9))ENDPROC'ZF15.9'⎕FMT7.12500007.125000000
APL's⎕FMT is similar to C'sprintf (only it operates on arrays).
onfixedlength(x,max)ifx<0thensetprefto"-"setxto-xelsesetprefto""endifsetstoxastextsetminto(lengthofs)+(lengthofpref)repeatmax-mintimessetsto"0"&sendrepeatreturnpref&sendfixedlengthrepeatwithxin{7.125,-7.125,77.125,777.125}logfixedlength(x,9)endrepeat
(*00007.125*)(*-0007.125*)(*00077.125*)(*00777.125*)
/* ARM assembly Raspberry PI *//* program formatNum.s *//* use C library printf ha, ha, ha !!! *//* Constantes */.equ EXIT, 1 @ Linux syscall/* Initialized data */.dataszFormat1: .asciz " %09.3f\n".align 4sfNumber: .double 0f-7125E-3sfNumber1: .double 0f7125E-3/* UnInitialized data */.bss .align 4/* code section */.text.global main main: @ entry of program push {fp,lr} @ saves registers ldr r0,iAdrszFormat1 @ format ldr r1,iAdrsfNumber @ number address ldr r2,[r1] @ load first 4 bytes ldr r3,[r1,#4] @ load last 4 bytes bl printf @ call C function !!! ldr r0,iAdrszFormat1 ldr r1,iAdrsfNumber1 ldr r2,[r1] ldr r3,[r1,#4] bl printf100: @ standard end of the program mov r0, #0 @ return code pop {fp,lr} @restaur registers mov r7, #EXIT @ request to exit program swi 0 @ perform the system calliAdrszFormat1: .int szFormat1iAdrsfNumber: .int sfNumberiAdrsfNumber1: .int sfNumber1r:7.125printrprintto:string.format:"09.3f"r
7.12500007.125
contributed by Laszlo on the ahkforum
MsgBox%pad(7.25,7) ; 0007.25MsgBox%pad(-7.25,7) ; -007.25pad(x,len){ ; pad with 0's from left to len charsIfLessx,0,Return"-"pad(SubStr(x,2),len-1)VarSetCapacity(p,len,Asc("0"))ReturnSubStr(px,1-len)}
BEGIN{r=7.125printf" %9.3f\n",-rprintf" %9.3f\n",rprintf" %-9.3f\n",rprintf" %09.3f\n",-rprintf" %09.3f\n",rprintf" %-09.3f\n",r}
Same output as the C code.
0P=5:T=3:R=7.125:GOSUB100"FORMATTEDNUMERICOUTPUT9ENDREM FORMATTED NUMERIC OUTPUTREM Given R a Real numberREM and P as left Padding amount, P$ as the PaddingREM and T as the Trailing amount, T$ as the Trailing padding100R$=STR$(R):L=LEN(R$):S$="":IFMID$(R$,1,1)=" "THENS$=" ":L=L-1:R$=RIGHT$(R$,L)110IFMID$(R$,1,1)="-"THENL=L-1:R$=RIGHT$(R$,L):S$=S$+"-":REMSIGN120LETD$="":D=0:E$="":E=0:REMDECIMAL,EXPONENTandPOSITIONS130IFP$=""THENP$="0":REMLEFTPADDING140IFT$=""THENT$="0":REMTRAILINGPADDING150FORI=1TOL160LETC$=MID$(R$,I,1)170IFC$="."THEND=I180IFC$="E"THENE=I190NEXTI200IFETHENE$=MID$(R$,E):R$=LEFT$(R$,E-1)210IFDTHEND$=MID$(R$,D+1):R$=LEFT$(R$,D-1)220LETPAD$="":FORI=1TOP:PAD$=P$+PAD$:NEXT230PRINTS$RIGHT$(PAD$+R$,P);240LETPAD$="":FORI=1TOT:PAD$=PAD$+T$:NEXT250IFTTHENPRINT"."LEFT$(D$+PAD$,T);260PRINTE$;270RETURN
00007.125
100REM Formatted numeric output110LETN=7.125120PRINTUSING("%%%%.###"):N130PRINTUSING("****.###"):N140PRINTUSING("####.###"):N150PRINTUSING("+%%%.###"):N160PRINTUSING("+%%%.###"):-N170PRINTUSING(".###^^^^^"):N180PRINTUSING("#.###^^^^^"):N190PRINTUSING("##.###^^^^^"):N200PRINTUSING("+.###^^^^^"):-N210END
0007.125***7.125 7.125+007.125-007.125.713E+0017.125E+00071.250E-001-.713E+001
BaCon can use C styleprintf format specifiers.
' Formatted numeric outputn=7.125PRINTnFORMAT"%09.3f\n"
prompt$ ./formatted00007.125
PRINTFNformat(PI,9,3)PRINTFNformat(-PI,9,3)ENDDEFFNformat(n,sl%,dp%)LOCAL@%@%=&1020000ORdp%<<8IFn>=0THEN=RIGHT$(STRING$(sl%,"0")+STR$(n),sl%)ENDIF="-"+RIGHT$(STRING$(sl%,"0")+STR$(-n),sl%-1)
00003.142-0003.142
n=7.125printrjust(string(n),8,"0")#=>00007.125printzfill(string(n),8)#=>00007.125
This example isin need of improvement:
|
10printusing"0000#.###";7.125
00007.125
' FB 1.05.0 Win64#Include"vbcompat.bi"DimsAsString=Format(7.125,"00000.0##")PrintsSleep
00007.125
100 LET F=7.125110 PRINT USING "-%%%%%.###":F
Custom function builds on the supplied 'print using( "###.###", n)'.
NB no check that this does not truncate high-order digits... and remember LB calculates with more figures than its normal 'print' displays.
for i = 1 to 10 n = rnd(1) * 10 ^ (int(10 * rnd(1)) - 2) print "Raw number = "; n, "Using custom function = "; FormattedPrint$(n, 16, 5)next iendfunction FormattedPrint$(n, length, decPlaces) format$ = "#." for i = 1 to decPlaces format$ = format$ + "#" next i n$ = using(format$, n) ' remove leading spaces if less than 3 figs left of decimal ' add leading zeros for i = 1 to len(n$) c$ = mid$(n$, i, 1) if c$ = " " or c$ = "%" then nn$ = nn$ + "0" else nn$ = nn$ + c$ next i FormattedPrint$ = right$( "000000000000" +nn$, length) ' chop to required lengthend function
Raw number = 0.92349667e-2 Using custom function = 0000000000.00923Raw number = 0.45244905 Using custom function = 0000000000.45245Raw number = 3084321.68 Using custom function = 0003084321.68220Raw number = 545.557351 Using custom function = 0000000545.55735Raw number = 765.455263 Using custom function = 0000000765.45526Raw number = 650413.092 Using custom function = 0000650413.09248Raw number = 0.85554345 Using custom function = 0000000000.85554Raw number = 296.155771 Using custom function = 0000000296.15577Raw number = 8.3816344 Using custom function = 0000000008.38163Raw number = 0.1007265e-2 Using custom function = 0000000000.00101
10REM Formatted numeric output20CLS30LETN=7.12540LETW=950GOSUB100060SCREEN10,9:PRINTN$70END1000REM Formatted fixed-length1010N$=STR$(N):N$=RIGHT$(N$,LEN(N$)-1)1020FORI=1TOW-LEN(N$)1030N$="0"+N$1040NEXTI1050RETURN
Using RSet() to pad 7.125 with 3 decimals converted to a string, to 8 char length.
RSet(StrF(7.125,3),8,"0");Willbe0007.125
n=7.125PRINTUSING("0000#.###");n' => 00007.125
print right$("00000";using("#####.##",7.125),8) ' => 00007.13printformat("00000.000",7.125)
This example isin need of improvement:
|
right("00000" & format(7.12511, "f3"), 9)LETn=7.125PRINTUSING("0000#.###"):n!=>0007.125END
OptionExplicitSubMain()Debug.PrintfFormat(13,2,1230.3333)Debug.PrintfFormat(2,13,1230.3333)Debug.PrintfFormat(10,5,0.3333)Debug.PrintfFormat(13,2,1230)EndSubPrivateFunctionfFormat(NbIntAsInteger,NbDecAsInteger,NbAsDouble)AsString'NbInt : Lenght of integral part'NbDec : Lenght of decimal part'Nb : decimal on integer numberDimuAsString,vAsString,iAsIntegeru=CStr(Nb)i=InStr(u,Application.DecimalSeparator)Ifi>0Thenv=Mid(u,i+1)u=Left(u,i-1)fFormat=Right(String(NbInt,"0")&u,NbInt)&Application.DecimalSeparator&Left(v&String(NbDec,"0"),NbDec)ElsefFormat=Right(String(NbInt,"0")&u,NbInt)&Application.DecimalSeparator&String(NbDec,"0")EndIfEndFunction
0000000001230.3330.33330000000000000000000.333300000000001230.00
a=1234.5678' Round to three decimal places. Groups by default. Output = "1,234.568".WScript.EchoFormatNumber(a,3)' Truncate to three decimal places. Output = "1234.567".WScript.EchoLeft(a,InStr(a,".")+3)' Round to a whole number. Grouping disabled. Output = "1235".WScript.EchoFormatNumber(a,0,,,False)' Use integer portion only and pad with zeroes to fill 8 chars. Output = "00001234".WScript.EchoRight("00000000"&Int(a),8)
Debug.PrintFormat$(7.125,"00000.000")
Output (the decimal separator used depends on the system's language settings):
00007.125PROGRAM"progname"VERSION"0.0000"DECLAREFUNCTIONEntry()FUNCTIONEntry()n!=7.125PRINTFORMAT$("0000#.###",n!)ENDFUNCTIONENDPROGRAM
00007.125
n=7.125printnusing("#####.###")//=>7.125printstr$(n,"%09.3f")//=>00007.125
10LETn=7.12520LETwidth=930GOSUB100040PRINTAT10,10;n$50STOP1000REM Formatted fixed-length1010LETn$=STR$n1020FORi=1TOwidth-LENn$1030LETn$="0"+n$1040NEXTi1050RETURN
First define a custom function for numeric output.
/* * Print number n, using at least c characters. * * Different from normal, this function: * 1. Uses the current ibase (not the obase) to print the number. * 2. Prunes "0" digits from the right, so p(1.500, 1) prints "1.5". * 3. Pads "0" digits to the left, so p(-1.5, 6) prints "-001.5". * 4. Never prints a newline. * * Use an assignment, as t = p(1.5, 1), to discard the return value * from this function so that bc not prints the return value. */define p(n, c){auto d, d[], f, f[], i, m, r, s, vs=scale/* Save original scale. */if(n<0){"-"/* Print negative sign. */c-=1n=-n/* Remove negative sign from n. */}/* d[] takes digits before the radix point. */scale=0for(m= n/1; m!=0; m/=10) d[d++]= m%10/* f[] takes digits after the radix point. */r= n-(n/1)/* r is these digits. */scale=scale(n)f=-1/* f counts the digits of r. */for(m= r+1; m!=0; m/=10) f+=1scale=0r= r*(10^ f)/1/* Remove radix point from r. */if(r!=0){while(r%10==0){/* Prune digits. */f-=1r/=10}for(i=0; i< f; i++){f[i]= r%10r/=10}}/* Pad "0" digits to reach c characters. */c-= dif(f>0) c-=1+ ffor(1; c>0; c--)"0"/* Print "0". *//* i = index, m = maximum index, r = digit to print. */m= d+ ffor(i=1; i<= m; i++){if(i<= d) r= d[d- i]if(i> d) r= f[m- i]if(i== d+1)"."/* Print radix point. */v=0if(r== v++)"0"/* Print digit. */if(r== v++)"1"if(r== v++)"2"/* r == 2 might not work, */if(r== v++)"3"/* unless ibase is ten. */if(r== v++)"4"if(r== v++)"5"if(r== v++)"6"if(r== v++)"7"if(r== v++)"8"if(r== v++)"9"if(r== v++)"A"if(r== v++)"B"if(r== v++)"C"if(r== v++)"D"if(r== v++)"E"if(r== v++)"F"}scale= s/* Restore original scale. */}
Then use this function to print 7.125 with 9 characters.
x=7.125"Decimal: "; t= p(x,9);""ibase=16"Hexadecimal: "; t= p(x,9);""ibase=2"Binary: "; t= p(x,1001);""quit
Decimal: 00007.125Hexadecimal: 0000007.2Binary: 00111.001
beads 1 program 'Formatted numeric output'calc main_initvar num = 7.125log to_str(num, min:9, zero_pad:Y)
00007.125
#include<stdio.h>main(){floatr=7.125;printf(" %9.3f\n",-r);printf(" %9.3f\n",r);printf(" %-9.3f\n",r);printf(" %09.3f\n",-r);printf(" %09.3f\n",r);printf(" %-09.3f\n",r);return0;}
-7.125 7.1257.125 -0007.12500007.1257.125
classProgram{staticvoidMain(string[]args){floatmyNumbers=7.125F;stringstrnumber=Convert.ToString(myNumbers);Console.WriteLine(strnumber.PadLeft(9,'0'));Console.ReadLine();}}
#include<iostream>#include<iomanip>intmain(){std::cout<<std::setfill('0')<<std::setw(9)<<std::fixed<<std::setprecision(3)<<7.125<<std::endl;return0;}
C++20
#include<iostream>#include<format>intmain(){std::cout<<std::format("{:09.3f}\n",7.125);return0;}
Using cl format strings
(cl-formattrue"~9,3,,,'0F"7.125)
Using java format strings
(printf"%09.3f"7.125); format works the same way (without side the effect of printing)
This is actually the easiest kind of numeric output to achieve in COBOL, because it requires no adjustments from the way numbers are stored internally (in fixed-point decimal). Each variable declaration requires aPIC orPICTURE clause describing the kind of data that will be stored there. In this case, we have9 (a decimal digit), repeated five times; thenV, the decimal point (cf. Frenchvirgule); and then three more decimal digits. Other terms that can appear inPICTURE clauses includeA (a letter of the alphabet),X (a character), andZ (a decimal digit to be printed with leading spaces instead of leading zeros).
IDENTIFICATIONDIVISION.PROGRAM-ID.NUMERIC-OUTPUT-PROGRAM.DATA DIVISION.WORKING-STORAGESECTION.01 WS-EXAMPLE. 05XPIC 9(5)V9(3).PROCEDUREDIVISION. MOVE7.125TOX. DISPLAYXUPONCONSOLE. STOPRUN.
00007.125
(formatt"~9,3,,,'0F"7.125)
importstd.stdio;voidmain(){immutabler=7.125;writefln(" %9.3f",-r);writefln(" %9.3f",r);writefln(" %-9.3f",r);writefln(" %09.3f",-r);writefln(" %09.3f",r);writefln(" %-09.3f",r);}
-7.125 7.125 7.125 -0007.125 00007.125 7.125
D5=7125 A10=D5,'-ZZZZX.XXX' ; 7.125 A10=D5,'-ZZZZX.XXX' [LEFT] ;7.125 A10=D5,'-XXXXX.XXX' ; 00007.125 A10=-D5,'-ZZZZX.XXX' ;- 7.125 A10=-D5,'-ZZZZX.XXX' [LEFT] ;- 7.125 A10=-D5,'-XXXXX.XXX' [LEFT] ;-00007.125 A10=-D5,'XXXXX.XXX-' ;00007.125- A10=-D5,'ZZZZX.XXX-' ; 7.125- A10=-D5,'ZZZZX.XXX-' [LEFT] ;7.125- A10=1500055,'ZZZ,ZZX.XX ; 15,000.55
First define a custom function for numeric output.
[* * (n) (c) lpx * Print number n, using at least c characters. * * Different from normal, this function: * 1. Uses the current ibase (not the obase) to print the number. * 2. Prunes "0" digits from the right, so [1.500 1 lxp] prints "1.5". * 3. Pads "0" digits to the left, so [_1.5 6 lxp] prints "-001.5". * 4. Never prints a newline. *]sz[ Sc Sn [Local n, c = from stack.]sz K Ss [Local s = original scale.]sz [Reserve local variables D, F, I, L.]sz 0 SD 0 SF 0 SI 0 SL [ [If n < 0:]sz [-]P [Print negative sign.]sz lc 1 - sc [Decrement c.]sz 0 ln - sn [Negate n.]sz ]sI 0 ln <I [* * Array D[] takes digits before the radix point. *]sz 0 k [scale = 0]sz 0 Sd [Local d = 0]sz ln 1 / [Push digits before radix point.]sz [ [Loop to fill D[]:]sz d 10 % ld :D [D[d] = next digit.]sz ld 1 + sd [Increment d.]sz 10 / [Remove digit.]sz d 0 !=L [Loop until no digits.]sz ]sL d 0 !=L sz [Pop digits.]sz [* * Array F[] takes digits after the radix point. *]sz ln ln 1 / - [Push digits after radix point.]sz d X k [scale = enough.]sz _1 Sf [Local f = -1]sz d 1 + [Push 1 + digits after radix point.]sz [ [Loop to count digits:]sz lf 1 + sf [Increment f.]sz 10 / [Remove digit.]sz d 0 !=L [Loop until no digits.]sz ]sL d 0 !=L sz [Pop 1 + digits.]sz 0 k [scale = 0]sz 10 lf ^ * 1 / [Remove radix point from digits.]sz [ [Loop to prune digits:]sz lf 1 - sf [Decrement f.]sz 10 / [Remove digit.]sz d 10 % 0 =L [Loop while last digit is 0.]sz ]sL d 10 % 0 =L 0 Si [Local i = 0]sz [ [Loop to fill F[]:]sz d 10 % li :F [F[i] = next digit.]sz 10 / [Remove digit.]sz li 1 + si [Increment i.]sz lf li <L [Loop while i < f.]sz ]sL lf li <L sz [Pop digits.]sz lc ld - [Push count = c - d.]sz [ [If f > 0:]sz 1 lf + - [Subtract 1 radix point + f from count.]sz ]sI 0 lf >I [ [Loop:]sz [0]P [Print a padding "0".]sz 1 - [Decrement count.]sz d 0 <L [Loop while count > 0.]sz ]sL d 0 <L sz [Pop count.]sz [ [Local function (digit) lPx:]sz [ [Execute:]sz [* * Push the string that matches the digit. *]sz [[0] 2Q]sI d 0 =I [[1] 2Q]sI d 1 =I [[2] 2Q]sI d 2 =I [[3] 2Q]sI d 3 =I [[4] 2Q]sI d 4 =I [[5] 2Q]sI d 5 =I [[6] 2Q]sI d 6 =I [[7] 2Q]sI d 7 =I [[8] 2Q]sI d 8 =I [[9] 2Q]sI d 9 =I [[A] 2Q]sI d A =I [[B] 2Q]sI d B =I [[C] 2Q]sI d C =I [[D] 2Q]sI d D =I [[E] 2Q]sI d E =I [[F] 2Q]sI d F =I [?] [Else push "?".]sz ]x P [Print the string.]sz sz [Pop the digit.]sz ]SP ld [Push counter = d.]sz [ [Loop:]sz 1 - [Decrement counter.]sz d ;D lPx [Print digit D[counter].]sz d 0 <L [Loop while counter > 0.]sz ]sL d 0 <L sz [Pop counter.]sz [ [If f > 0:]sz [.]P [Print radix point.]sz lf [Push counter = f.]sz [ [Loop:]sz 1 - [Decrement counter.]sz d ;F lPx [Print digit F[counter].]sz d 0 <L [Loop while counter > 0.]sz ]sL d 0 <L sz [Pop counter.]sz ]sI 0 lf >I [Restore variables n, c, d, f, D, F, L, I, P.]sz Lnsz Lcsz Ldsz Lfsz LDsz LFsz LLsz LIsz LPsz Ls k [Restore variable s. Restore original scale.]sz]sp
Then use this function to print 7.125 with 9 characters:
7.125 sx[Decimal: ]P lx 9 lpx []P 16 i [Hexadecimal: ]P lx 9 lpx []P 2 i [Binary: ]P lx 9 lpx []P
Decimal: 00007.125Hexadecimal: 0000007.2Binary: 00111.001
programFormattedNumericOutput;{$APPTYPE CONSOLE}usesSysUtils;constfVal=7.125;beginWriteln(FormatFloat('0000#.000',fVal));Writeln(FormatFloat('0000#.0000000',fVal));Writeln(FormatFloat('##.0000000',fVal));Writeln(FormatFloat('0',fVal));Writeln(FormatFloat('#.#E-0',fVal));Writeln(FormatFloat('#,##0.00;;Zero',fVal));Readln;end.
00007.12500007.12500007.125000077.1E07.13
DuckDB supports string formatting using the widespread printf() conventions andalso thefmt mini-language :
SELECTprintf('%09.3f',7.125),format('{:09.3f}',7.125);
┌─────────────────────────┬───────────────────────────┐│ printf('%09.3f', 7.125) │ format('{:09.3f}', 7.125) ││ varchar │ varchar │├─────────────────────────┼───────────────────────────┤│ 00007.125 │ 00007.125 │└─────────────────────────┴───────────────────────────┘Here's a typescript showing how to avoid the tabular decorations:
D .headers offD .mode listD SELECT printf('%09.3f', 7.125);00007.125D SELECT format('{:09.3f}', 7.125);00007.125notedescription:"{2Examplesaregiven.Thefirstexampleusesthestandardlibrary'sFORMAT_DOUBLEclass.ThesecondexampleusestheAEL_PRINTFclassfromthefreelyavailableAmalasoftEiffelLibrary(AEL).Seeadditionalcommentsinthecode.}"classAPPLICATIONinheritAEL_PRINTF-- Optional, see belowcreatemakefeature{NONE}-- Initializationmake-- Run application.doprint_formatted_std(7.125)print_formatted_ael(7.125)end--|--------------------------------------------------------------print_formatted_std(v:REAL_64)-- Print the value 'v' as a zero-padded string in a fixed-- overall width of 9 places and, with a precision of-- to 3 places to the right of the decimal point.-- Use the FORMAT_DOUBLE class from the standard librarylocalfmt:FORMAT_DOUBLEdocreatefmt.make(9,3)fmt.zero_fillprint(fmt.formatted(v)+"%N")end--|--------------------------------------------------------------print_formatted_ael(v:REAL_64)-- Print the value 'v' as a zero-padded string in a fixed-- overall width of 9 places and, with a precision of-- to 3 places to the right of the decimal point.-- Use the AEL_PRINTF class from the Amalasoft Eiffel Library-- freely available from www.amalasoft.comdo-- printf accepts a format string and an argument list-- The argument list is a container (often a manifest-- array) of values corresponding to the type of the format-- specified in the format string argument.-- When only one argument is needed, then there is also the-- option to use just the value, without the container.-- In this example, the line would be:-- printf ("%%09.3f%N", v)-- The more deliberate form is used in the actual example,-- as it is more representative of common usage, when there-- are multiple value arguments.printf("%%09.3f%N",<<v>>)endend
n=7.125:io.fwrite"~f~n",[n]:io.fwrite"~.3f~n",[n]:io.fwrite"~9f~n",[n]:io.fwrite"~9.3f~n",[n]:io.fwrite"~9..0f~n",[n]:io.fwrite"~9.3.0f~n",[n]:io.fwrite"~9.3._f~n",[n]:io.fwrite"~f~n",[-n]:io.fwrite"~9.3f~n",[-n]:io.fwrite"~9.3.0f~n",[-n]:io.fwrite"~e~n",[n]:io.fwrite"~12.4e~n",[n]:io.fwrite"~12.4.0e~n",[n]
7.1250007.125 7.125000 7.12507.12500000007.125____7.125-7.125000 -7.125000-7.1257.12500e+0 7.125e+000007.125e+0
(format"%09.3f"7.125);=> "00007.125"
format is similar to Csprintf. SeeGNU Elisp manual on Formatting Strings.
Built in
14> io:fwrite("~9.3.0f~n", [7.125]).00007.125PROGRAM FORMATTEDPROCEDURE FORMATTED_PRINT(N,LENGTH,DEC_PLACES->FP$) LOCAL I,C$,NN$ FORMAT$=STRING$(LENGTH,"#")+"." FOR I=1 TO DEC_PLACES DO FORMAT$=FORMAT$+"#" END FOR OPEN("O",1,"FORMAT.$$$") WRITE(#1,FORMAT$;N) CLOSE(1) OPEN("I",1,"FORMAT.$$$") INPUT(LINE,#1,N$) CLOSE(1) ! add leading zeros FOR I=1 TO LEN(N$) DO C$=MID$(N$,I,1) IF C$=" " OR C$="%" THEN NN$=NN$+"0" ELSE NN$=NN$+C$ END FOR FP$=RIGHT$("000000000000"+NN$,LENGTH) ! chop to required lengthEND PROCEDUREBEGIN PRINT(CHR$(12);) ! CLS FOR I=1 TO 10 DO N=RND(1)*10^(INT(10*RND(1))-2) FORMATTED_PRINT(N,16,5->FP$) PRINT("Raw number =";N;TAB(30);"Using custom function =";FP$) END FOREND PROGRAMRaw number = 1213.501 Using custom function =0000001213.50100Raw number = 86886.11 Using custom function =0000086886.11000Raw number = 7.98853E-03 Using custom function =0000000000.00799Raw number = 49.03128 Using custom function =0000000049.03128Raw number = 1072496 Using custom function =0001072496.00000Raw number = 703.8703 Using custom function =0000000703.87030Raw number = 9.711614 Using custom function =0000000009.71161Raw number = 9561278 Using custom function =0009561278.00000Raw number = 534.9367 Using custom function =0000000534.93670Raw number = 67121.88 Using custom function =0000067121.88000
constant r = 7.125printf(1,"%9.3f\n",-r)printf(1,"%9.3f\n",r)printf(1,"%-9.3f\n",r)printf(1,"%09.3f\n",-r)printf(1,"%09.3f\n",r)printf(1,"%-09.3f\n",r)
-7.125 7.125 7.125 -0007.125 00007.125 7.125
printfn"%09.3f"7.125f
USE:formatting7.125"%09.3f\n"printf
00007.125
class Main{ public static Void main() { echo (7.125.toStr.padl(9, '0')) }}Forth has a rather rich set of number formatting words, which makes formatted output very flexible but sometime cumbersome.
Here one way to generate the required output. Note that the number generated is NOT truncated to the field width. If you wish to truncate the number, remove #s and 1- from the definition. (The 1- is necessary because #s always generates at least one digit, even if it's zero.)
\ format 'n' digits of the double word 'd':#n( d n -- d )0?do#loop;\ ud.0 prints an unsigned double:ud.0( d n -- )<#1-#n#s#>type;\ d.0 prints a signed double:d.0( d n -- )>rtuckdabs<#r>1-#n#srotsign#>type;
Usage example:
Type:123s>d8ud.0Result:00000123okType:-123s>d8d.0Result:-00000123ok
Forth's number formatting words are different than many other languages because they are active code rather than using a pattern string. This small set of seven routines ( >DIGIT <# #> # #S HOLD SIGN ) allow arbitrary number formatting of double precision and single precision numbers. The number is created in a "hold' buffer the output is typically a Forth style stack-string consisting of an address and a length.
Typical of Forth the using the formatting routines means putting things in reverse order.We are also free to create a mnemonic name that gives a reminder at how numbers will appear.
To replicate the example for this task we could write:
: '.' [CHAR] . HOLD ; \ HOLD inserts a character into the number string\ right side . left side : 0000#.### ( d -- addr len) DABS <# # # # '.' # # # # # #> ;
At the console we can input a double number, execute the format routine and type the resulting string.
7.125 0000#.### TYPE 000007.125 ok
Using standard data edit descriptors it is only possible to precede Integer data with leading zeros.
INTEGER::number=7125WRITE(*,"(I8.8)")number! Prints 00007125
One can engage in trickery via FORMAT statements, in particular the T format option. Unlike actual tab settings which on a typewriter go to a particular column following, Tn means go to columnn.
INTEGERIVREALVDATAV/7.125/!A positive number.IV=V!Grab the integer part.WRITE(6,1)V,IV1FORMAT(F9.3,T1,I5.5)END
Output is
00007.125
This would need adjustment for other sizes, but works as follows: The value part is printed (in the format system's working area) as "bbbb7.125" (b's standing for spaces), then the T1 moves the finger back to column one, and the I5.5 writes out "00007", the .5 addendum to I5 meaning print leading zeroes rather than leading spaces. It does not overwrite the subsequent ".125", and as no further output items appear the deed is done. Only later Fortran offers the addendum feature, but the Tab feature is much older.
Another approach would be to write forth a literal "0000" instead of the integer, but this is less flexible. In the absence of the .5 addendum, write the output to a character string (or equivalent), replace leading spaces by zeroes (watching out for negative numbers), and print the result.
SeePascal
Fōrmulæ programs are not textual, visualization/edition of programs is done showing/manipulating structures but not text. Moreover, there can be multiple visual representations of the same program. Even though it is possible to have textual representation —i.e. XML, JSON— they are intended for storage and transfer purposes more than visualization and edition.
Programs in Fōrmulæ are created/edited online in itswebsite.
Inthis page you can see and run the program(s) related to this task and their results. You can also change either the programs or the parameters they are called with, for experimentation, but remember that these programs were created with the main purpose of showing a clear solution of the task, and they generally lack any kind of validation.
window 1, @"Formatted Numeric Output", (0,0,480,270)// option 1print using "0000#.###";7.125// option 2printf @"%09.3f",7.125
Click this link to run this code
PublicSubMain()PrintFormat("7.125","00000.000")End
Output:
00007.125
printsprintf("%09.3f",7.125)
fmt.Printf("%09.3f",7.125)
Solution:
printf("%09.3f",7.125)
00007.125
importText.Printfmain=printf"%09.3f"7.125
fun format n length let n tostr n while len n < length let n 0 + n endwhile println nendfunformat 7.125 9
WRITE(ClipBoard, Format='i5.5, F4.3') INT(7.125), MOD(7.125, 1) ! 00007.125
concept FixedLengthFormat(value, length) {string = text(abs(value))prefix = ""sign = ""if value < 0sign = "-"endif #string < lengthprefix = "0"*(length-#sign-#string-#prefix)endreturn sign+prefix+string}software {d = 7.125print(FixedLengthFormat(d, 9))print(FixedLengthFormat(-d, 9))}linkprintfproceduremain()everyr:=&pi|-r|100-rdo{write(r," <=== no printf")everyp:="|%r|"|"|%9.3r|"|"|%-9.3r|"|"|%0.3r|"|"|%e|"|"|%d|"dowrite(sprintf(p,r)," <=== sprintf ",p)}end
Abbreviated
3.141592653589793 <=== no printf|3.141593| <=== sprintf |%r|| 3.142| <=== sprintf |%9.3r||3.142 | <=== sprintf |%-9.3r||3.142| <=== sprintf |%0.3r|| 3.141593e0| <=== sprintf |%e||3| <=== sprintf |%d|
providesprintf
n=7.125print,n,format='(f08.3)';==> 0007.125
'r<0>9.3'(8!:2)7.12500007.125
Stealing printf from C/C++:
publicclassPrinting{publicstaticvoidmain(String[]args){doublevalue=7.125;System.out.printf("%09.3f",value);// System.out.format works the same waySystem.out.println(String.format("%09.3f",value));}}
000000007.125000000007.125
UsingNumberFormat:
importjava.text.DecimalFormat;importjava.text.NumberFormat;publicclassFormat{publicstaticvoidmain(String[]args){NumberFormatnumForm=newDecimalFormat();numForm.setMinimumIntegerDigits(9);//Maximum also available for Integer digits and Fraction digitsnumForm.setGroupingUsed(false);//stops it from inserting commasSystem.out.println(numForm.format(7.125));//example of Fraction digit optionsnumForm.setMinimumIntegerDigits(5);numForm.setMinimumFractionDigits(5);System.out.println(numForm.format(7.125));numForm.setMinimumFractionDigits(0);numForm.setMaximumFractionDigits(2);System.out.println(numForm.format(7.125));System.out.println(numForm.format(7.135));//rounds to even}}
000000007.12500007.1250000007.1200007.14
functionfmt(n,options){const[whole,fraction]=String(n).split('.',2)return[whole.padStart(options.whole||1,'0'),(fraction??'').padEnd(options.fraction,'0').slice(0,options.fraction),].filter(Boolean).join('.')}for(const[n,options]of[[123,{whole:1,fraction:2}],// 123.00[123,{whole:5,fraction:2}],// 00123.00[123,{whole:5,fraction:0}],// 00123[0.5,{whole:1,fraction:2}],// 0.50[0.5,{whole:5,fraction:2}],// 00000.50[0.5,{whole:5,fraction:0}],// 00000]){console.log(fmt(n,options))}
Also, a 60-line implementation ofsprintf can be foundhere.
The jq function pp0/1 as defined below is written in accordance with the taskrequirements, but no truncation occurs; pp/1 is similar butis likely to be more useful as the decimal point is aligned if possible.
def pp0(width): tostring | if width > length then (width - length) * "0" + . else . end;# pp(left; right) formats a decimal number to occupy# (left+right+1) positions if possible,# where "left" is the number of characters to the left of# the decimal point, and similarly for "right".def pp(left; right): def lpad: if (left > length) then ((left - length) * "0") + . else . end; tostring as $s | $s | index(".") as $ix | ((if $ix then $s[0:$ix] else $s end) | lpad) + "." + (if $ix then $s[$ix+1:] | .[0:right] else "" end);Examples:
(1.0, 12.3, 333.333, 1e6) | pp0(10)
produces
000000000100000012.3000333.3330001000000
(1.0, 12.3, 333.333, 1e6) | pp(4;2)
produces
0001.0012.30333.331000000.
Julia's@sprintf macro provides string formatting that is similar to that of the c function of the same name. Though easy to use and efficient,@sprintf has limited flexibility, as its format specification must be a string literal, precluding its use in dynamic formatting. Greater flexibility is available via theFormatting package, which provides an implementation of Python's format specification mini-language. This solution demonstrates both of these techniques to provide the leading zero padded floating point format suggested in the task description ("%09.3f").
usingPrintftest=[7.125,[rand()*10^rand(0:4)foriin1:9]]println("Formatting some numbers with the @sprintf macro (using\"%09.3f\"):")foriintestprintln(@sprintf"%09.3f"i)endusingFormattingprintln()println("The same thing using the Formatting package:")fe=FormatExpr(" {1:09.3f}")foriintestprintfmtln(fe,i)end
Formatting some numbers with the @sprintf macro (using "%09.3f"): 00007.125 00001.734 00903.432 00000.980 00002.271 00559.864 00105.497 00069.955 00046.107 04970.430The same thing using the Formatting package: 00007.125 00001.734 00903.432 00000.980 00002.271 00559.864 00105.497 00069.955 00046.107 04970.430
// version 1.0.5-2funmain(args:Array<String>){valnum=7.125println("%09.3f".format(num))}
00007.125
Lambdatalk has no primitive for numeric output. This is a way to define it:
{deffmt{defpadd{lambda{:n:x}{if{<:n1}thenelse:x{padd{-:n1}:x}}}}{deftrunc{lambda{:n}{if{>:n0}then{floor:n}else{ceil:n}}}}{lambda{:a:b:n}{let{{:a:a}{:b:b}{:n{abs:n}}{:sign{if{>=:n0}then+else-}}{:int{trunc:n}}{:dec{ceil{*1.0e:b{abs{-:n{trunc:n}}}}}}}{br}{padd{-:a{W.length{trunc:n}}}>}{if{W.equal?:sign-}thenelse:sign}:int.:dec{padd{-:b{W.length:dec}}0}}}}->fmt{defnumbers7.12510.70.980-1000559.8-69.994970.430}->numbers{S.map{fmt103}{numbers}}->>>>>>>>>>+7.125>>>>>>>>+10.699>>>>>>>>>+0.980>>>>>>-1000.000>>>>>>>+559.799>>>>>>>>-69.990>>>>>>+4970.430
7.125->asstring(-precision=3,-padding=9,-padchar='0')
00007.125
Various collection functions, such as MAP and FILTER, will work on individual characters of a string when given a word instead of a list.
to zpad :num :width :precision output map [ifelse ? = "| | ["0] [?]] form :num :width :precisionendprint zpad 7.125 9 3 ; 00007.125
As a debugging feature, you can drop down toC language printf formatting by giving -1 for the width and a format string for the precision.
print form 7.125 -1 "|%09.3f| ; 00007.125
functiondigits(n)returnmath.floor(math.log(n)/math.log(10))+1endfunctionfixedprint(num,digs)--digs = number of digits before decimal pointfori=1,digs-digits(num)doio.write"0"endprint(num)endfixedprint(7.125,5)--> 00007.125
An easier way to do that would be
print(string.format("%09.3d",7.125))
Locale1032Printstr$(7.125,"00000.000")="00007,125"' Αληθές//multiplecolumnprintPrint$("00000.000"),7.125,100,200.567Print$("")Locale1033Printstr$(7.125,"00000.000")="00007.125"' True//multiplecolumnprintPrint$("00000.000"),7.125,100,200.567Print$("")
printf("%f",Pi);3.141593printf("%.0f",Pi);3printf("%.2f",Pi);3.14printf("%08.2f",Pi);00003.14printf("%8.2f",Pi);3.14printf("%-8.2f|",Pi);3.14|printf("%+08.2f",Pi);+0003.14printf("%+0*.*f",8,2,Pi);+0003.14
StringTake["000000"<>ToString[7.125],-9]00007.125
>>disp(sprintf('%09.3f',7.125))00007.125
printf(false,"~9,3,,,'0F",7.125);
"00007.125"
:- module formatted_numeric_output.:- interface.:- import_module io.:- pred main(io::di, io::uo) is det.:- implementation.:- import_module list, string.main(!IO) :- io.format("%09.3f\n", [f(7.125)], !IO).(pick length - repeat prefix) ^left-pad7.125 string "0" 9 left-pad puts!
00007.125
ModulesIO andFmt must be imported before use.
IO.Put(Fmt.Pad("7.125\n",length:=10,padChar:='0'));
printer = 7.125println format("%09.3f", printer)00007.125
/* NetRexx */optionsreplaceformatcommentsjavacrossrefsavelogsymbolsbinaryimportjava.text.MessageFormatsevenPointOneTwoFive=double7.125--usingNetRexxBuilt-InFunctions(BIFs)sayRexx(sevenPointOneTwoFive).format(5,3).changestr(' ','0')--usingJavalibraryconstructsSystem.out.printf('%09.3f\n',[Double(sevenPointOneTwoFive)])sayMessageFormat.format('{0,number,#00000.###}',[Double(sevenPointOneTwoFive)])return
00007.12500007.12500007.125
importstrformatconstr=7.125echorechofmt"{-r:9.3f}"echofmt"{r:9.3f}"echofmt"{-r:09.3f}"echofmt"{r:09.3f}"
7.125 -7.125 7.125-0007.12500007.125
ModuleOut must be imported before use.
Out.Real(7.125,9,0);
NSLog(@"%09.3f",7.125);
or
NSLog(@"%@",[NSStringstringWithFormat:@"%09.3f",7.125]);
Printf.printf"%09.3f\n"7.125
MESSAGE STRING( 7.125, "99999.999" )VIEW-AS ALERT-BOX.
It is possible to set the precision used for float printing (where "precision" means the total number of digits used).
It doesn't seem to be possible to use leading zeros for printing, so we implement this manually:
declare fun {PrintFloat X Prec} {Property.put 'print.floatPrecision' Prec} S = {Float.toString X} in {Append for I in 1..Prec-{Length S}+1 collect:C do {C &0} end S} endin {System.showInfo {PrintFloat 7.125 8}}printf("%09.4f\n", Pi)procedurewriteInFixedFormat(n:real);constwholeNumberPlaces=5;fractionalPlaces=3;zeroDigit='0';negative='-';varsignPresent:boolean;i:integer;begin// NOTE: This does not catch “negative” zero.signPresent:=n<0.0;ifsignPresentthenbeginwrite(negative);n:=abs(n);end;// determine number of leading zerosi:=wholeNumberPlaces;ifn>0thenbegini:=i-trunc(ln(n)/ln(10));end;fori:=i-1downtosucc(ord(signPresent))dobeginwrite(zeroDigit);end;// writes n with// - at least 0 characters in total// - exactly fractionalPlaces post-radix digits// roundedwrite(n:0:fractionalPlaces);end;
##varPi:=3.1415926536;Println($'{Pi,8:f2}');Println($'{Pi,-8:f3}!');
3.143.142 !
printf"%09.3f\n",7.125;
printf(1,"%09.3f\n",7.125)00007.125
echostr_pad(7.125,9,'0',STR_PAD_LEFT);
or
printf("%09.3f\n",7.125);
(pad 9 (format 7125 3))(pad 9 (format 7125 3 ",")) # European format
put edit (X) (p'999999.V999'); /* Western format. */put edit (X) (p'999999,V999'); /* In European format. */
lz: Proc Options(main); /********************************************************************* * 10.09.2013 Walter Pachl one way to treat negative numbers * another would be using a Picture of 'S(9)9.V(3)9' or '-(9)9.V(3)9' *********************************************************************/ Call z2lz(1.2); Call z2lz(-1.32); Call z2lz(123456789.012); Call z2lz(-23456789.012); Call z2lz(-123456789.012); z2lz: Proc(z); Dcl z Dec Fixed(15,3); ; Dcl s Char(13) Based(addr(p)); Dcl p Pic'(9)9.V(3)9'; p=z; If z<0 Then If left(s,1)='0' Then substr(s,1,1)='-'; Else Do; Put Skip List(z,'can''t be formatted that way'); Return; End; Put Skip List(z,s); End; End;
1.200 000000001.200 -1.320 -00000001.320 123456789.012 123456789.012 -23456789.012 -23456789.012 -123456789.012 can't be formatted that way
print(string.format("%09.3f",7.125))
00007.125
The task is underspecified, so we present a few alternatives.
;;; field of length 12, 3 digits after decimal placeformat_print('~12,3,0,`*,`0F', [1299.19]);;;; prints "00001299.190"format_print('~12,3,0,`*,`0F', [100000000000000000]);;;; Since the number does not fit into the field prints "************";;; that is stars instead of the numberformat_print('~12,3,0,`*,`0F', [-1299.19]);;;; prints "000-1299.190";;; that is _leading zeros_ before signformat_print('~3,1,12,`0:$', [1299.19]);;;; prints "00001299.190"format_print('~3,1,12,`0:$', [-1299.19]);;;; prints "-0001299.190";;; that is sign before leading zerosformat_print('~3,1,12,`0:$', [100000000000000000]);;;; prints "100000000000000000.000";;; that is uses more space if the number does not fit into;;; fixed widthUsing the-f formatting operator and a custom format string:
'{0:00000.000}'-f7.125
or by invokingToString on the number:
7.125.ToString('00000.000')
Python has 3 different floating point formatting methods: "%e","%f" & "%g". The "%g" format is a beautified hybrid of "%e" and "%f". There is no way of specifying how many digits appear in the exponent when printed with a format.
frommathimportpi,expr=exp(pi)-piprintrprint"e=%e f=%f g=%g G=%G s=%s r=%r!"%(r,r,r,r,r,r)print"e=%9.4e f=%9.4f g=%9.4g!"%(-r,-r,-r)print"e=%9.4e f=%9.4f g=%9.4g!"%(r,r,r)print"e=%-9.4e f=%-9.4f g=%-9.4g!"%(r,r,r)print"e=%09.4e f=%09.4f g=%09.4g!"%(-r,-r,-r)print"e=%09.4e f=%09.4f g=%09.4g!"%(r,r,r)print"e=%-09.4e f=%-09.4f g=%-09.4g!"%(r,r,r)
19.9990999792e=1.999910e+01 f=19.999100 g=19.9991 G=19.9991 s=19.9990999792 r=19.999099979189474!e=-1.9999e+01 f= -19.9991 g= -20!e=1.9999e+01 f= 19.9991 g= 20!e=1.9999e+01 f=19.9991 g=20 !e=-1.9999e+01 f=-019.9991 g=-00000020!e=1.9999e+01 f=0019.9991 g=000000020!e=1.9999e+01 f=19.9991 g=20 !
frommathimportpi,expr=exp(pi)-piprint(r)print("e={0:e} f={0:f} g={0:g} G={0:G} s={0!s} r={0!r}!".format(r))print("e={0:9.4e} f={0:9.4f} g={0:9.4g}!".format(-r))print("e={0:9.4e} f={0:9.4f} g={0:9.4g}!".format(r))print("e={0:-9.4e} f={0:-9.4f} g={0:-9.4g}!".format(r))print("e={0:09.4e} f={0:09.4f} g={0:09.4g}!".format(-r))print("e={0:09.4e} f={0:09.4f} g={0:09.4g}!".format(r))print("e={0:-09.4e} f={0:-09.4f} g={0:-09.4g}!".format(r))
19.9990999792e=1.999910e+01 f=19.999100 g=19.9991 G=19.9991 s=19.9990999792 r=19.999099979189474!e=-1.9999e+01 f= -19.9991 g= -20!e=1.9999e+01 f= 19.9991 g= 20!e=1.9999e+01 f=19.9991 g=20 !e=-1.9999e+01 f=-019.9991 g=-00000020!e=1.9999e+01 f=0019.9991 g=000000020!e=1.9999e+01 f=19.9991 g=20 !
Behaviour offormat ( $ a b --> $ )
Accepts a well formatted numerical string$, optionally with a decimal point, without validation.
a is the number of digits before the decimal point.b is the number of digits after the decimal point.
Returns a string$ with either a leading zero or a leading space, thenat leasta digits, then a decimal point, thenat leastb digits. The digits are padded with zeroes fore and aft if required.
"at least" – if there are already more digits before the point thana, and/or more digits after the point thanb, it willnot crop the number. IMO, it is better to mess up the formatting than to display an incorrect number. Check the $ is not too long fore or aft before passing toformat if the string may be truncated.
[ over find swap found ] is has ( $ c --> b ) [ over 0 peek char - = iff [ dip [ behead drop ] true unrot ] else [ false unrot ] over char . swap find - char 0 swap of swap join swap iff char - else space swap join ] is left-pad ( $ n --> $ ) [ over char . has not if [ dip [ char . join ] ] over char . swap find dip [ over size ] 1+ - - char 0 swap of join ] is right-pad ( $ n --> $ ) [ dip left-pad right-pad ] is format ( $ n n --> $ ) ' [ $ "7.125" $ "-7.125" $ "0.125" $ "-0.12" $ "7.12" $ "-7.12" $ "0.12" $ "-0.12" $ "7" $ "-7" $ "0" ] witheach [ do 5 3 format echo$ cr ]
00007.125-00007.125 00000.125-00000.120 00007.120-00007.120 00000.120-00000.120 00007.000-00007.000 00000.000
sprintf brings the printf goodness one expects:
>sprintf("%f",pi)[1]"3.141593">sprintf("%.3f",pi)[1]"3.142">sprintf("%1.0f",pi)[1]"3">sprintf("%5.1f",pi)[1]" 3.1">sprintf("%05.1f",pi)[1]"003.1">sprintf("%+f",pi)[1]"+3.141593">sprintf("% f",pi)[1]" 3.141593">sprintf("%-10f",pi)# left justified[1]"3.141593 ">sprintf("%e",pi)[1]"3.141593e+00">sprintf("%E",pi)[1]"3.141593E+00">sprintf("%g",pi)[1]"3.14159">sprintf("%g",1e6*pi)# -> exponential[1]"3.14159e+06">sprintf("%.9g",1e6*pi)# -> "fixed"[1]"3141592.65">sprintf("%G",1e-6*pi)[1]"3.14159E-06"
formatC also provides C-style string formatting.
formatC(x,width=9,flag="0")# "00007.125"
Other string formatting functions include
format, prettynum
->(displayln(~a7.125#:width9#:align'right#:pad-string"0"))00007.125
(formerly Perl 6)
say7.125.fmt('%09.3f');
7.125 "%09.3f" print00007.125
define PI -1 acos PI exp PI - as r r print "\n" printr "" prefer "s=%s!\n" printr dup dup dup dup "e=%e f=%f g=%g G=%G!\n" print-1 r * dup dup "e=%9.4e f=%9.4f g=%9.4g!\n" printr dup dup "e=%9.4e f=%9.4f g=%9.4g!\n" printr dup dup "e=%-9.4e f=%-9.4f g=%-9.4g!\n" printr -1 * dup dup "e=%09.4e f=%09.4f g=%09.4g!\n" printr dup dup "e=%09.4e f=%09.4f g=%09.4g!\n" printr dup dup "e=%-09.4e f=%-09.4f g=%-09.4g!\n" print
19.9991s=19.999100!e=1.999910e+01 f=19.999100 g=19.9991 G=19.9991!e=-1.9999e+01 f= -19.9991 g= -20!e=1.9999e+01 f= 19.9991 g= 20!e=1.9999e+01 f=19.9991 g=20 !e=-1.9999e+01 f=-019.9991 g=-00000020!e=1.9999e+01 f=0019.9991 g=000000020!e=1.9999e+01 f=19.9991 g=20 !
Rebol[Title:"Formatted Numeric Output"URL:http://rosettacode.org/wiki/Formatted_Numeric_Output]; Rebol has no built-in facilities for printing pictured output.; However, it's not too hard to cook something up using the; string manipulation facilities.zeropad:func["Pad number with zeros or spaces. Works on entire number."pad"Number of characters to pad to."n"Number to pad."/space"Pad with spaces instead."/localnncs][n:to-stringnc:" "s:""ifnotspace[c:"0"if#"-"=n/1[pad:pad-1n:copyskipn1s:"-"]]insert/dupnc(pad-length? n)insertnsn]; These tests replicate the C example output.print[zeropad/space9negate7.125]print[zeropad/space97.125]print7.125print[zeropad9negate7.125]print[zeropad97.125]print7.125
-7.125 7.1257.125-0007.12500007.1257.125
/*REXX program shows various ways to add leading zeroes to numbers. */a=7.125b=translate(format(a,10),0,' ')say'a='asay'b='bsayc=8.37d=right(c,20,0)say'c='csay'd='dsaye=19.46f='000000'esay'e='esay'f='fsayg=18.25e+1h=000000||gsay'g='gsay'h='hsayi=45.2j=translate(' 'i,0," ")say'i='isay'j='jsayk=36.007l=insert(00000000,k,0)say'k='ksay'l='lsaym=.10055n=copies(0,20)msay'm='msay'n='nsayp=4.060q=0000000000000||psay'p='psay'q='qsayr=876s=substr(r+10000000,2)say'r='rsay's='ssayt=13.02u=reverse(reverse(t)000000000)say't='tsay'u='u/*stick a fork in it, we're done.*/
a= 7.125b= 0000000007.125c= 8.37d= 00000000000000008.37e= 19.46f= 00000019.46g= 18.25E+1h= 00000018.25E+1i= 45.2j= 00000045.2k= 36.007l= 0000000036.007m= .10055n= 00000000000000000000.10055p= 4.060q= 00000000000004.060r= 876s= 0000876t= 13.02u= 00000000013.02
decimals(3)see fixedprint(7.125, 5) + nlfunc fixedprint num, digs for i = 1 to digs - len(string(floor(num))) see "0" next see num + nl
Number formatting in RPL is at 1980s standards (ANSI BASIC X3J2, 1983 to be precise). If the user wants something else, she/he has to write some code, formatting the number as a string.
≪ 1 CFIF OVER 0 <THEN 1 SF 1 -END SWAP ABS →STRWHILE DUP2 SIZE >REPEAT "0" SWAP +ENDIF 1 FS?THEN "-" SWAP +END SWAP DROP≫ 'TASK' STO
7.125 9 TASK-7.125 9 TASK
2: "00007.125"1: "-0007.125"
r = 7.125printf " %9.3f\n", r #=> 7.125printf " %09.3f\n", r #=> 00007.125printf " %09.3f\n", -r #=> -0007.125printf " %+09.3f\n", r #=> +0007.125puts " %9.3f" % r #=> 7.125puts " %09.3f" % r #=> 00007.125puts " %09.3f" % -r #=> -0007.125puts " %+09.3f" % r #=> +0007.125
fn main() { let x = 7.125; println!("{:9}", x); println!("{:09}", x); println!("{:9}", -x); println!("{:09}", -x);}7.12500007.125 -7.125-0007.125
The Fill options should fill with any character, but it is still (!) not implemented; according toICSI Sather library documentation (GNU Sather library documentation is missing) works only for string, bools and characters, but a test has revealed it does not work in either way (yet) (GNU Sather v1.2.3).
class MAIN is main is #OUT + #FMT("<F0 #####.###>", 7.1257) + "\n"; #OUT + #FMT("<F0 #####.###>", 7.1254) + "\n"; end;end;Luckly the C-like formats are supported too:
#OUT + #FMT("%09.3f", 7.125) + "\n";As shown in aScala Worksheet:
object FormattedNumeric { val r = 7.125 //> r : Double = 7.125 println(f" ${-r}%9.3f"); //> -7,125 println(f" $r%9.3f"); //> 7,125 println(f" $r%-9.3f"); //> 7,125 println(f" ${-r}%09.3f"); //> -0007,125 println(f" $r%09.3f"); //> 00007,125 println(f" $r%-9.3f"); //> 7,125 println(f" $r%+09.3f"); //> +0007,125}Obtain the implementation of SRFI 54 fromhttp://srfi.schemers.org/srfi-54/srfi-54.htmland save it as "srfi-54.scm" in directoryGauche/share/gauche/site/lib/
(load "srfi-54.scm")(load "srfi-54.scm") ;; Don't ask.(define x 295643087.65432)(dotimes (i 4) (print (cat x 25 3.0 #\0 (list #\, (- 4 i)))))
00000000002,9564,3087.6540000000000295,643,087.65400000002,95,64,30,87.65,4002,9,5,6,4,3,0,8,7.6,5,4
$ include "seed7_05.s7i"; include "float.s7i";const proc: main is func local const float: r is 7.125; begin writeln( r digits 3 lpad 9); writeln(-r digits 3 lpad 9); writeln( r digits 3 lpad0 9); writeln(-r digits 3 lpad0 9); writeln( r digits 3); writeln(-r digits 3); end func;
7.125 -7.12500007.125-0007.1257.125-7.125
printf("%09.3f\n", 7.125);or
say ("%09.3f" % 7.125);00007.125
Transcript show: (7.125 printPaddedWith: $0 to: 3.6); cr."output: 007.125000"
(7.123 asFixedPoint:3) printOn: Transcript leftPaddedTo: 9 with: $0 "output: 00007.125"
notice that printOn:* is implemented in Object;thus any object can be printed with padding this way.
Using the PrintfScanf utility:
PrintfScanf new printf:'%08.3f' arguments: { 7.125 }declare @n intselect @n=123select substring(convert(char(5), 10000+@n),2,4) as FourDigitsset @n=5print "TwoDigits: " + substring(convert(char(3), 100+@n),2,2)--Output: 05
print (StringCvt.padLeft #"0" 9 (Real.fmt (StringCvt.FIX (SOME 3)) 7.125) ^ "\n")
print (Format.format "%09.3f\n" [Format.REAL 7.125])
Seeformat in Stata help.
. display %010.3f (57/8)000007.125
Print(7.125.Pad(9))
00007.125
print format '%09.3f;' 7.125 print pad left 7.125 to 9 by '0'
set number 7.342format "%08.3f" $number
0007.432
Use withputs if output is desired to go to a channel.
needs valuesvalue n123 to n2 import printf" %08d" n printf
The library function printf calls the host system's Clibrary function by that name and can cope with any ofthe same numeric formats.
#import flox = 7.125#show+t = <printf/'%09.3f' x>
00007.125
void main() { double r = 7.125; print(" %9.3f\n", -r); print(" %9.3f\n",r); print(" %-9.3f\n",r); print(" %09.3f\n",-r); print(" %09.3f\n",r); print(" %-09.3f\n",r);}-7.125 7.125 7.125 -0007.125 00007.125 7.125
Vedit only supports integers, but fixed point calculations can be used for decimal values.
The following example uses 3 decimal places (value scaled by 1000). The output is inserted at current edit position.
#1 = 7125Num_Ins(#1, FILL+COUNT, 9) Char(-3) Ins_Char('.')00007.125
fn main() {// refer to string interpolation and format place holding in documentation// pad with zeros towards the leftnum := 7.125println("${num:09f}")}00007.125
import "./fmt" for Fmtvar n = 7.125System.print(Fmt.rjust(9, n, "0"))
00007.125
int C;[Format(5, 3); \5 places before decimal point and 3 afterRlOut(8, 7.125); \output real number to internal bufferloop [C:= ChIn(8); \read character from internal buffer if C = ^ then C:= ^0; \change leading space characters to zeros if C = $1A then quit; \exit loop on end-of-file (EOF = end of chars) ChOut(0, C); \display digit character on terminal ];]
00007.125
<xsl:value-of select="format-number(7.125, '00000000.#############')" />
"%09.3f".fmt(7.125) //-->"00007.125""%09.3e".fmt(7.125) //-->"7.125e+00""%09.3g".fmt(7.125) //-->"000007.12""%09d".fmt(7.125) //-->"000000007""%09,d".fmt(78901.125)//-->"00078,901"