Formatted numeric output: Difference between revisions

=={{header|11l}}==

 

 

{{out}}

 

As an added bonus, this program supports trailing zeroes, but since the example didn't have any it won't get run.

.stack 1024

.data

 

LeadingZeroes byte 4 ;number of leading zeroes to print

 

{{out}}

 

=={{header|8th}}==

7.125 "%09.3f" s:strfmt

. cr

{{out}}

<pre>

=={{header|AArch64 Assembly}}==

{{works with|as|Raspberry Pi 3B version Buster 64 bits}}

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program formatNum64.s */

qAdrsfNumber1: .quad sfNumber1

 

{{Output}}

<pre>

 

=={{header|Ada}}==

with Ada.Text_Io; use Ada.Text_Io;

 

begin

Put(Item => Value, Pic => Pic);

{{out}}

<pre>

 

=={{header|Aime}}==

o_form("/w12d6p6/\n", -12.0625);

{{out}}

<pre>00007.125

{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-1.18.0/algol68g-1.18.0-9h.tiny.el5.centos.fc11.i386.rpm/download 1.18.0-9h.tiny]}}

{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d] - due to extensive use of FORMATted transput}}

REAL r=exp(pi)-pi;

print((r,newline));

printf(($zzzz-d.ddddeddl$,r));

printf(($4z-d.4de4dl$,r))

{{out}}

<pre>

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)

DEF s, t, i

IF (len = 0) OR (len < (digit+3))

DEF s[100] : STRING

WriteF('\s\n', newRealF(s, 7.125, 3,9))

 

=={{header|APL}}==

 

 

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

=={{header|ARM Assembly}}==

{{works with|as|Raspberry Pi}}

/* ARM assembly Raspberry PI */

/* program formatNum.s */

 

 

 

=={{header|Arturo}}==

 

 

print r

 

{{out}}

=={{header|AutoHotkey}}==

