Formatted numeric output: Difference between revisions

Content added Content deleted

Inline

Revision as of 08:04, 27 November 2008

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

<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;</ada> 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

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

}</c> Output:

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

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

Stealing printf from C/C++: <java>public class Printing{ public static void main(String[] args){ double printer = 7.125; System.out.printf("%09.3f",printer); } }</java>

JavaScript

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

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.

Out.Real(7.125, 9, 0);

OCaml

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

Perl

Works with: Perl version 5.x

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

PHP

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

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

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

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

printf " %09.3f\n", 7.125

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

Tcl

set number 7.342
format "%08.3f" $number

Toka

needs values
value n
123 to n

2 import printf
" %08d" n printf

XSLT

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