Formatted numeric output
From Rosetta Code
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".
[edit] Ada
with Ada.Text_Io.Editing; use Ada.Text_Io.Editing;
with Ada.Text_Io; use Ada.Text_Io;
procedure Zero_Fill is
Pic_String: String := "<999999.99>";
Pic : Picture := To_Picture(Pic_String);
type Money is delta 0.01 digits 8;
package Money_Output is new Decimal_Output(Money);
use Money_Output;
Value : Money := 37.25;
begin
Put(Item => Value, Pic => Pic);
end Zero_Fill;
The output of this program is
000037.25
[edit] ALGOL 68
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-d.ddddl$,r));
printf(($zzzz-d.ddddedl$,r));
printf(($zzzz-d.ddddeddl$,r));
printf(($4z-d.4de4dl$,r))
)
Output:
+1.99990999791895e +1
-19.9991
19.9991
+19.9991
+19999099.979e-6
-0019.9991
0019.9991
+0019.9991
00019.9991
00019.9991
19.9991
1.9999e1
1.9999e01
1.9999e0001
[edit] AmigaE
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)
ENDIF
ENDPROC es
PROC main()
DEF s[100] : STRING
WriteF('\s\n', newRealF(s, 7.125, 3,9))
ENDPROC
[edit] APL
'ZF15.9' ⎕FMT 7.125
00007.125000000
APL's ⎕FMT is similar to C's printf (only it operates on arrays).
[edit] AWK
BEGIN {
r=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
}
Same output as the C code.
[edit] AutoHotkey
contributed by Laszlo on the ahk forum
MsgBox % pad(7.25,7) ; 0007.25
MsgBox % pad(-7.25,7) ; -007.25
pad(x,len) { ; pad with 0's from left to len chars
IfLess x,0, Return "-" pad(SubStr(x,2),len-1)
VarSetCapacity(p,len,Asc("0"))
Return SubStr(p x,1-len)
}
[edit] C#
class Program
{
static void Main(string[] args)
{
float myNumbers = 7.125F;
string strnumber = Convert.ToString(myNumbers);
Console.WriteLine(strnumber.PadLeft(9, '0'));
Console.ReadLine();
}
}
[edit] C
#include <stdio.h>
main(){
float r=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);
return 0;
}
Output:
-7.125
7.125
7.125
-0007.125
00007.125
7.125
[edit] C++
#include <iostream>
#include <iomanip>
int main()
{
std::cout << std::setfill('0') << std::setw(9) << std::fixed << std::setprecision(3) << 7.125 << std::endl;
return 0;
}
[edit] Clojure
Translation of: Common Lisp Using cl format strings
(cl-format true "~9,3,,,'0F" 7.125)
Translation of: java Using java format strings
(printf "%09.3f" 7.125) ; format works the same way (without side the effect of printing)
[edit] Common Lisp
(format t "~9,3,,,'0F" 7.125)
[edit] Forth
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 -- ) >r tuck dabs <# r> 1- #n #s rot sign #> type ;
Usage example:
Type: 123 s>d 8 ud.0
Result: 00000123 ok
Type: -123 s>d 8 d.0
Result: -00000123 ok
[edit] Fortran
Works with: Fortran version 90 and later Using standard data edit descriptors it is only possible to precede Integer data with leading zeros.
INTEGER :: number = 7125
WRITE(*,"(I8.8)") number ! Prints 00007125
[edit] gnuplot
print sprintf("%09.3f", 7.125)
[edit] Haskell
import Text.Printf
main =
printf "%09.3f" 7.125
[edit] IDL
n = 7.125
print, n, format='(f08.3)'
;==> 0007.125
[edit] J
'r<0>9.3' (8!:2) 7.125
00007.125
[edit] Java
Works with: Java version 1.5+ Stealing printf from C/C++:
public class Printing{
public static void main(String[] args){
double printer = 7.125;
System.out.printf("%09.3f",printer);//System.out.format works the same way
}
}
[edit] JavaScript
var n = 123;
var str = ("00000" + n).slice(-5);
alert(str);
or, put in browser URL: javascript:n=123;alert(("00000"+n).slice(-5));
Also, a 60-line implementation of sprintf can be found here.
[edit] Logo
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 :precision
end
print zpad 7.125 9 3 ; 00007.125
Works with: UCB Logo As a debugging feature, you can drop down to C 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
[edit] Lua
function digits(n) return math.floor(math.log(n) / math.log(10))+1 end
function fixedprint(num, digs) --digs = number of digits before decimal point
for i = 1, digs - digits(num) do
io.write"0"
end
print(num)
end
fixedprint(7.125, 5) --> 00007.125
[edit] Modula-3
Modules IO and Fmt must be imported before use.
IO.Put(Fmt.Pad("7.125\n", length := 10, padChar := '0'));
[edit] Oberon-2
Module Out must be imported before use.
Out.Real(7.125, 9, 0);
[edit] Objective-C
NSLog(@"%09.3f", 7.125);
or
NSLog(@"%@", [NSString stringWithFormat:@"%09.3f", 7.125]);
[edit] OCaml
Printf.printf "%09.3f\n" 7.125
[edit] Oz
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}
end
in
{System.showInfo {PrintFloat 7.125 8}}
[edit] Perl
Works with: Perl version 5.x
printf " %09.3f\n", 7.125;
[edit] PHP
echo str_pad(7.125, 9, '0', STR_PAD_LEFT);
or
printf("%09.3f\n", 7.125);
[edit] PicoLisp
(pad 9 (format 7125 3))
(pad 9 (format 7125 3 ",")) # European format
[edit] PL/I
put edit (X) (p'999999.V999'); /* Western format. */
put edit (X) (p'999999,V999'); /* In European format. */
[edit] Pop11
The task is underspecified, so we present a few alternatives.
;;; field of length 12, 3 digits after decimal place
format_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 number
format_print('~12,3,0,`*,`0F', [-1299.19]);
;;; prints "000-1299.190"
;;; that is _leading zeros_ before sign
format_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 zeros
format_print('~3,1,12,`0:$', [100000000000000000]);
;;; prints "100000000000000000.000"
;;; that is uses more space if the number does not fit into
;;; fixed width
[edit] PowerShell
Using the -f formatting operator and a custom format string:
"{0,9:00000.000}" -f 7.125
[edit] Python
Works with: Python version 2.5 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.
from math import pi, exp
r = exp(pi)-pi
print r
print "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.9990999792 e=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 !
Works with: Python version 3
from math import pi, exp
r = exp(pi)-pi
print(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.9990999792 e=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 !
[edit] R
formatC provides C-style string formatting.
formatC(x, width=9, flag="0")
# "00007.125"
Other string formatting functions include
format, prettynum
[edit] REBOL
rebol [
Title: "Formatted Numeric Output"
Author: oofoe
Date: 2009-12-22
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."
/local nn c s
][
n: to-string n c: " " s: ""
if not space [
c: "0"
if #"-" = n/1 [pad: pad - 1 n: copy skip n 1 s: "-"]
]
insert/dup n c (pad - length? n)
insert n s
n
]
; These tests replicate the C example output.
print [zeropad/space 9 negate 7.125]
print [zeropad/space 9 7.125]
print 7.125
print [zeropad 9 negate 7.125]
print [zeropad 9 7.125]
print 7.125
Output:
-7.125
7.125
7.125
-0007.125
00007.125
7.125
[edit] Raven
7.125 "%09.3f" print
00007.125
[edit] Ruby
printf " %09.3f\n", 7.125
[edit] SQL
Works with: MS SQL version 2005
declare @n int
SELECT @n=123
SELECT substring(convert(char(5), 10000+@n),2,4) AS FourDigits
SET @n=5
print "TwoDigits: " + substring(convert(char(3), 100+@n),2,2)
--Output: 05
[edit] Standard ML
print (StringCvt.padLeft #"0" 9 (Real.fmt (StringCvt.FIX (SOME 3)) 7.125) ^ "\n")
[edit] Suneido
Print(7.125.Pad(9))
Output:
00007.125
[edit] Tcl
set number 7.342
format "%08.3f" $number
Use with puts if output is desired to go to a channel.
[edit] TI-89 BASIC
right("00000" & format(7.12511, "f3"), 9)
[edit] Toka
needs values
value n
123 to n
2 import printf
" %08d" n printf
[edit] Ursala
The library function printf calls the host system's C library function by that name and can cope with any of the same numeric formats.
#import flo
x = 7.125
#show+
t = <printf/'%09.3f' x>
output:
00007.125
[edit] Vedit macro language
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 = 7125
Num_Ins(#1, FILL+COUNT, 9) Char(-3) Ins_Char('.')
Output:
00007.125
[edit] XSLT
<xsl:value-of select="format-number(7.125, '00000000.#############')" />
