Formatted numeric output: Difference between revisions

Content added Content deleted

Inline

Revision as of 11:54, 25 February 2010

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".

Ada

<lang 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;</lang> The output of this program is

000037.25

ALGOL 68

<lang algol68>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))

)</lang> Output: <lang algol68>+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</lang>

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) <lang amigae>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</lang>

APL

APL's ⎕FMT is similar to C's printf (only it operates on arrays).

AWK

<lang 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

}</lang>

Same output as the C code.

AutoHotkey

contributed by Laszlo on the ahk forum <lang AutoHotkey>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)

}</lang>

C#

<lang csharp> class Program

       static void Main(string[] args)
       {

           float myNumbers = 7.125F;
           
           string strnumber = Convert.ToString(myNumbers);
                      
           Console.WriteLine(strnumber.PadLeft(9, '0'));
          
           Console.ReadLine();
       }

</lang>

C

<lang 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;

}</lang> Output:

C++

<lang cpp>#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;

}</lang>

Clojure

Translation of: Common Lisp

Using cl format strings

<lang lisp>(cl-format true "~9,3,,,'0F" 7.125)</lang>

Translation of: java

Using java format strings

<lang lisp>(printf "%09.3f" 7.125) ; format works the same way (without side the effect of printing)</lang>

Common Lisp

<lang lisp>(format t "~9,3,,,'0F" 7.125)</lang>

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.)

<lang forth>\ 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 ;</lang>

Usage example:

<lang forth>Type: 123 s>d 8 ud.0 Result: 00000123 ok Type: -123 s>d 8 d.0 Result: -00000123 ok</lang>

Fortran

Works with: Fortran version 90 and later

Using standard data edit descriptors it is only possible to precede Integer data with leading zeros. <lang fortran>INTEGER :: number = 7125 WRITE(*,"(I8.8)") number ! Prints 00007125</lang>

gnuplot

<lang gnuplot>print sprintf("%09.3f", 7.125)</lang>

Haskell

<lang haskell>import Text.Printf main =

 printf "%09.3f" 7.125</lang>

IDL

<lang idl>n = 7.125 print, n, format='(f08.3)'

==> 0007.125</lang>

J

Java

Works with: Java version 1.5+

Stealing printf from C/C++: <lang java>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 } }</lang>

JavaScript

<lang javascript>var n = 123; var str = ("00000" + n).slice(-5); alert(str);</lang>

or, put in browser URL: javascript:n=123;alert(("00000"+n).slice(-5));

Also, a 60-line implementation of sprintf can be found here.

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. <lang logo>to zpad :num :width :precision

 output map [ifelse ? = "| | ["0] [?]] form :num :width :precision

end print zpad 7.125 9 3 ; 00007.125</lang>

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. <lang logo>print form 7.125 -1 "|%09.3f| ; 00007.125</lang>

Lua

<lang 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</lang>

Modula-3

Modules IO and Fmt must be imported before use. <lang modula3>IO.Put(Fmt.Pad("7.125\n", length := 10, padChar := '0'));</lang>

Oberon-2

Module Out must be imported before use.

Objective-C

<lang objc>NSLog(@"%09.3f", 7.125);</lang> or <lang objc>NSLog(@"%@", [NSString stringWithFormat:@"%09.3f", 7.125]);</lang>

OCaml

<lang ocaml>Printf.printf "%09.3f\n" 7.125</lang>

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: <lang oz>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}}</lang>

Perl

Works with: Perl version 5.x

<lang perl>printf " %09.3f\n", 7.125;</lang>

PHP

<lang php>echo str_pad(7.125, 9, '0', STR_PAD_LEFT);</lang> or <lang php>printf("%09.3f\n", 7.125);</lang>

PicoLisp

<lang PicoLisp>(pad 9 (format 7125 3)) (pad 9 (format 7125 3 ",")) # European format</lang>

PL/I

<lang PL/I> put edit (X) (p'999999.V999'); /* Western format. */

put edit (X) (p'999999,V999'); /* In European format. */

</lang>

Pop11

The task is underspecified, so we present a few alternatives.

<lang pop11>;;; 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</lang>

PowerShell

Using the -f formatting operator and a custom format string: <lang powershell>"{0,9:00000.000}" -f 7.125</lang>

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.

<lang python>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)</lang>

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

<lang python>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))</lang>

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       !

R

formatC provides C-style string formatting. <lang R>formatC(x, width=9, flag="0")

"00007.125"</lang>

Other string formatting functions include

format, prettynum

REBOL

<lang 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

]

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</lang>

Output:

Raven

<lang raven>7.125 "%09.3f" print

00007.125</lang>

Ruby

<lang ruby>printf " %09.3f\n", 7.125</lang>

SQL

Works with: MS SQL version 2005

<lang sql>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</lang>

Standard ML

<lang sml>print (StringCvt.padLeft #"0" 9 (Real.fmt (StringCvt.FIX (SOME 3)) 7.125) ^ "\n")</lang>

Tcl

<lang tcl>set number 7.342 format "%08.3f" $number</lang> Use with puts if output is desired to go to a channel.

TI-89 BASIC

This example is in need of improvement:

It does not handle negative numbers.

<lang ti89b>right("00000" & format(7.12511, "f3"), 9)</lang>

Toka

<lang toka>needs values value n 123 to n

2 import printf " %08d" n printf</lang>

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. <lang Ursala>#import flo

x = 7.125

show+

t = <printf/'%09.3f' x></lang> output:

00007.125

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. <lang vedit>#1 = 7125 Num_Ins(#1, FILL+COUNT, 9) Char(-3) Ins_Char('.')</lang>

Output:

 00007.125

XSLT

<xsl:value-of select="format-number(7.125, '00000000.#############')" />