Write float arrays to a text file: Difference between revisions
Write float arrays to a text file (view source)
Revision as of 11:12, 17 February 2024
, 3 months ago→{{header|Wren}}: Minor tidy
m (→{{header|Wren}}: Minor tidy) |
|||
| (107 intermediate revisions by 68 users not shown) | |||
Line 1:
{{task}} [[Category:File_handling]]
{{omit from|GUISS}}
{{omit from|M4}}
{{omit from|Retro|No floating point in standard VM}}
{{omit from|UNIX Shell}}
;Task:
Write two equal-sized numerical arrays 'x' and 'y' to
a two-column text file named 'filename'.
The first column of the file contains values from an 'x'-array with a
given 'xprecision', the second -- values from 'y'-array with 'yprecision'.
For example, considering:
Line 10 ⟶ 19:
yprecision = 5;
The file
1 1
2 1.4142
Line 17 ⟶ 26:
This task is intended as a subtask for [[Measure relative performance of sorting algorithms implementations]].
<br><br>
=={{header|Ada}}==
<
with Ada.Float_Text_IO; use Ada.Float_Text_IO;
with Ada.Numerics.Elementary_Functions; use Ada.Numerics.Elementary_Functions;
Line 51 ⟶ 62:
Write_columns (File, X, Y);
Close (File);
end Write_Float_Array;</
=={{header|ALGOL 68}}==
{{works with|ALGOL 68|Revision 1 - no extensions to language used}}
Line 57 ⟶ 69:
{{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}}
<
FILE f;
INT errno = open(f, filename, stand out channel);
Line 87 ⟶ 99:
print((line,new line))
OD
)</
{{out}}
<pre>
x before: +1.00000000000000e +0 +2.00000000000000e +0 +3.00000000000000e +0 +1.00000000000000e +11
Line 99 ⟶ 111:
</pre>
=={{header|Amazing Hopper}}==
Version hopper-FLOW:
<syntaxhighlight lang="amazing hopper">
#include <flow.h>
DEF-MAIN(argv,argc)
VOID( x ), MSET( y, f )
MEM(1,2,3,1.0e11), APND-LST(x), SET( y, x )
SET-ROUND(5), SQRT(y), MOVE-TO(y)
UNSET-ROUND
CAT-COLS( f, y, x )
TOK-SEP( TAB ), SAVE-MAT(f, "filename.txt" )
END
</syntaxhighlight>
{{out}}
<pre>
$ cat filename.txt
1 1
2 1.41421
3 1.73205
1e+11 316228
</pre>
=={{header|Applesoft BASIC}}==
<syntaxhighlight lang="gwbasic"> 100 D$ = CHR$ (4)
110 F$ = "FILENAME.TXT"
120 READ X(0),X(1),X(2),X(3),Y(0),Y(1),Y(2),Y(3)
130 DATA 1,2,3,1E11
140 DATA 1,1.4142135623730951,1.7320508075688772,316227.76601683791
150 XPRECISIO = 3
160 YPRECISIO = 5
170 PRINT D$"OPEN"F$
180 PRINT D$"CLOSE"F$
190 PRINT D$"DELETE"F$
200 PRINT D$"OPEN"F$
210 PRINT D$"WRITE"F$
220 FOR I = 0 TO 3
230 P = XPRECISIO:N = X(I): GOSUB 300
240 PRINT " ";
250 P = YPRECISIO:N = Y(I): GOSUB 300
260 PRINT
270 NEXT I
280 PRINT D$"CLOSE"F$
290 END
300 O = N
310 E = 0
320 IF O > = 10 THEN GOSUB 390
330 IF O < 1 THEN GOSUB 450
340 LET O = INT ( INT (O * (10 ^ P)) / 10 + .5) / (10 ^ (P - 1))
350 PRINT O;
360 IF E > 0 THEN PRINT "E+" RIGHT$ ("00" + STR$ (E),3);
370 IF E < 0 THEN PRINT "E-" RIGHT$ ("00" + STR$ ( - E),3);
380 RETURN
390 FOR Q = 0 TO 1
400 O = O / 10
410 E = E + 1
420 Q = NOT (O > = 10)
430 NEXT Q
440 RETURN
450 FOR Q = 0 TO 1
460 O = O * 10
470 E = E - 1
480 Q = NOT (O < 1)
490 NEXT Q
500 RETURN</syntaxhighlight>
=={{header|AWK}}==
As usual, the order of array traversal in AWK is not necessarily the same as the input had:
<
> split("1 1.4142135623730951 1.7320508075688772 316227.76601683791",y);
> for(i in x)printf("%6g %.5g\n",x[i],y[i])}'
Line 107 ⟶ 187:
1 1
2 1.4142
3 1.7321</
For the text file part of the task, just redirect stdout to it.
=={{header|BASIC256}}==
<syntaxhighlight lang="basic256">x$ = "1 2 3 1e11"
x$ = explode(x$, " ")
f = freefile
open f, "filename.txt"
for i = 0 to x$[?]-1
writeline f, int(x$[i]) + chr(9) + round(sqrt(x$[i]),4)
next i
close f</syntaxhighlight>
=={{header|BBC BASIC}}==
{{works with|BBC BASIC for Windows}}
<syntaxhighlight lang="bbcbasic"> DIM x(3), y(3)
x() = 1, 2, 3, 1E11
FOR i% = 0 TO 3
y(i%) = SQR(x(i%))
NEXT
xprecision = 3
yprecision = 5
outfile% = OPENOUT("filename.txt")
IF outfile%=0 ERROR 100, "Could not create file"
FOR i% = 0 TO 3
@% = &1000000 + (xprecision << 8)
a$ = STR$(x(i%)) + CHR$(9)
@% = &1000000 + (yprecision << 8)
a$ += STR$(y(i%))
PRINT #outfile%, a$ : BPUT #outfile%, 10
NEXT
CLOSE #outfile%</syntaxhighlight>
{{out}}
<pre>
1 1
2 1.4142
3 1.7321
1E11 3.1623E5
</pre>
=={{header|C}}==
<
#include <math.h>
Line 124 ⟶ 247:
for (i = 0; i < 4; i++) {
y[i] = sqrt(x[i]);
}
return 0;
}</
The file <tt>"floatArray"</tt> then contains the following:
<syntaxhighlight lang="text">1 1
2 1.4142
3 1.7321
1e+11 3.1623e+05</syntaxhighlight>
=={{header|C sharp|C#}}==
<syntaxhighlight lang="csharp">using System.IO;
class Program
{
static void Main(string[] args)
{
var x = new double[] { 1, 2, 3, 1e11 };
var y = new double[] { 1, 1.4142135623730951, 1.7320508075688772, 316227.76601683791 };
string formatString = "{0:G" + xprecision + "}\t{1:G" + yprecision + "}";
using (var outf = new StreamWriter("FloatArrayColumns.txt"))
for (int i = 0; i < x.Length; i++)
outf.WriteLine(formatString, x[i], y[i]);
}
}</syntaxhighlight>
{{out}}
<pre>1 1
2 1.4142
3 1.7321
=={{header|C++}}==
Function ''writedat()'':
<
void writedat(const char* filename,
InputIterator xbegin, InputIterator xend,
Line 226 ⟶ 300:
f << std::setprecision(xprecision) << *xbegin << '\t'
<< std::setprecision(yprecision) << *ybegin << '\n';
}</
Example:
<
#include <cmath> // ::sqrt()
#include <fstream>
Line 258 ⟶ 332:
}
return 0;
}</
{{out|Result}}
<pre>
1 1
Line 266 ⟶ 341:
1e+11 3.1623e+05
</pre>
=={{header|COBOL}}==
<syntaxhighlight lang="cobol">
identification division.
program-id. wr-float.
environment division.
input-output section.
file-control.
select report-file assign "float.txt"
organization sequential.
data division.
file section.
fd report-file
report is floats.
working-storage section.
1 i binary pic 9(4).
1 x-values comp-2.
2 value 1.0.
2 value 2.0.
2 value 3.0.
2 value 1.0e11.
1 redefines x-values comp-2.
2 x occurs 4.
1 comp-2.
2 y occurs 4.
report section.
rd floats.
1 float-line type de.
2 line plus 1.
3 column 1 pic -9.99e+99 source x(i).
2 column 12 pic -9.9999e+99 source y(i).
procedure division.
begin.
open output report-file
initiate floats
perform varying i from 1 by 1
until i > 4
compute y(i) = function sqrt (x(i))
generate float-line
end-perform
terminate floats
close report-file
stop run
.
end program wr-float.
</syntaxhighlight>
{{out|Result}}
<pre>
1.00E+00 1.0000E+00
2.00E+00 1.4142E+00
3.00E+00 1.7321E+00
1.00E+11 3.1623E+05
</pre>
=={{header|Common Lisp}}==
<
(let* ((x (make-array 4 :initial-contents '(1 2 3 1e11)))
(y (map 'vector 'sqrt x))
Line 274 ⟶ 403:
(fmt (format nil "~~,1,~d,,G~~12t~~,~dG~~%" xprecision yprecision)))
(map nil (lambda (a b)
(format stream fmt a b)) x y)))</
Using [[CLISP]] I get
1. 1.0000
Line 282 ⟶ 411:
=={{header|D}}==
<
void main() {
auto
auto
1.7320508075688772, 316227.76601683791];
int xPrecision =
string
foreach (i, fx; x)
tmp ~= format("%." ~ text(xPrecision) ~ "g %." ~
text(yPrecision) ~ "g\r\n", fx, y[i]);
write("float_array.txt", tmp);
}</syntaxhighlight>
{{out}}
<pre>1 1
2 1.4142
3 1.7321
1e+11 3.1623e+05</pre>
=={{header|Delphi}}==
{{libheader| System.SysUtils}}
{{libheader| System.IoUtils}}
<syntaxhighlight lang="delphi">
program Write_float_arrays_to_a_text_file;
{$APPTYPE CONSOLE}
uses
System.SysUtils,
System.IoUtils;
function ToString(v: TArray<Double>): TArray<string>;
var
fmt: TFormatSettings;
begin
fmt := TFormatSettings.Create('en-US');
SetLength(Result, length(v));
for var i := 0 to High(v) do
Result[i] := v[i].tostring(ffGeneral, 5, 3, fmt);
end;
function Merge(a, b: TArray<string>): TArray<string>;
begin
SetLength(Result, length(a));
for var i := 0 to High(a) do
Result[i] := a[i] + ^I + b[i];
end;
var
x, y: TArray<Double>;
begin
x := [1, 2, 3, 1e11];
y := [1, 1.4142135623730951, 1.7320508075688772, 316227.76601683791];
TFile.WriteAllLines('FloatArrayColumns.txt', Merge(ToString(x), ToString(y)));
end.</syntaxhighlight>
{{out}}
<pre>1 1
2 1.4142
3 1.7321
1E011 3.1623E005</pre>
=={{header|Elixir}}==
<syntaxhighlight lang="elixir">defmodule Write_float_arrays do
def task(xs, ys, fname, precision\\[]) do
xprecision = Keyword.get(precision, :x, 2)
yprecision = Keyword.get(precision, :y, 3)
format = "~.#{xprecision}g\t~.#{yprecision}g~n"
File.open!(fname, [:write], fn file ->
Enum.zip(xs, ys)
|> Enum.each(fn {x, y} -> :io.fwrite file, format, [x, y] end)
end)
end
end
x = [1.0, 2.0, 3.0, 1.0e11]
y = for n <- x, do: :math.sqrt(n)
fname = "filename.txt"
Write_float_arrays.task(x, y, fname)
IO.puts File.read!(fname)
precision = [x: 3, y: 5]
Write_float_arrays.task(x, y, fname, precision)
IO.puts File.read!(fname)</syntaxhighlight>
{{out}}
<pre>
1.0 1.00
2.0 1.41
3.0 1.73
1.0e+11 3.16e+5
1.00 1.0000
2.00 1.4142
3.00 1.7321
1.00e+11 3.1623e+5
</pre>
=={{header|Erlang}}==
Erlang thinks 1 is an integer. To persuade it otherwise I have to use 1.0.
<syntaxhighlight lang="erlang">
-module( write_float_arrays ).
-export( [task/0, to_a_text_file/3, to_a_text_file/4] ).
task() ->
File = "afile",
Xs = [1.0, 2.0, 3.0, 1.0e11],
Ys = [1.0, 1.4142135623730951, 1.7320508075688772, 316227.76601683791],
Options = [{xprecision, 3}, {yprecision, 5}],
to_a_text_file( File, Xs, Ys, Options ),
{ok, Contents} = file:read_file( File ),
io:fwrite( "File contents: ~p~n", [Contents] ).
to_a_text_file( File, Xs, Ys ) -> to_a_text_file( File, Xs, Ys, [] ).
to_a_text_file( File, Xs, Ys, Options ) ->
Xprecision = proplists:get_value( xprecision, Options, 2 ),
Yprecision = proplists:get_value( yprecision, Options, 2 ),
Format = lists:flatten( io_lib:format("~~.~pg ~~.~pg~n", [Xprecision, Yprecision]) ),
{ok, IO} = file:open( File, [write] ),
[ok = io:fwrite( IO, Format, [X, Y]) || {X, Y} <- lists:zip( Xs, Ys)],
file:close( IO ).
</syntaxhighlight>
{{out}}
<pre>
3> write_float_arrays:task().
File contents: <<"1.00 1.0000\n2.00 1.4142\n3.00 1.7321\n1.00e+11 3.1623e+5\n">>
</pre>
=={{header|Euphoria}}==
<
y = {1, 1.4142135623730951, 1.7320508075688772, 316227.76601683791}
Line 310 ⟶ 558:
printf(fn,"%.3g\t%.5g\n",{x[n],y[n]})
end for
close(fn)</
=={{header|F Sharp|F#}}==
<syntaxhighlight lang="fsharp">[<EntryPoint>]
let main argv =
let x = [ 1.; 2.; 3.; 1e11 ]
let y = List.map System.Math.Sqrt x
let xprecision = 3
let yprecision = 5
use file = System.IO.File.CreateText("float.dat")
let line = sprintf "%.*g\t%.*g"
List.iter2 (fun x y -> file.WriteLine (line xprecision x yprecision y)) x y
0</syntaxhighlight>
Content of File, visualized with TAB=8
<pre>1 1
2 1.4142
3 1.7321
1e+11 3.1623e+05</pre>
=={{header|Forth}}==
{{works with|GNU Forth}}
<
create y 1e f, 2e fsqrt f, 3e fsqrt f, 1e11 fsqrt f,
Line 329 ⟶ 596:
outfile-id stdout to outfile-id
close-file throw ;</
=={{header|Fortran}}==
=== Fortran 90 ===
{{works with|Fortran|90 and later}}
<
implicit none
Line 370 ⟶ 626:
end subroutine writexy
end program writefloats</
The arrays x and y should have same bounds (and size); this constraint is not checked.
=== Fortran 77 ===
<syntaxhighlight lang="fortran"> program writefloats
integer i
double precision x(4), y(4)
data x /1d0, 2d0, 4d0, 1d11/
do 10 i = 1, 4
y = sqrt(x)
10 continue
open(unit=15, file='two_cols.txt', status='new')
write(15, '(f20.3,f21.4)') (x(i), y(i), i = 1, 4)
end</syntaxhighlight>
=={{header|FreeBASIC}}==
<syntaxhighlight lang="freebasic">' FB 1.05.0 Win64
Dim x(0 To 3) As Double = {1, 2, 3, 1e11}
Dim y(0 To 3) As Double = {1, 1.4142135623730951, 1.7320508075688772, 316227.76601683791}
Open "output.txt" For Output As #1
For i As Integer = 0 To 2
Print #1, Using "#"; x(i);
Print #1, Spc(7); Using "#.####"; y(i)
Next
Print #1, Using "#^^^^"; x(3);
Print #1, Spc(2); Using "##.####^^^^"; y(3)
Close #1</syntaxhighlight>
Contents of output.txt :
{{out}}
<pre>
1 1.0000
2 1.4142
3 1.7321
1E+11 3.1623E+05
</pre>
=={{header|FutureBasic}}==
<syntaxhighlight lang="futurebasic">
local fn DoIt
NSUInteger i
CFStringRef s
CFArrayRef x = @[@1, @2, @3, @1e11]
CFArrayRef y = @[@1, @1.4142135623730951, @1.7320508075688772, @316227.76601683791]
CFMutableStringRef mutStr = fn MutableStringWithCapacity(0)
CFURLRef desktopURL = fn FileManagerURLForDirectory( NSDesktopDirectory, NSUserDomainMask )
CFURLRef url = fn URLByAppendingPathComponent( desktopURL, @"Array_to_file.txt" )
for i = 0 to 3
if ( i < 3 )
s = fn StringWithFormat( @"%ld \t", fn NumberIntegerValue( x[i] ) )
MutableStringAppendString( mutStr, s )
s = fn StringWithFormat( @"%.4f\n", fn NumberFloatValue( y[i] ) )
MutableStringAppendString( mutStr, s )
else
s = fn StringWithFormat( @"%.e\t", fn NumberFloatValue( x[i] ) )
MutableStringAppendString( mutStr, s )
s = fn StringWithFormat( @"%.4e\n", fn NumberFloatValue( y[i] ) )
MutableStringAppendString( mutStr, s )
end if
next
fn StringWriteToURL( mutStr, url, YES, NSUTF8StringEncoding, NULL )
print mutStr
end fn
fn DoIt
HandleEven
</syntaxhighlight>
{{output}}
<pre>
1 1.0000
2 1.4142
3 1.7321
1e+11 3.1623e+05
</pre>
=={{header|Go}}==
<
import (
Line 403 ⟶ 740:
}
f.Close()
}</
File contents:
<pre>
Line 414 ⟶ 751:
=={{header|Haskell}}==
Probably not very idiomatic but oh well
<
import Text.Printf
import Control.Monad
Line 421 ⟶ 758:
withFile filename WriteMode $ \h ->
-- Haskell's printf doesn't support a precision given as an argument for some reason, so we insert it into the format manually:
let writeLine = hPrintf h
zipWithM_ writeLine x y</
Example usage
Prelude> let x = [1, 2, 3, 1e11]
Line 434 ⟶ 771:
3.000 1.73205
1.000e11 316227.76602
Alternative solution without Printf
<syntaxhighlight lang="haskell">import System.IO
import Control.Monad
import Numeric
writeDat filename x y xprec yprec =
withFile filename WriteMode $ \h ->
let writeLine a b = hPutStrLn h $ showGFloat (Just xprec) a "" ++ "\t" ++ showGFloat (Just yprec) b "" in
zipWithM_ writeLine x y</syntaxhighlight>
=={{header|HicEst}}==
<
CHARACTER :: outP = "Test.txt"
Line 444 ⟶ 791:
DO i = 1, n
WRITE(FIle=outP, Format='F5, F10.3') x(i), y(i)
ENDDO </
Alternative: Display or Edit the formatted arrays in a [http://www.HicEst.com/MatrixExplorer spreadsheet-like dialog] with a common scroll bar.
The menu More - Export - File writes the formatted arrays to a file:
<syntaxhighlight lang="hicest">DLG(Text=x, Format='i12', Edit=y, Format='F10.2', Y=0)</syntaxhighlight>
=={{header|Icon}} and {{header|Unicon}}==
The following works in both languages.
<syntaxhighlight lang="unicon">link printf
procedure main()
every put(x := [], (1 to 3) | 1e11)
every put(y := [], sqrt(!x))
every fprintf(open("filename","w"),"%10.2e %10.4e\n", x[i := 1 to *x], y[i])
end</syntaxhighlight>
Contents of <tt>filename</tt> after running:
<pre>
->cat filename
1.00e0 1.0000e0
2.00e0 1.4142e0
3.00e0 1.7321e0
1.00e+11 3.1623e+5
->
</pre>
=={{header|IDL}}==
Line 466 ⟶ 837:
The file <tt>"datafile.txt"</tt> then contains the following:
<
2 1.4142
3 1.7321
1E+011 3.1623E+005</
This is fairly ugly and un-IDLish.
For example one shouldn't just rely on x and y having the same size.
And if data is output in human-readable form,
it should probably be lined up more nicely.
And if it really has to be in two-column format with x and y side by side,
one might consider running ASCII_Template or some such instead of that ugly hand-formatting.
=={{header|J}}==
<
x =. 1 2 3 1e11
Line 486 ⟶ 862:
data =. (0 j. xprecision,yprecision) ": x,.y
data fwrites filename</
Or, more concisely:
<syntaxhighlight lang="j">((0 j. 3 5) ": (,.%:) 1 2 3 1e11) fwrites 'whatever.txt' [ require 'fwrites'</syntaxhighlight>
This loses all of the inline comments and names, and instead relies on the reader's understanding of the purpose of each of the names (for example: 3 is the precision of the first column, and 5 is the precision of the second column).
Note that J's idea of precision here is "positions after the decimal point":
<syntaxhighlight lang="j"> (0 j. 3 5) ": (,.%:) 1 2 3 1e11
1.000 1.00000
2.000 1.41421
3.000 1.73205
100000000000.000 316227.76602</syntaxhighlight>
=={{header|Java}}==
<
public class FloatArray {
Line 521 ⟶ 911:
} catch (IOException e) { }
}
}</
=={{header|Joy}}==
<syntaxhighlight lang="joy">
DEFINE write-floats ==
['g 0] [formatf] enconcat map rollup
['g 0] [formatf] enconcat map swap zip
"filename" "w" fopen swap
[[fputchars] 9 fputch] step 10 fputch] step
fclose.
</syntaxhighlight>
Using it:
<pre>
[1.0 2.0 3.0 1e11] 3
[1.0 1.41421356 1.73205080 316227.7660168] 5
write-floats.
</pre>
=={{header|jq}}==
''' Program''':
<syntaxhighlight lang="jq">[1, 2, 3, 1e11] as $x
| $x | map(sqrt) as $y
| range(0; $x|length) as $i
| "\($x[$i]) \($y[$i])"</syntaxhighlight>
''' Execution''':
To write the output to "filename":
<syntaxhighlight lang="sh">$ jq -n -r -f Write_float_arrays_to_a_text_file.jq > filename</syntaxhighlight>
=={{header|Julia}}==
<syntaxhighlight lang="julia">xprecision = 3
yprecision = 5
x = round.([1, 2, 3, 1e11],xprecision)
y = round.([1, 1.4142135623730951, 1.7320508075688772, 316227.76601683791],yprecision)
writedlm("filename", [x y], '\t')</syntaxhighlight>
=={{header|Kotlin}}==
<syntaxhighlight lang="scala">// version 1.1.2
import java.io.File
fun main(args: Array<String>) {
val x = doubleArrayOf(1.0, 2.0, 3.0, 1e11)
val y = doubleArrayOf(1.0, 1.4142135623730951, 1.7320508075688772, 316227.76601683791)
val xp = 3
val yp = 5
val f = "%.${xp}g\t%.${yp}g\n"
val writer = File("output.txt").writer()
writer.use {
for (i in 0 until x.size) {
val s = f.format(x[i], y[i])
writer.write(s)
}
}
}</syntaxhighlight>
Contents of 'output.txt':
<pre>
1.00 1.0000
2.00 1.4142
3.00 1.7321
1.00e+11 3.1623e+05
</pre>
=={{header|Lingo}}==
<syntaxhighlight lang="lingo">on saveFloatLists (filename, x, y, xprecision, yprecision)
eol = numtochar(10) -- LF
fp = xtra("fileIO").new()
fp.openFile(tFile, 2)
cnt = x.count
repeat with i = 1 to cnt
the floatPrecision = xprecision
fp.writeString(string(x[i])
fp.writeString(TAB)
the floatPrecision = yprecision
fp.writeString(string(y[i])
fp.writeString(eol)
end repeat
fp.closeFile()
end</syntaxhighlight>
<syntaxhighlight lang="lingo">x = [1.0, PI, sqrt(2)]
y = [2.0, log(10), sqrt(3)]
saveFloatLists("floats.txt", x, y, 3, 5)</syntaxhighlight>
=={{header|Lua}}==
<
x = { 1, 2, 3, 1e11 }
Line 538 ⟶ 1,013:
end
io.close( fp )</
=={{header|M2000 Interpreter}}==
Precision here is just Round (as school rounding)
Print round(2.5,0)=3
Print round(1.5,0)=2
Print round(-2.5,0)=-3
Print round(-1.5,0)=-2
<syntaxhighlight lang="m2000 interpreter">
Module Test1 (filename$, x, xprecision, y, yprecision) {
locale 1033 // set decimal point symbol to "."
// using: for wide output // for UTF16LE
// here we use ANSI (8bit per character)
open filename$ for output as #f
for i=0 to len(x)-1
print #f, format$("{0} {1}", round(x#val(i),xprecision-1), round(y#val(i), yprecision-1))
next
close #f
win "notepad", dir$+filename$
}
Test1 "OutFloat.num", (1, 2, 3, 1.e11),3, (1, 1.4142135623730951, 1.7320508075688772, 316227.76601683791), 5
</syntaxhighlight>
{{out}}
<pre>1 1
2 1.4142
3 1.7321
100000000000 316227.766</pre>
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<syntaxhighlight lang="mathematica">exportPrec[path_, data1_, data2_, prec1_, prec2_] :=
Export[
path,
Transpose[{Map[ToString[NumberForm[#, prec2]] &, data2], Map[ToString[NumberForm[#, prec1]] &, data1]}],
"Table"
]</syntaxhighlight>
=={{header|MATLAB}} / {{header|Octave}}==
<syntaxhighlight lang="matlab"> x = [1, 2, 3, 1e11];
y = [1, 1.4142135623730951, 1.7320508075688772, 316227.76601683791];
fid = fopen('filename','w')
fprintf(fid,'%.3g\t%.5g\n',[x;y]);
fclose(fid); </syntaxhighlight>
{{out}}
<pre>1 1
2 1.4142
3 1.7321
1e+11 3.1623e+05</pre>
=={{header|Mercury}}==
<syntaxhighlight lang="mercury">:- module write_float_arrays.
:- interface.
:- import_module io.
:- pred main(io::di, io::uo) is det.
:- implementation.
:- import_module float, list, math, string.
main(!IO) :-
io.open_output("filename", OpenFileResult, !IO),
(
OpenFileResult = ok(File),
X = [1.0, 2.0, 3.0, 1e11],
list.foldl_corresponding(write_dat(File, 3, 5), X, map(sqrt, X), !IO),
io.close_output(File, !IO)
;
OpenFileResult = error(IO_Error),
io.stderr_stream(Stderr, !IO),
io.format(Stderr, "error: %s\n", [s(io.error_message(IO_Error))], !IO),
io.set_exit_status(1, !IO)
).
:- pred write_dat(text_output_stream::in, int::in, int::in, float::in,
float::in, io::di, io::uo) is det.
write_dat(File, XPrec, YPrec, X, Y, !IO) :-
io.format(File, "%.*g\t%.*g\n", [i(XPrec), f(X), i(YPrec), f(Y)], !IO).</syntaxhighlight>
File contents:
<pre>
1 1
2 1.4142
3 1.7321
1e+11 3.1623e+05
</pre>
=={{header|NetRexx}}==
<syntaxhighlight lang="netrexx">/* NetRexx */
options replace format comments java crossref savelog symbols nobinary
-- Invent a target text file name based on this program's source file name
parse source . . pgmName '.nrx' .
outFile = pgmName || '.txt'
do
formatArrays(outFile, [1, 2, 3, 1e+11], [1, 1.4142135623730951, 1.7320508075688772, 316227.76601683791])
catch ex = Exception
ex.printStackTrace
end
return
-- 08:55, 27 August 2022 (UTC)08:55, 27 August 2022 (UTC)08:55, 27 August 2022 (UTC)08:55, 27 August 2022 (UTC)08:55, 27 August 2022 (UTC)08:55, 27 August 2022 (UTC)08:55, 27 August 2022 (UTC)08:55, 27 August 2022 (UTC)08:55, 27 August 2022 (UTC)08:55, 27 August 2022 (UTC)08:55, 27 August 2022 (UTC)08:55, 27 August 2022 (UTC)08:55, 27 August 2022 (UTC)08:55, 27 August 2022 (UTC)08:55, 27 August 2022 (UTC)~~
-- This function formats the input arrays.
-- It has defaults for the x & y precision values of 3 & 5
-- 08:55, 27 August 2022 (UTC)08:55, 27 August 2022 (UTC)08:55, 27 August 2022 (UTC)08:55, 27 August 2022 (UTC)08:55, 27 August 2022 (UTC)08:55, 27 August 2022 (UTC)08:55, 27 August 2022 (UTC)08:55, 27 August 2022 (UTC)08:55, 27 August 2022 (UTC)08:55, 27 August 2022 (UTC)08:55, 27 August 2022 (UTC)08:55, 27 August 2022 (UTC)08:55, 27 August 2022 (UTC)08:55, 27 August 2022 (UTC)08:55, 27 August 2022 (UTC)~~
method formatArrays(outFile, xf = Rexx[], yf = Rexx[], xprecision = 3, yprecision = 5) -
public static signals IllegalArgumentException, FileNotFoundException, IOException
if xf.length > yf.length then signal IllegalArgumentException('Y array must be at least as long as X array')
fw = BufferedWriter(OutputStreamWriter(FileOutputStream(outFile)))
loop i_ = 0 to xf.length - 1
row = xf[i_].format(null, xprecision, null, xprecision).left(15) yf[i_].format(null, yprecision, null, yprecision)
(Writer fw).write(String row)
fw.newLine
end i_
fw.close
return
</syntaxhighlight>
{{out}}
<pre>
1.000 1.00000
2.000 1.41421
3.000 1.73205
1.000E+11 3.16228E+5
</pre>
=={{header|NewLISP}}==
<syntaxhighlight lang="newlisp">; file: write-float-array.lsp
; url: http://rosettacode.org/wiki/Write_float_arrays_to_a_text_file
; author: oofoe 2012-01-30
; The "transpose" function is used to flip the joined lists around so
; that it's easier to iterate through them together.
(define (write-float-array x xp y yp filename)
(let ((f (format "%%-10.%dg %%-10.%dg" xp yp))
(o (open filename "write")))
(dolist (v (transpose (list x y)))
(write-line o (format f (v 0) (v 1))))
(close o)
))
; Test
(write-float-array
'(1 2 3 1e11) 3
'(1 1.4142135623730951 1.7320508075688772 316227.76601683791) 5
"filename.chan")
(println "File contents:")
(print (read-file "filename.chan"))
(exit)</syntaxhighlight>
{{out}}
<pre>File contents:
1 1
2 1.4142
3 1.7321
1e+011 3.1623e+005
</pre>
=={{header|Nim}}==
<syntaxhighlight lang="nim">import strutils, math, sequtils
const OutFileName = "floatarr2file.txt"
const
XPrecision = 3
Yprecision = 5
let a = [1.0, 2.0, 3.0, 100_000_000_000.0]
let b = [sqrt(a[0]), sqrt(a[1]), sqrt(a[2]), sqrt(a[3])]
var res = ""
for t in zip(a, b):
res.add formatFloat(t[0], ffDefault, Xprecision) & " " &
formatFloat(t[1], ffDefault, Yprecision) & "\n"
OutFileName.writeFile res
var res2 = OutFileName.readFile()
echo res2</syntaxhighlight>
{{out}}
<pre>1.00 1.0000
2.00 1.4142
3.00 1.7321
1.00e+11 3.1623e+05</pre>
=={{header|OCaml}}==
<
let oc = open_out filename in
let write_line a b = Printf.fprintf oc "%.*g\t%.*g\n" xprec a yprec b in
List.iter2 write_line x y;
close_out oc</
Example usage
# let x = [1.0; 2.0; 3.0; 1e11];;
Line 566 ⟶ 1,241:
1e+11 3.1623e+05
- : unit = ()
=={{header|PARI/GP}}==
{{works with|PARI/GP|2.5.0 and above}}
<syntaxhighlight lang="parigp">f(x,pr)={
Strprintf(if(x>=10^pr,
Str("%.",pr-1,"e")
,
Str("%.",pr-#Str(x\1),"f")
),x)
};
wr(x,y,xprec,yprec)={
for(i=1,#x,
write("filename",f(x[i],xprec),"\t",f(y[i],yprec))
)
};</syntaxhighlight>
=={{header|Pascal}}==
<syntaxhighlight lang="pascal">Program WriteNumbers;
const
x: array [1..4] of double = (1, 2, 3, 1e11);
xprecision = 3;
yprecision = 5;
baseDigits = 7;
var
i: integer;
filename: text;
begin
assign (filename, 'filename');
rewrite (filename);
for i := 1 to 4 do
writeln (filename, x[i]:baseDigits+xprecision, sqrt(x[i]):baseDigits+yprecision);
close (filename);
end.</syntaxhighlight>
File contents
<pre>
1.00E+000 1.0000E+000
2.00E+000 1.4142E+000
3.00E+000 1.7321E+000
1.00E+011 3.1623E+005
</pre>
=={{header|Perl}}==
<syntaxhighlight lang
sub writedat {
my ($filename, $x, $y, $xprecision, $yprecision) = @_;
open my $fh, ">", $filename;
for my $i (0 .. $#$x) {
printf $fh "%.*g\t%.*g\n", $xprecision||3, $x->[$i], $yprecision||5, $y->[$i];
}
close $fh;
}
Line 578 ⟶ 1,303:
my @y = map sqrt, @x;
writedat("sqrt.dat", \@x, \@y);</
File contents
<pre>
Line 587 ⟶ 1,312:
</pre>
Alternatively, with the CPAN List::MoreUtils package:
<syntaxhighlight lang="perl">use autodie;
use List::MoreUtils qw(each_array);
sub writedat {
my ($filename, $x, $y, $xprecision, $yprecision) = @_;
open my $fh, ">", $filename;
my $ea = each_array(@$x, @$y);
while ( my ($i, $j) = $ea->() ) {
printf $fh "%.*g\t%.*g\n", $xprecision||3, $i, $yprecision||5, $j;
}
close $fh
}
my @x = (1, 2, 3, 1e11);
my @y = map sqrt, @x;
writedat("sqrt.dat", \@x, \@y);</syntaxhighlight>
=={{header|Phix}}==
Copy of [[Write_float_arrays_to_a_text_file#Euphoria|Euphoria]]
<!--<syntaxhighlight lang="phix">-->
<span style="color: #008080;">constant</span> <span style="color: #000000;">x</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">2</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">3</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">1e11</span><span style="color: #0000FF;">},</span>
<span style="color: #000000;">y</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">1.4142135623730951</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">1.7320508075688772</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">316227.76601683791</span><span style="color: #0000FF;">}</span>
<span style="color: #004080;">integer</span> <span style="color: #000000;">fn</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">open</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"filename"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"w"</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">x</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">fn</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%.3g\t%.5g\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">x</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">],</span><span style="color: #000000;">y</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]})</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<span style="color: #7060A8;">close</span><span style="color: #0000FF;">(</span><span style="color: #000000;">fn</span><span style="color: #0000FF;">)</span>
<!--</syntaxhighlight>-->
File contents:
<pre>
1 1
2 1.4142
3 1.7321
1e+11 3.1623e+5
</pre>
=={{header|PicoLisp}}==
An exponential format like "1e11" is not supported
<
(scl 7)
Line 621 ⟶ 1,366:
(round Y *Yprecision) ) )
(1.0 2.0 3.0)
(1.0 1.414213562 1.732050807) )</
{{out}}
<pre>1.000 1.00000
2.000 1.41421
3.000 1.73205</pre>
=={{header|PL/I}}==
<syntaxhighlight lang="pl/i">*Process source attributes xref;
aaa: Proc Options(main);
declare X(5) float (9) initial (1, 2, 3, 4, 5),
Y(5) float (18) initial (9, 8, 7, 6, 1e9);
declare (x_precision, y_precision) fixed binary;
Dcl out stream output;
open file(out) title('/OUT.TXT,type(text),recsize(100)');
x_precision = 9;
y_precision = 16;
put file(out) edit((X(i),Y(i) do i=1 to 5))
(skip,e(19,x_precision),
x(2),e(24,y_precision));
end;</syntaxhighlight>
{{out}}
<pre> 1.000000000E+0000 9.0000000000000000E+0000
2.000000000E+0000 8.0000000000000000E+0000
3.000000000E+0000 7.0000000000000000E+0000
4.000000000E+0000 6.0000000000000000E+0000
5.000000000E+0000 1.0000000000000000E+0009 </pre>
=={{header|PowerShell}}==
<syntaxhighlight lang="powershell">$x = @(1, 2, 3, 1e11)
$y = @(1, 1.4142135623730951, 1.7320508075688772, 316227.76601683791)
$xprecision = 3
$yprecision = 5
$arr = foreach($i in 0..($x.count-1)) {
[pscustomobject]@{x = "{0:g$xprecision}" -f $x[$i]; y = "{0:g$yprecision}" -f $y[$i]}
}
($arr | format-table -HideTableHeaders | Out-String).Trim() > filename.txt
</syntaxhighlight>
<b>Output:</b>
<pre>
1 1
2 1.4142
3 1.7321
1e+11 3.1623e+05
</pre>
=={{header|PureBasic}}==
<
DataSection
Line 655 ⟶ 1,439:
CloseFile(fileID)
EndIf
EndIf</
{{out}} to text file:
<pre>1.000 1.00000
2.000 1.41421
Line 664 ⟶ 1,448:
=={{header|Python}}==
{{works with|Python|2.6}}
<
def writedat(filename, x, y, xprecision=3, yprecision=5):
with open(filename,'w') as f:
for a, b in itertools.izip(x, y):
print >> f, "%.*g\t%.*g" % (xprecision, a, yprecision, b)</
Example usage
<
>>> x = [1, 2, 3, 1e11]
>>> y = map(math.sqrt, x)
Line 684 ⟶ 1,468:
2 1.4142
3 1.7321
1e+011 3.1623e+005</
{{works with|Python|3}}
<
with open(filename,'w') as f:
for a, b in zip(x, y):
print("%.*g\t%.*g" % (xprecision, a, yprecision, b), file=f)
#or, using the new-style formatting:
#print("{1:.{0}g}\t{3:.{2}g}".format(xprecision, a, yprecision, b), file=f)</
=={{header|R}}==
<
fx <- formatC(x, digits=xprecision, format="g", flag="-")
fy <- formatC(y, digits=yprecision, format="g", flag="-")
dfr <- data.frame(fx, fy)
write.table(dfr, file=file, sep="\t", row.names=F, col.names=F, quote=F)
}
x <- c(1, 2, 3, 1e11)
y <- sqrt(x)
writexy(
=={{header|
<syntaxhighlight lang="racket">
#lang racket
(define xs '(1.0 2.0 3.0 1.0e11))
(define ys '(1.0 1.4142135623730951 1.7320508075688772 316227.76601683791))
(define xprecision 3)
(define yprecision 5)
(with-output-to-file "some-file" #:exists 'truncate
(λ() (for ([x xs] [y ys])
(displayln (~a (~r x #:precision xprecision)
" "
(~r y #:precision yprecision))))))
#|
The output is not using exponenets as above, but that's not needed
since Racket can read these numbers fine:
1 1
2 1.41421
3 1.73205
100000000000 316227.76602
|#
</syntaxhighlight>
=={{header|Raku}}==
(formerly Perl 6)
===Perl 5-ish===
Written in the style of the 2nd Perl 5 example.
<syntaxhighlight lang="raku" line>sub writefloat ( $filename, @x, @y, $x_precision = 3, $y_precision = 5 ) {
my $fh = open $filename, :w;
for flat @x Z @y -> $x, $y {
$fh.printf: "%.*g\t%.*g\n", $x_precision, $x, $y_precision, $y;
}
$fh.close;
}
my @x = 1, 2, 3, 1e11;
my @y = @x.map({.sqrt});
writefloat( 'sqrt.dat', @x, @y );</syntaxhighlight>
{{out}}
<pre>1 1
2 1.4142
3 1.7321
1e+11 3.1623e+05</pre>
===Idiomatic===
Written in a more idiomatic style.
<syntaxhighlight lang="raku" line>sub writefloat($filename, @x, @y, :$x-precision = 3, :$y-precision = 3) {
open($filename, :w).print:
join '', flat (@x».fmt("%.{$x-precision}g") X "\t") Z (@y».fmt("%.{$y-precision}g") X "\n");
}
my @x = 1, 2, 3, 1e11;
writefloat('sqrt.dat', @x, @x».sqrt, :y-precision(5));</syntaxhighlight>
{{out}}
<pre>1 1
2 1.4142
3 1.7321
1e+11 3.1623e+05</pre>
=={{header|Raven}}==
<syntaxhighlight lang="raven">3 as $xprecision
5 as $yprecision
[ ] as $results
[ 1 2 3 1e11 ] as $a
group
$a each sqrt
list as $b
# generate format specifier "%-8.3g %.5g\n"
"%%-8.%($xprecision)dg %%.%($yprecision)dg\n" as $f
define print2 use $v1, $v2, $f
$v2 1.0 prefer $v1 1.0 prefer $f format $results push
4 each as $i
$f $b $i get $a $i get print2
$results "" join "results.dat" write</syntaxhighlight>
{{out}}
results.dat file contains:
<pre>1 1
2
3 1.7321
1e+11 3.1623e+05</pre>
=={{header|REXX}}==
<syntaxhighlight lang="rexx">/*REXX program writes two arrays to a file with a specified (limited) precision. */
numeric digits 1000 /*allow use of a huge number of digits.*/
oFID= 'filename' /*name of the output File IDentifier.*/
x.=; y.=; x.1= 1 ; y.1= 1
x.2= 2 ; y.2= 1.4142135623730951
x.3= 3 ; y.3= 1.7320508075688772
x.4= 1e11 ; y.4= 316227.76601683791
xPrecision= 3 /*the precision for the X numbers. */
yPrecision= 5 /* " " " " Y " */
do j=1 while x.j\=='' /*process and reformat all the numbers.*/
newX=rule(x.j, xPrecision) /*format X numbers with new precision*/
newY=rule(y.j, yPrecision) /* " Y " " " " */
aLine=translate(newX || left('',4) || newY, "e", 'E')
say aLine /*display re─formatted numbers ──► term*/
call lineout oFID, aLine /*write " " " disk*/
end /*j*/
exit /*stick a fork in it, we're all done. */
/*──────────────────────────────────────────────────────────────────────────────────────*/
rule: procedure; parse arg z 1 oz,p; numeric digits p; z=format(z,,p)
parse var z mantissa 'E' exponent /*get the dec dig exponent*/
parse var mantissa int '.' fraction /* " integer and fraction*/
fraction=strip(fraction, 'T', 0) /*strip trailing zeroes.*/
if fraction\=='' then fraction="."fraction /*any fractional digits ? */
if exponent\=='' then exponent="E"exponent /*in exponential format ? */
z=int || fraction || exponent /*format # (as per rules)*/
if datatype(z,'W') then return format(oz/1,,0) /*is it a whole number ? */
return format(oz/1,,,3,0) /*3 dec. digs in exponent.*/</syntaxhighlight>
'''output''' when using the default (internal) data:
<pre>
1 1
2 1.4142
Line 789 ⟶ 1,615:
1e+011 3.1623e+005
</pre>
=={{header|Ring}}==
<syntaxhighlight lang="ring">
# Project : Write float arrays to a text file
decimals(13)
x = [1, 2, 3, 100000000000]
y = [1, 1.4142135623730, 1.7320508075688, 316227.76601683]
str = list(4)
fn = "C:\Ring\calmosoft\output.txt"
fp = fopen(fn,"wb")
for i = 1 to 4
str[i] = string(x[i]) + " | " + string(y[i]) + windowsnl()
fwrite(fp, str[i])
next
fclose(fp)
fp = fopen("C:\Ring\calmosoft\output.txt","r")
r = ""
while isstring(r)
r = fgetc(fp)
if r = char(10) see nl
else see r ok
end
fclose(fp)
</syntaxhighlight>
Output:
<pre>
1 | 1
2 | 1.4142135623730
3 | 1.7320508075688
100000000000.0000000000000 | 316227.76601683
</pre>
=={{header|RLaB}}==
In RLaB this task can be done in two ways:
1. Direct writing of the numerical data to the file of an array using function ''writem''. Here the writing format
is specified using the global property that is accessible through function ''format''.
<syntaxhighlight lang="rlab">
>> x = rand(10,1); y = rand(10,1);
>> writem("mytextfile.txt", [x,y]);
</syntaxhighlight>
2. Converting the numerical data to text, and then writing the text to the file, using the same function ''writem''.
Here, the writing format is specified through ''text'' function, and the result is written as a plain string matrix.
<syntaxhighlight lang="rlab">
>> x = rand(10,1); y = rand(10,1);
>> s = text( [x,y], "%10.8f" );
>> writem("mytextfile.txt", s);
</syntaxhighlight>
Please note, ''writem'' function in RLaB can operate in two-fold fashion. RLaB keeps track of the open files that were created using the built-in function ''open''.
If user writes the data to a file using ''open'' followed by ''writem'' then RLaB opens the file in append mode if it already hasn't been opened. If it has been, then the command ''open'' is ignored (say in batch mode). Then, each successive call to ''writem'' appends newest data to the end of the file while keeping the file open. RLaB will close the file (and OS will flush its file buffer) upon the command ''close''.
If user writes the data to a file by using only ''writem'' then the RLaB temporarily opens the file, writes the data to it, and then closes the file. Successive calls to ''writem'' in this mode will erase the previous content of the file.
=={{header|Ruby}}==
<
x = [1, 2, 3, 1e11]
y = x.collect { |xx| Math.sqrt xx }
Line 803 ⟶ 1,685:
# print the result file
open('sqrt.dat', 'r') { |f| puts f.read }</
Result:
<pre>1 1
Line 809 ⟶ 1,691:
3 1.7321
1e+11 3.1623e+05</pre>
=={{header|Run BASIC}}==
<syntaxhighlight lang="runbasic">x$ = "1, 2, 3, 1e11"
y$ = "1, 1.4142135623730951, 1.7320508075688772, 316227.76601683791"
open "filename" for output as #f ' Output to "filename"
for i = 1 to 4
print #f, using("##############.###",val(word$(x$,i,",")));"|";using("#######.#####",val(word$(y$,i,",")))
next i
close #f</syntaxhighlight>
{{out}}
<pre> 1.000| 1.00000
2.000| 1.41421
3.000| 1.73205
100000000000.000| 316227.76602</pre>
=={{header|SAS}}==
<syntaxhighlight lang="sas">data _null_;
input x y;
file "output.txt";
put x 12.3 " " y 12.5;
cards;
1 1
2 1.4142135623730951
3 1.7320508075688772
1e11 316227.76601683791
;
run;</syntaxhighlight>
=={{header|Scala}}==
{{libheader|Scala}}<syntaxhighlight lang="scala">import java.io.{File, FileWriter, IOException}
object FloatArray extends App {
val x: List[Float] = List(1f, 2f, 3f, 1e11f)
def writeStringToFile(file: File, data: String, appending: Boolean = false) =
using(new FileWriter(file, appending))(_.write(data))
def using[A <: {def close() : Unit}, B](resource: A)(f: A => B): B =
try f(resource) finally resource.close()
try {
val file = new File("sqrt.dat")
using(new FileWriter(file))(writer => x.foreach(x => writer.write(f"$x%.3g\t${math.sqrt(x)}%.5g\n")))
} catch {
case e: IOException => println(s"Running Example failed: ${e.getMessage}")
}
}</syntaxhighlight>
=={{header|Seed7}}==
The library [http://seed7.sourceforge.net/libraries/math.htm math.s7i] defines the function [http://seed7.sourceforge.net/libraries/math.htm#sqrt%28ref_float%29 sqrt]. The operators [http://seed7.sourceforge.net/libraries/float.htm#%28ref_float%29sci%28ref_integer%29 sci] and [http://seed7.sourceforge.net/libraries/float.htm#%28in_string%29exp%28in_integer%29 exp] (defined in [http://seed7.sourceforge.net/libraries/float.htm float.s7i]) support writing floating point numbers in scientific notation.<syntaxhighlight lang="seed7">$ include "seed7_05.s7i";
include "float.s7i";
include "math.s7i";
const proc: main is func
local
const array float: numbers is [] (1.0, 2.0, 3.0, 1.0e11);
var float: aFloat is 0.0;
var file: aFile is STD_NULL;
begin
aFile := open("filename", "w");
for aFloat range numbers do
writeln(aFile, aFloat sci 3 exp 2 <& " " <& sqrt(aFloat) sci 5 exp 2);
end for;
close(aFile);
end func;</syntaxhighlight>{{out|Result file ''filename''}}
1.000e+00 1.00000e+00
2.000e+00 1.41421e+00
3.000e+00 1.73205e+00
1.000e+11 3.16228e+05
=={{header|Sidef}}==
{{trans|Raku}}
<syntaxhighlight lang="ruby">func writedat(filename, x, y, x_precision=3, y_precision=5) {
var fh = File(filename).open_w
for a,b in (x ~Z y) {
fh.printf("%.*g\t%.*g\n", x_precision, a, y_precision, b)
}
fh.close
}
var x = [1, 2, 3, 1e11]
var y = x.map{.sqrt}
writedat('sqrt.dat', x, y)</syntaxhighlight>
{{out}}
<pre>
1 1
2 1.4142
3 1.7321
1e+11 3.1623e+05
</pre>
=={{header|Smalltalk}}==
{{works with | Smalltalk/X}}
<syntaxhighlight lang="smalltalk">x := #( 1 2 3 1e11 ).
y := x collect:#sqrt.
xprecision := 3.
yprecision := 5.
'sqrt.dat' asFilename writingFileDo:[:fileStream |
x with:y do:[:xI :yI |
'%.*g\t%.*g\n' printf:{ xprecision . xI . yprecision . yI } on:fileStream
]
]</syntaxhighlight>
obviously, with fix precisions, the following printing expression is more readable:
<syntaxhighlight lang="smalltalk">'%.3g\t%.5g\n' printf:{ xI . yI } on:fileStream</syntaxhighlight>
=={{header|SPL}}==
<syntaxhighlight lang="spl">x = [1, 2, 3, 10^11]
y = [1, 1.4142135623730951, 1.7320508075688772, 316227.76601683791]
xprecision = 3
yprecision = 5
> i, 1..4
s1 = #.str(x[i],"g"+xprecision)
s2 = #.str(y[i],"g"+yprecision)
#.writeline("file.txt",s1+#.tab+s2)
<</syntaxhighlight>
=={{header|Standard ML}}==
<
val os = TextIO.openOut filename
fun write_line (a, b) =
Line 819 ⟶ 1,820:
ListPair.appEq write_line (x, y);
TextIO.closeOut os
end;</
Example usage
- val x = [1.0, 2.0, 3.0, 1e11];
Line 835 ⟶ 1,836:
1E11 3.1623E05
val it = () : unit
=={{header|Stata}}==
<syntaxhighlight lang="stata">* Create the dataset
clear
mat x=1\2\3\1e11
svmat double x
ren *1 *
gen y=sqrt(x)
format %10.1g x
format %10.5g y
* Save as text file
export delim file.txt, delim(" ") novar datafmt replace</syntaxhighlight>
{{out}}
<pre>1 1
2 1.4142
3 1.7321
1.0e+11 316228</pre>
=={{header|Tcl}}==
<
foreach a $x {lappend y [expr {sqrt($a)}]}
set fh [open sqrt.dat w]
Line 847 ⟶ 1,869:
set fh [open sqrt.dat]
puts [read $fh [file size sqrt.dat]]
close $fh</
{{out}}
<pre>1 1
2 1.4142
Line 854 ⟶ 1,876:
1e+011 3.1623e+005</pre>
=={{
<syntaxhighlight lang="vb">Public Sub main()
x = [{1, 2, 3, 1e11}]
y = [{1, 1.4142135623730951, 1.7320508075688772, 316227.76601683791}]
Dim TextFile As Integer
TextFile = FreeFile
Open "filename" For Output As TextFile
For i = 1 To UBound(x)
Print #TextFile, Format(x(i), "0.000E-000"), Format(y(i), "0.00000E-000")
Next i
Close TextFile
End Sub</syntaxhighlight>{{out}}
<pre>1,000E000 1,00000E000
2,000E000 1,41421E000
3,000E000 1,73205E000
1,000E011 3,16228E005
</pre>
=={{header|V (Vlang)}}==
{{incomplete|V (Vlang)|Formatting at least currently doesn't allow variables, floating point notation `g` seems to have bugs}}
<syntaxhighlight lang="v (vlang)">import os
const (
x = [1.0, 2, 3, 1e11]
y = [1.0, 1.4142135623730951, 1.7320508075688772, 316227.76601683791]
xprecision = 3
yprecision = 5
)
fn main() {
if x.len != y.len {
println("x, y different length")
return
}
mut f := os.create("filename")?
defer {
f.close()
}
for i,_ in x {
f.write_string('${x[i]:3}, ${y[i]:1G}\n')?
}
}</syntaxhighlight>
{{out}}
<pre> 1, 1
2, 1.414
3, 1.732
1e+11, 316227.766
</pre>
=={{header|Wren}}==
{{libheader|Wren-fmt}}
In the above module, 'precision' signifies the number of decimal places whereas for the purpose of this task it appears to mean the number of significant figures. We adjust for that by using a precision one less than the required figure.
In the final example, we need to force exponential format as numbers of this size would normally be printed in decimal format.
<syntaxhighlight lang="wren">import "io" for File
import "./fmt" for Fmt
var x = [1, 2, 3, 1e11]
var y = [1, 1.4142135623730951, 1.7320508075688772, 316227.76601683791]
var xprec = 3 - 1
var yprec = 5 - 1
File.create("filename.txt") { |file|
for (i in 0...x.count) {
var f = (i < x.count-1) ? "h" : "e"
var s = Fmt.swrite("$0.%(xprec)%(f)\t$0.%(yprec)%(f)\n", x[i], y[i])
file.writeBytes(s)
}
}</syntaxhighlight>
{{out}}
The contents of filename.txt:
<pre>
1 1
2 1.4142
3 1.7321
1e11 3.1623e05
</pre>
=={{header|XPL0}}==
Output is redirected to the file like this: writefloat > filename
Precision here refers to the size of the numeric field. A precision of 5
means a total of five digits, e.g: 1.2345. XPL0 translates this as one place
before the decimal point and four places after it.
<syntaxhighlight lang "XPL0">include xpllib; \for Print
real X, Y;
int N;
[X:= [1., 2., 3., 1e11];
Y:= [1., 1.4142135623730951, 1.7320508075688772, 316227.76601683791];
for N:= 0 to 3 do
Print("%1.2g\t%1.4g\n", X(N), Y(N));
]</syntaxhighlight>
{{out}}
<pre>
1 1
2 1.4142
3 1.7321
1e11 3.1623e5
</pre>
=={{header|Yabasic}}==
<syntaxhighlight lang="yabasic">x$ = "1 2 3 1e11"
pr1 = 3 : pr2 = 5
dim x$(1)
n = token(x$, x$())
f = open("filename.txt", "w")
for i = 1 to n
print #f str$(val(x$(i)), "%1." + str$(pr1) + "g") + "\t" + str$(sqrt(val(x$(i))), "%1." + str$(pr2) + "g")
next i
close #f</syntaxhighlight>
=={{header|zkl}}==
<syntaxhighlight lang="zkl">fcn writeFloatArraysToFile(filename, xs,xprecision, ys,yprecision){
f :=File(filename,"w");
fmt:="%%.%dg\t%%.%dg".fmt(xprecision,yprecision).fmt; // "%.3g\t%.5g".fmt
foreach x,y in (xs.zip(ys)){ f.writeln(fmt(x,y)); }
f.close();
}
xs,ys := T(1.0, 2.0, 3.0, 1e11), xs.apply("sqrt");
xprecision,yprecision := 3,5;
writeFloatArraysToFile("floatArray.txt", xs,xprecision, ys,yprecision);</syntaxhighlight>
{{out}}
<pre>
$ cat floatArray
1 1
2 1.4142
3 1.7321
1e+11 3.1623e+05
</pre>
=={{header|ZX Spectrum Basic}}==
The ZX Spectrum has a dedicated file format for floating point arrays.
Although this format is not a text file, it would be the usual format
for writing such data to a file on a ZX Spectrum.
Here we write the contents of the array g() to a file:
<syntaxhighlight lang="zxbasic">SAVE "myarray" DATA g()</syntaxhighlight>
| |||