Formatted numeric output: Difference between revisions

Content added Content deleted

Inline

Revision as of 15:20, 2 April 2009

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

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

APL

      'ZF15.9' ⎕FMT 7.125
00007.125000000

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

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:

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

\ 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

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

Haskell

import Text.Printf
main =
  printf "%09.3f" 7.125

IDL

n = 7.125
print, n, format='(f08.3)'
;==> 0007.125

J

   'r<0>15.9' (8!:2) 7.125
00007.125000000

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

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

Oberon-2

Module Out must be imported before use.

OCaml

<lang ocaml>Printf.printf "%09.3f\n" 7.125</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>

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

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       !

Raven

7.125 "%09.3f" print

00007.125

Ruby

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

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

Standard ML

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

Tcl

set number 7.342
format "%08.3f" $number

Toka

needs values
value n
123 to n

2 import printf
" %08d" n printf

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.#############')" />