Formatted numeric output: Difference between revisions
m (Fixed lang tags.) |
|||
Line 24: | Line 24: | ||
=={{header|ALGOL 68}}== |
=={{header|ALGOL 68}}== |
||
<lang algol68>main:( |
|||
<pre> |
|||
main:( |
|||
REAL r=exp(pi)-pi; |
REAL r=exp(pi)-pi; |
||
print((r,newline)); |
print((r,newline)); |
||
Line 41: | Line 40: | ||
printf(($zzzz-d.ddddeddl$,r)); |
printf(($zzzz-d.ddddeddl$,r)); |
||
printf(($4z-d.4de4dl$,r)) |
printf(($4z-d.4de4dl$,r)) |
||
⚫ | |||
) |
|||
</pre> |
|||
Output: |
Output: |
||
⚫ | |||
<pre> |
|||
⚫ | |||
-19.9991 |
-19.9991 |
||
19.9991 |
19.9991 |
||
Line 58: | Line 55: | ||
1.9999e1 |
1.9999e1 |
||
1.9999e01 |
1.9999e01 |
||
1.9999e0001 |
1.9999e0001</lang> |
||
</pre> |
|||
=={{header|AmigaE}}== |
=={{header|AmigaE}}== |
||
Line 85: | Line 81: | ||
== {{header|APL}} == |
== {{header|APL}} == |
||
'ZF15.9' ⎕FMT 7.125 |
<lang apl> 'ZF15.9' ⎕FMT 7.125 |
||
00007.125000000</lang> |
|||
APL's <tt>⎕FMT</tt> is similar to C's <tt>printf</tt> (only it operates on arrays). |
APL's <tt>⎕FMT</tt> is similar to C's <tt>printf</tt> (only it operates on arrays). |
||
Line 105: | Line 101: | ||
=={{header|AutoHotkey}}== |
=={{header|AutoHotkey}}== |
||
contributed by Laszlo on the ahk [http://www.autohotkey.com/forum/post-276467.html#276467 forum] |
contributed by Laszlo on the ahk [http://www.autohotkey.com/forum/post-276467.html#276467 forum] |
||
<lang AutoHotkey> |
<lang AutoHotkey>MsgBox % pad(7.25,7) ; 0007.25 |
||
MsgBox % pad(7.25,7) ; 0007.25 |
|||
MsgBox % pad(-7.25,7) ; -007.25 |
MsgBox % pad(-7.25,7) ; -007.25 |
||
Line 153: | Line 148: | ||
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.) |
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: |
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> |
|||
=={{header|Fortran}}== |
=={{header|Fortran}}== |
||
{{works with|Fortran|90 and later}} |
{{works with|Fortran|90 and later}} |
||
Using standard data edit descriptors it is only possible to precede Integer data with leading zeros. |
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> |
|||
=={{header|gnuplot}}== |
=={{header|gnuplot}}== |
||
Line 179: | Line 174: | ||
=={{header|Haskell}}== |
=={{header|Haskell}}== |
||
<lang haskell>import Text.Printf |
|||
main = |
|||
printf "%09.3f" 7.125</lang> |
|||
=={{header|IDL}}== |
=={{header|IDL}}== |
||
[[Category:IDL]] |
[[Category:IDL]] |
||
<lang idl>n = 7.125 |
|||
print, n, format='(f08.3)' |
|||
;==> 0007.125</lang> |
|||
=={{header|J}}== |
=={{header|J}}== |
||
'r<0>15.9' (8!:2) 7.125 |
<lang j> 'r<0>15.9' (8!:2) 7.125 |
||
00007.125000000</lang> |
|||
=={{header|Java}}== |
=={{header|Java}}== |
||
Line 215: | Line 210: | ||
=={{header|Logo}}== |
=={{header|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. |
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}} |
{{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. |
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> |
|||
=={{header|Modula-3}}== |
=={{header|Modula-3}}== |
||
Line 248: | Line 243: | ||
The task is underspecified, so we present a few alternatives. |
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> |
|||
=={{header|PowerShell}}== |
=={{header|PowerShell}}== |
||
Line 323: | Line 318: | ||
=={{header|R}}== |
=={{header|R}}== |
||
formatC provides C-style string formatting. |
formatC provides C-style string formatting. |
||
<lang R> |
<lang R>formatC(x, width=9, flag="0") |
||
⚫ | |||
formatC(x, width=9, flag="0") |
|||
⚫ | |||
⚫ | |||
Other string formatting functions include |
Other string formatting functions include |
||
format, prettynum |
format, prettynum |
||
=={{header|Raven}}== |
=={{header|Raven}}== |
||
<lang raven>7.125 "%09.3f" print |
|||
00007.125</lang> |
|||
=={{header|Ruby}}== |
=={{header|Ruby}}== |
||
Line 340: | Line 333: | ||
=={{header|SQL}}== |
=={{header|SQL}}== |
||
{{works with|MS SQL|2005}} |
{{works with|MS SQL|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> |
|||
=={{header|Standard ML}}== |
=={{header|Standard ML}}== |
||
Line 360: | Line 353: | ||
{{improve|TI-89 BASIC|It does not handle negative numbers.}} |
{{improve|TI-89 BASIC|It does not handle negative numbers.}} |
||
< |
<lang ti89b>right("00000" & format(7.12511, "f3"), 9)</lang> |
||
=={{header|Toka}}== |
=={{header|Toka}}== |
||
<lang toka>needs values |
|||
value n |
|||
123 to n |
|||
2 import printf |
|||
" %08d" n printf</lang> |
|||
=={{header|Ursala}}== |
=={{header|Ursala}}== |
||
Line 387: | Line 380: | ||
Vedit only supports integers, but fixed point calculations can be used for decimal values.<br> |
Vedit only supports integers, but fixed point calculations can be used for decimal values.<br> |
||
The following example uses 3 decimal places (value scaled by 1000). The output is inserted at current edit position. |
The following example uses 3 decimal places (value scaled by 1000). The output is inserted at current edit position. |
||
<lang vedit> |
<lang vedit>#1 = 7125 |
||
⚫ | |||
#1 = 7125 |
|||
⚫ | |||
</lang> |
|||
Output: |
Output: |
Revision as of 14:48, 20 November 2009
You are encouraged to solve this task according to the task description, using any language you may know.
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>
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) <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
<lang apl> 'ZF15.9' ⎕FMT 7.125 00007.125000000</lang>
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 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:
-7.125 7.125 7.125 -0007.125 00007.125 7.125
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>
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
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
<lang j> 'r<0>15.9' (8!:2) 7.125 00007.125000000</lang>
Java
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>
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>
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.
<lang oberon2>Out.Real(7.125, 9, 0);</lang>
OCaml
<lang ocaml>Printf.printf "%09.3f\n" 7.125</lang>
Perl
<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.
<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
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 !
<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
Raven
<lang raven>7.125 "%09.3f" print
00007.125</lang>
Ruby
<lang ruby>printf " %09.3f\n", 7.125</lang>
SQL
<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
<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.#############')" />
- Programming Tasks
- Basic language learning
- Text processing
- Ada
- ALGOL 68
- AmigaE
- APL
- AWK
- AutoHotkey
- C
- C++
- Common Lisp
- Forth
- Fortran
- Gnuplot
- Haskell
- IDL
- J
- Java
- JavaScript
- Logo
- Modula-3
- Oberon-2
- OCaml
- Perl
- PHP
- Pop11
- PowerShell
- Python
- R
- Raven
- Ruby
- SQL
- Standard ML
- Tcl
- TI-89 BASIC
- TI-89 BASIC examples needing attention
- Examples needing attention
- Toka
- Ursala
- Vedit macro language
- XSLT