contributed by Laszlo on the ahk [http://www.autohotkey.com/forum/post-276467.html#276467 forum]

MsgBox % pad(-7.25,7) ; -007.25

 

VarSetCapacity(p,len,Asc("0"))

Return SubStr(p x,1-len)

 

=={{header|AWK}}==

r=7.125

printf " %9.3f\n",-r

printf " %09.3f\n",r

printf " %-09.3f\n",r

 

Same output as the C code.

BaCon can use C style <tt>printf</tt> format specifiers.

 

n = 7.125

 

{{out}}

 

=={{header|BBC BASIC}}==

PRINT FNformat(-PI, 9, 3)

END

= RIGHT$(STRING$(sl%,"0") + STR$(n), sl%)

ENDIF

{{out}}

<pre>

First define a custom function for numeric output.

 

* Print number n, using at least c characters.

*

 

scale = s /* Restore original scale. */

 

Then use this function to print 7.125 with 9 characters.

 

"Decimal: "; t = p(x, 9); "

"

"Binary: "; t = p(x, 1001); "

"

 

{{out}}

 

=={{header|Beads}}==

calc main_init

var num = 7.125

{{out}}

<pre>00007.125</pre>

=={{header|C}}==

main(){

float r=7.125;

printf(" %-09.3f\n",r);

return 0;

{{out}}

-7.125

 

=={{header|C sharp|C#}}==

class Program

{

}

 

=={{header|C++}}==

#include <iomanip>

 

std::cout << std::setfill('0') << std::setw(9) << std::fixed << std::setprecision(3) << 7.125 << std::endl;

return 0;

C++20

#include <format>

std::cout << std::format("{:09.3f}\n", 7.125);

return 0;

 

=={{header|Clojure}}==

 

{{trans|Common Lisp}} Using cl format strings

 

{{trans|java}} Using java format strings

 

=={{header|COBOL}}==

This is actually the easiest kind of numeric output to achieve in COBOL, because it requires no adjustments from the way numbers are stored internally (in fixed-point decimal). Each variable declaration requires a <tt>PIC</tt> or <tt>PICTURE</tt> clause describing the kind of data that will be stored there. In this case, we have <tt>9</tt> (a decimal digit), repeated five times; then <tt>V</tt>, the decimal point (cf. French <i>virgule</i>); and then three more decimal digits. Other terms that can appear in <tt>PICTURE</tt> clauses include <tt>A</tt> (a letter of the alphabet), <tt>X</tt> (a character), and <tt>Z</tt> (a decimal digit to be printed with leading spaces instead of leading zeros).

PROGRAM-ID. NUMERIC-OUTPUT-PROGRAM.

DATA DIVISION.

MOVE 7.125 TO X.

DISPLAY X UPON CONSOLE.

{{out}}

<pre>00007.125</pre>

 

=={{header|Common Lisp}}==

 

=={{header|D}}==

 

void main() {

writefln(" %09.3f", r);

writefln(" %-09.3f", r);

{{out}}

<pre> -7.125

 

=={{header|DBL}}==

A10=D5,'-ZZZZX.XXX' ; 7.125

A10=D5,'-ZZZZX.XXX' [LEFT] ;7.125

A10=-D5,'ZZZZX.XXX-' [LEFT] ;7.125-

 

 

=={{header|dc}}==

First define a custom function for numeric output.

 

* (n) (c) lpx

* Print number n, using at least c characters.

Lnsz Lcsz Ldsz Lfsz LDsz LFsz LLsz LIsz LPsz

Ls k [Restore variable s. Restore original scale.]sz

 

Then use this function to print 7.125 with 9 characters:

 

[Decimal: ]P lx 9 lpx [

]P 16 i [Hexadecimal: ]P lx 9 lpx [

]P 2 i [Binary: ]P lx 9 lpx [

 

{{out}}

=={{header|Delphi}}==

 

program FormattedNumericOutput;

 

Readln;

end.

 

{{out}}

{{works with|Eiffel Studio|6.6}}

 

note

description : "{

 

end

 

=={{header|Elixir}}==

 

:io.fwrite "~f~n", [n]

:io.fwrite "~.3f~n", [n]

:io.fwrite "~e~n", [n]

:io.fwrite "~12.4e~n", [n]

 

{{out}}

 

=={{header|Emacs Lisp}}==

 

<code>format</code> is similar to C <code>sprintf</code>. See [http://www.gnu.org/software/emacs/manual/html_node/elisp/Formatting-Strings.html GNU Elisp manual on Formatting Strings].

 

=={{header|ERRE}}==

 

PROCEDURE FORMATTED_PRINT(N,LENGTH,DEC_PLACES->FP$)

END FOR

 

{{out}}

<pre>

 

=={{header|Euphoria}}==

printf(1,"%9.3f\n",-r)

printf(1,"%9.3f\n",r)

printf(1,"%09.3f\n",-r)

printf(1,"%09.3f\n",r)

 

{{out}}

 

=={{header|F_Sharp|F#}}==

 

=={{header|Factor}}==

{{out}}

<pre>

=={{header|Fantom}}==

 

class Main

{

}

}

 

=={{header|Forth}}==

(The 1- is necessary because #s always generates at least one digit, even if it's zero.)

 

: #n ( d n -- d ) 0 ?do # loop ;

 

 

\ d.0 prints a signed double

 

Usage example:

 

Result: 00000123 ok

Type: -123 s>d 8 d.0

===={{header|Detail}}====

Forth's number formatting words are different than many other languages because they are active code rather than using a pattern string. This small set of seven routines ( >DIGIT <# #> # #S HOLD SIGN ) allow arbitrary number formatting of double precision and single precision numbers. The number is created in a "hold' buffer the output is typically a Forth style stack-string consisting of an address and a length.

{{works with|Fortran|90 and later}}

Using standard data edit descriptors it is only possible to precede Integer data with leading zeros.

===On the other hand===

One can engage in trickery via FORMAT statements, in particular the T format option. Unlike actual tab settings which on a typewriter go to a particular column following, T''n'' means go to column ''n''.

INTEGER IV

REAL V

1 FORMAT (F9.3,T1,I5.5)

END

Output is

00007.125

 

=={{header|FreeBASIC}}==

 

#Include "vbcompat.bi"

Dim s As String = Format(7.125, "00000.0##")

Print s

 

{{out}}

 

=={{header|FutureBasic}}==

 

print using "0000#.###";7.125

 

Output:

<pre>

=={{header|Gambas}}==

'''[https://gambas-playground.proko.eu/?gist=4f64ab96d0f97df5876b76ab0431b302 Click this link to run this code]'''

 

Print Format("7.125", "00000.000")

 

Output:

<pre>

 

=={{header|gnuplot}}==

 

=={{header|Go}}==

 

=={{header|Groovy}}==

Solution:

 

{{out}}

 

=={{header|Haskell}}==

main =

 

=={{header|hexiscript}}==

let n tostr n

while len n < length

endfun

 

 

=={{header|HicEst}}==

 

=={{header|i}}==

concept FixedLengthFormat(value, length) {

string = text(abs(value))

print(FixedLengthFormat(-d, 9))

}

 

=={{header|Icon}} and {{header|Unicon}}==

 

procedure main()

write(sprintf(p,r)," <=== sprintf ",p)

}

 

{{out}} Abbreviated

[[Category:IDL]]

 

print, n, format='(f08.3)'

 

=={{header|IS-BASIC}}==

 

=={{header|J}}==

 

[http://www.jsoftware.com/help/dictionary/dx008.htm Documentation on 8!:]

{{works with|Java|1.5+}}

Stealing printf from C/C++:

public static void main(String[] args){

double value = 7.125;

System.out.println(String.format("%09.3f",value));

}

{{out}}

<pre>000000007.125

000000007.125</pre>

Using <code>NumberFormat</code>:

import java.text.NumberFormat;

 

System.out.println(numForm.format(7.135));//rounds to even

}

{{out}}

<pre>000000007.125

 

=={{header|JavaScript}}==

var str = ("00000" + n).slice(-5);

 

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

requirements, but no truncation occurs; pp/1 is similar but

is likely to be more useful as the decimal point is aligned if possible.

tostring

| if width > length then (width - length) * "0" + . else . end;

| index(".") as $ix

| ((if $ix then $s[0:$ix] else $s end) | lpad) + "." +

'''Examples''':

produces

00000012.3

000333.333

 

produces

0012.3

0333.33

 

=={{header|Julia}}==

Julia's <tt>@sprintf</tt> macro provides string formatting that is similar to that of the c function of the same name. Though easy to use and efficient, <tt>@sprintf</tt> has limited flexibility, as its format specification must be a string literal, precluding its use in dynamic formatting. Greater flexibility is available via the <tt>Formatting</tt> package, which provides an implementation of Python's format specification mini-language. This solution demonstrates both of these techniques to provide the leading zero padded floating point format suggested in the task description ("%09.3f").

test = [7.125, [rand()*10^rand(0:4) for i in 1:9]]

 

printfmtln(fe, i)

end

 

{{out}}

 

=={{header|Kotlin}}==

 

fun main(args: Array<String>) {

val num = 7.125

println("%09.3f".format(num))

 

{{out}}

=={{header|Lambdatalk}}==

Lambdatalk has no primitive for numeric output. This is a way to define it:

{def fmt

{def padd {lambda {:n :x} {if {< :n 1} then else :x{padd {- :n 1} :x}}}}

>>>>>>>> -69.990

>>>>>> +4970.430

 

=={{header|Lasso}}==

{{out}}

<pre>00007.125</pre>

NB no check that this does not truncate high-order digits...

and remember LB calculates with more figures than its normal 'print' displays.

for i =1 to 10

n =rnd( 1) *10^( int( 10 *rnd(1)) -2)

FormattedPrint$ =right$( "000000000000" +nn$, length) ' chop to required length

end function

{{out}}

<pre>

Various collection functions, such as MAP and FILTER,

will work on individual characters of a string when given a word instead of a list.

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

end

 

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

 

=={{header|Lua}}==

function fixedprint(num, digs) --digs = number of digits before decimal point

for i = 1, digs - digits(num) do

end

 

 

 

An easier way to do that would be

 

print(string.format("%09.3d",7.125))

 

=={{header|M2000 Interpreter}}==

We can use ? as Print

Print str$(7.125,"00000.000")

 

=={{header|Maple}}==

3.141593

printf("%.0f", Pi);

+0003.14

printf("%+0*.*f",8, 2, Pi);

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

 

=={{header|MATLAB}} / {{header|Octave}}==

 

=={{header|Mercury}}==

:- module formatted_numeric_output.

:- interface.

main(!IO) :-

io.format("%09.3f\n", [f(7.125)], !IO).

 

=={{header|min}}==

{{works with|min|0.19.6}}

(pick length - repeat swap str-append) :left-pad

 

{{out}}

<pre>

=={{header|Modula-3}}==

Modules <tt>IO</tt> and <tt>Fmt</tt> must be imported before use.

 

=={{header|Nanoquery}}==

{{out}}

<pre>00007.125</pre>

 

=={{header|NetRexx}}==

 

options replace format comments java crossref savelog symbols binary

 

return

{{out}}

<pre>

 

=={{header|Nim}}==

const r = 7.125

echo r

echo fmt"{r:9.3f}"

echo fmt"{-r:09.3f}"

{{out}}

<pre>7.125

Module <code>Out</code> must be imported before use.

 

 

=={{header|Objective-C}}==

or

 

=={{header|OCaml}}==

 

=={{header|OpenEdge/Progress}}==

STRING( 7.125, "99999.999" )

 

=={{header|Oz}}==

It doesn't seem to be possible to use leading zeros for printing,

so we implement this manually:

fun {PrintFloat X Prec}

{Property.put 'print.floatPrecision' Prec}

end

in

 

=={{header|PARI/GP}}==

{{works with|PARI/GP|2.4.3 and above}}

 

=={{header|Pascal}}==

const

wholeNumberPlaces = 5;

// rounded

write(n:0:fractionalPlaces);

 

=={{header|Perl}}==

{{works with|Perl|5.x}}

 

=={{header|Phix}}==

{{libheader|Phix/basics}}

<span style="color: #7060A8;">printf<span style="color: #0000FF;">(<span style="color: #000000;">1<span style="color: #0000FF;">,<span style="color: #008000;">"%09.3f\n"<span style="color: #0000FF;">,<span style="color: #000000;">7.125<span style="color: #0000FF;">)

{{out}}

<pre>

 

=={{header|PHP}}==

or

 

=={{header|PicoLisp}}==

 

=={{header|PL/I}}==

put edit (X) (p'999999.V999'); /* Western format. */

 

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

 

 

/*********************************************************************

* 10.09.2013 Walter Pachl one way to treat negative numbers

Put Skip List(z,s);

End;

{{out}}

<pre>

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

 

format_print('~12,3,0,`*,`0F', [1299.19]);

;;; prints "00001299.190"

;;; prints "100000000000000000.000"

;;; that is uses more space if the number does not fit into

 

=={{header|PowerShell}}==

Using the <code>-f</code> formatting operator and a custom format string:

or by invoking <code>ToString</code> on the number:

 

=={{header|PureBasic}}==

Using RSet() to pad 7.125 with 3 decimals converted to a string, to 8 char length.

 

=={{header|Python}}==

specifying how many digits appear in the exponent when printed with a format.

 

r = exp(pi)-pi

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

{{out}}

<pre>

 

{{works with|Python|3}}

r = exp(pi)-pi

print(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))

{{out}}

<pre>

[http://www.stat.ucl.ac.be/ISdidactique/Rhelp/library/base/html/sprintf.html sprintf] brings the printf goodness one expects:

 

[1] "3.141593"

> sprintf("%.3f", pi)

[1] "3141592.65"

> sprintf("%G", 1e-6 * pi)

 

formatC also provides C-style string formatting.

 

Other string formatting functions include

=={{header|Racket}}==

 

-> (displayln (~a 7.125 #:width 9 #:align 'right #:pad-string "0"))

00007.125

 

=={{header|Raku}}==

(formerly Perl 6)

 

=={{header|Raven}}==

 

{{trans|Python}}

-1 acos

r -1 * dup dup "e=%09.4e f=%09.4f g=%09.4g!\n" print

r dup dup "e=%09.4e f=%09.4f g=%09.4g!\n" print

s=19.999100!

e=1.999910e+01 f=19.999100 g=19.9991 G=19.9991!

e=-1.9999e+01 f=-019.9991 g=-00000020!

e=1.9999e+01 f=0019.9991 g=000000020!

 

=={{header|REBOL}}==

Title: "Formatted Numeric Output"

URL: http://rosettacode.org/wiki/Formatted_Numeric_Output

print [zeropad 9 negate 7.125]

print [zeropad 9 7.125]

 

{{out}}

 

=={{header|REXX}}==

a=7.125

b=translate(format(a,10),0,' ')

say 't=' t

say 'u=' u

{{out}}

<pre style="height:30ex">

 

=={{header|Ring}}==

decimals(3)

see fixedprint(7.125, 5) + nl

next

see num + nl

 

=={{header|Ruby}}==

printf " %9.3f\n", r #=> 7.125

printf " %09.3f\n", r #=> 00007.125

puts " %09.3f" % r #=> 00007.125

puts " %09.3f" % -r #=> -0007.125

 

=={{header|Run BASIC}}==

 

=={{header|Rust}}==

fn main() {

let x = 7.125;

println!("{:09}", -x);

}

{{out}}

<pre>

The Fill options should fill with any character, but it is still (!) not implemented; according to [http://www.icsi.berkeley.edu/~sather/Documentation/Library/LibraryBrowser/short-FMT.html ICSI Sather library documentation] (GNU Sather library documentation is missing) works only for string, bools and characters, but a test has revealed it does not work in either way (yet) (GNU Sather v1.2.3).

 

main is

#OUT + #FMT("<F0 #####.###>", 7.1257) + "\n";

#OUT + #FMT("<F0 #####.###>", 7.1254) + "\n";

end;

 

Luckly the C-like formats are supported too:

 

 

=={{header|Scala}}==

{{works with|Scala|2.10.2}}

As shown in a [https://github.com/scala-ide/scala-worksheet/wiki/Getting-Started Scala Worksheet]:

val r = 7.125 //> r : Double = 7.125

println(f" ${-r}%9.3f"); //> -7,125

println(f" $r%-9.3f"); //> 7,125

println(f" $r%+09.3f"); //> +0007,125

 

=={{header|Scheme}}==

Gauche/share/gauche/site/lib/

 

(load "srfi-54.scm") ;; Don't ask.

 

(dotimes (i 4)

(print (cat x 25 3.0 #\0 (list #\, (- 4 i)))))

{{output}}

<pre>

 

=={{header|Seed7}}==

include "float.s7i";

 

writeln( r digits 3);

writeln(-r digits 3);

 

{{out}}

 

=={{header|Sidef}}==

or

{{out}}

<pre>

=={{header|Smalltalk}}==

{{works with|Pharo 1.1.1}}

 

{{works with|Smalltalk/X}}

notice that printOn:* is implemented in Object;thus any object can be printed with padding this way.

 

Using the PrintfScanf utility:

 

=={{header|SQL}}==

{{works with|MS SQL|2005}}

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)

 

=={{header|Standard ML}}==

{{works with|SML/NJ}}

 

=={{header|Stata}}==

See '''[https://www.stata.com/help.cgi?format format]''' in Stata help.

 

 

=={{header|Suneido}}==

 

{{out}}

 

=={{header|Tcl}}==

Use with <tt>puts</tt> if output is desired to go to a channel.

 

{{improve|TI-89 BASIC|It does not handle negative numbers.}}

 

 

=={{header|Toka}}==

value n

123 to n

 

2 import printf

 

=={{header|Ursala}}==

library function by that name and can cope with any of

the same numeric formats.

 

x = 7.125

#show+

 

{{out}}

<pre>00007.125</pre>

 

=={{header|Vala}}==

double r = 7.125;

print(" %9.3f\n", -r);

print(" %09.3f\n",r);

print(" %-09.3f\n",r);

{{out}}

<pre>

 

=={{header|VBA}}==

 

Sub Main()

End If

End Function

{{out}}

<pre>0000000001230.33

=={{header|VBScript}}==

{{works with|Windows Script Host|*}}

a = 1234.5678

 

' Use integer portion only and pad with zeroes to fill 8 chars. Output = "00001234".

WScript.Echo Right("00000000" & Int(a), 8)

 

=={{header|Vedit macro language}}==

The following example uses 3 decimal places (value scaled by 1000).

The output is inserted at current edit position.

 

{{out}}

=={{header|Visual Basic}}==

{{works with|Visual Basic|VB6 Standard}}

Debug.Print Format$(7.125, "00000.000")

Output (the decimal separator used depends on the system's language settings):

00007.125

 

=={{header|Wren}}==

{{libheader|Wren-fmt}}

 

var n = 7.125

 

{{out}}

 

=={{header|XPL0}}==

[Format(5, 3); \5 places before decimal point and 3 after

RlOut(8, 7.125); \output real number to internal buffer

ChOut(0, C); \display digit character on terminal

];

 

{{out}}

 

=={{header|zkl}}==

"%09.3e".fmt(7.125) //-->"7.125e+00"

"%09.3g".fmt(7.125) //-->"000007.12"

"%09d".fmt(7.125) //-->"000000007"

 

=={{header|ZX Spectrum Basic}}==

20 LET width=9

30 GO SUB 1000

1030 LET n$="0"+n$

1040 NEXT i