Rosetta Code

Write float arrays to a text file: Difference between revisions

Page Discussion

Write float arrays to a text file (view source)

Revision as of 11:12, 17 February 2024

16,079 bytes added ,  3 months ago
m
→‎{{header|Wren}}: Minor tidy
m (→‎{{header|Wren}}: Minor tidy)
 
(46 intermediate revisions by 30 users not shown)
Line 19:
yprecision = 5;
 
The file isshould look like:
1 1
2 1.4142
Line 29:
 
=={{header|Ada}}==
<langsyntaxhighlight lang="ada">with Ada.Text_IO; use Ada.Text_IO;
with Ada.Float_Text_IO; use Ada.Float_Text_IO;
with Ada.Numerics.Elementary_Functions; use Ada.Numerics.Elementary_Functions;
Line 62:
Write_columns (File, X, Y);
Close (File);
end Write_Float_Array;</langsyntaxhighlight>
 
=={{header|ALGOL 68}}==
Line 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}}
<langsyntaxhighlight lang="algol68">PROC writedat = (STRING filename, []REAL x, y, INT x width, y width)VOID: (
FILE f;
INT errno = open(f, filename, stand out channel);
Line 99:
print((line,new line))
OD
)</langsyntaxhighlight>
{{out}}
<pre>
Line 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:
<langsyntaxhighlight lang="awk">$ awk 'BEGIN{split("1 2 3 1e11",x);
> split("1 1.4142135623730951 1.7320508075688772 316227.76601683791",y);
> for(i in x)printf("%6g %.5g\n",x[i],y[i])}'
Line 119 ⟶ 187:
1 1
2 1.4142
3 1.7321</langsyntaxhighlight>
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}}
<langsyntaxhighlight lang="bbcbasic"> DIM x(3), y(3)
x() = 1, 2, 3, 1E11
FOR i% = 0 TO 3
Line 144 ⟶ 224:
NEXT
CLOSE #outfile%</langsyntaxhighlight>
{{out}}
<pre>
Line 154 ⟶ 234:
 
=={{header|C}}==
<langsyntaxhighlight lang="c">#include <stdio.h>
#include <math.h>
 
Line 171 ⟶ 251:
 
return 0;
}</langsyntaxhighlight>
 
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</langsyntaxhighlight>
 
=={{header|C sharp|C#}}==
<langsyntaxhighlight lang="csharp">using System.IO;
 
class Program
Line 198 ⟶ 278:
outf.WriteLine(formatString, x[i], y[i]);
}
}</langsyntaxhighlight>
 
{{out}}
Line 205 ⟶ 285:
3 1.7321
1E+11 3.1623E+05</pre>
 
 
=={{header|C++}}==
Function ''writedat()'':
<langsyntaxhighlight lang="cpp">template<class InputIterator, class InputIterator2>
void writedat(const char* filename,
InputIterator xbegin, InputIterator xend,
Line 221 ⟶ 300:
f << std::setprecision(xprecision) << *xbegin << '\t'
<< std::setprecision(yprecision) << *ybegin << '\n';
}</langsyntaxhighlight>
Example:
<langsyntaxhighlight lang="cpp">#include <algorithm>
#include <cmath> // ::sqrt()
#include <fstream>
Line 253 ⟶ 332:
}
return 0;
}</langsyntaxhighlight>
 
{{out|Result}}
Line 261 ⟶ 340:
3 1.7321
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}}==
<langsyntaxhighlight lang="lisp">(with-open-file (stream (make-pathname :name "filename") :direction :output)
(let* ((x (make-array 4 :initial-contents '(1 2 3 1e11)))
(y (map 'vector 'sqrt x))
Line 271 ⟶ 403:
(fmt (format nil "~~,1,~d,,G~~12t~~,~dG~~%" xprecision yprecision)))
(map nil (lambda (a b)
(format stream fmt a b)) x y)))</langsyntaxhighlight>
Using [[CLISP]] I get
1. 1.0000
Line 279 ⟶ 411:
 
=={{header|D}}==
<langsyntaxhighlight lang="d">import std.file, std.conv, std.string;
 
void main() {
Line 294 ⟶ 426:
 
write("float_array.txt", tmp);
}</langsyntaxhighlight>
{{out}}
<pre>1 1
Line 300 ⟶ 432:
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}}==
<langsyntaxhighlight lang="elixir">defmodule Write_float_arrays do
def task(xs, ys, fname, precision\\[]) do
xprecision = Keyword.get(precision, :x, 2)
Line 323 ⟶ 499:
precision = [x: 3, y: 5]
Write_float_arrays.task(x, y, fname, precision)
IO.puts File.read!(fname)</langsyntaxhighlight>
 
{{out}}
Line 341 ⟶ 517:
Erlang thinks 1 is an integer. To persuade it otherwise I have to use 1.0.
 
<syntaxhighlight lang="erlang">
<lang Erlang>
-module( write_float_arrays ).
 
Line 364 ⟶ 540:
[ok = io:fwrite( IO, Format, [X, Y]) || {X, Y} <- lists:zip( Xs, Ys)],
file:close( IO ).
</syntaxhighlight>
</lang>
 
{{out}}
Line 373 ⟶ 549:
 
=={{header|Euphoria}}==
<langsyntaxhighlight lang="euphoria">constant x = {1, 2, 3, 1e11},
y = {1, 1.4142135623730951, 1.7320508075688772, 316227.76601683791}
 
Line 382 ⟶ 558:
printf(fn,"%.3g\t%.5g\n",{x[n],y[n]})
end for
close(fn)</langsyntaxhighlight>
 
=={{header|F Sharp|F#}}==
<langsyntaxhighlight lang="fsharp">[<EntryPoint>]
let main argv =
let x = [ 1.; 2.; 3.; 1e11 ]
Line 396 ⟶ 572:
let line = sprintf "%.*g\t%.*g"
List.iter2 (fun x y -> file.WriteLine (line xprecision x yprecision y)) x y
0</langsyntaxhighlight>
Content of File, visualized with TAB=8
<pre>1 1
Line 406 ⟶ 582:
{{works with|GNU Forth}}
 
<langsyntaxhighlight lang="forth">create x 1e f, 2e f, 3e f, 1e11 f,
create y 1e f, 2e fsqrt f, 3e fsqrt f, 1e11 fsqrt f,
 
Line 420 ⟶ 596:
 
outfile-id stdout to outfile-id
close-file throw ;</langsyntaxhighlight>
 
=={{header|Fortran}}==
=== Fortran 90 ===
In ANSI FORTRAN 77 or later use OPEN STATEMENT, and formatted WRITE statement with implied DO loop:
<lang fortran> real x(4), y(4)
data x / 1.0, 2.0, 4.0, 1.0e11 /
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</lang>
 
{{works with|Fortran|90 and later}}
<langsyntaxhighlight lang="fortran">program writefloats
implicit none
 
Line 461 ⟶ 626:
end subroutine writexy
 
end program writefloats</langsyntaxhighlight>
 
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}}==
<langsyntaxhighlight lang="freebasic">' FB 1.05.0 Win64
 
Dim x(0 To 3) As Double = {1, 2, 3, 1e11}
Line 478 ⟶ 657:
Print #1, Using "#^^^^"; x(3);
Print #1, Spc(2); Using "##.####^^^^"; y(3)
Close #1</langsyntaxhighlight>
Contents of output.txt :
{{out}}
Line 487 ⟶ 666:
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}}==
<langsyntaxhighlight lang="go">package main
 
import (
Line 518 ⟶ 740:
}
f.Close()
}</langsyntaxhighlight>
File contents:
<pre>
Line 529 ⟶ 751:
=={{header|Haskell}}==
Probably not very idiomatic but oh well
<langsyntaxhighlight lang="haskell">import System.IO
import Text.Printf
import Control.Monad
Line 537 ⟶ 759:
-- 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 $ "%." ++ show xprec ++ "g\t%." ++ show yprec ++ "g\n" in
zipWithM_ writeLine x y</langsyntaxhighlight>
Example usage
Prelude> let x = [1, 2, 3, 1e11]
Line 551 ⟶ 773:
 
Alternative solution without Printf
<langsyntaxhighlight lang="haskell">import System.IO
import Control.Monad
import Numeric
Line 558 ⟶ 780:
withFile filename WriteMode $ \h ->
let writeLine a b = hPutStrLn h $ showGFloat (Just xprec) a "" ++ "\t" ++ showGFloat (Just yprec) b "" in
zipWithM_ writeLine x y</langsyntaxhighlight>
 
=={{header|HicEst}}==
<langsyntaxhighlight HicEstlang="hicest">REAL :: n=4, x(n), y(n)
CHARACTER :: outP = "Test.txt"
 
Line 569 ⟶ 791:
DO i = 1, n
WRITE(FIle=outP, Format='F5, F10.3') x(i), y(i)
ENDDO </langsyntaxhighlight>
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:
<langsyntaxhighlight HicEstlang="hicest">DLG(Text=x, Format='i12', Edit=y, Format='F10.2', Y=0)</langsyntaxhighlight>
 
=={{header|Icon}} and {{header|Unicon}}==
Line 578 ⟶ 800:
The following works in both languages.
 
<langsyntaxhighlight lang="unicon">link printf
 
procedure main()
Line 584 ⟶ 806:
every put(y := [], sqrt(!x))
every fprintf(open("filename","w"),"%10.2e %10.4e\n", x[i := 1 to *x], y[i])
end</langsyntaxhighlight>
 
Contents of <tt>filename</tt> after running:
Line 615 ⟶ 837:
The file <tt>"datafile.txt"</tt> then contains the following:
 
<langsyntaxhighlight lang="idl">1 1
2 1.4142
3 1.7321
1E+011 3.1623E+005</langsyntaxhighlight>
 
This is fairly ugly and un-IDLish.
Line 628 ⟶ 850:
 
=={{header|J}}==
<langsyntaxhighlight lang="j">require 'files' NB. for fwrites
 
x =. 1 2 3 1e11
Line 640 ⟶ 862:
data =. (0 j. xprecision,yprecision) ": x,.y
 
data fwrites filename</langsyntaxhighlight>
 
Or, more concisely:
 
<langsyntaxhighlight lang="j">((0 j. 3 5) ": (,.%:) 1 2 3 1e11) fwrites 'whatever.txt' [ require 'fwrites'</langsyntaxhighlight>
 
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).
Line 650 ⟶ 872:
Note that J's idea of precision here is "positions after the decimal point":
 
<langsyntaxhighlight 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</langsyntaxhighlight>
 
=={{header|Java}}==
<langsyntaxhighlight lang="java5">import java.io.*;
 
public class FloatArray {
Line 689 ⟶ 911:
} catch (IOException e) { }
}
}</langsyntaxhighlight>
 
=={{header|Joy}}==
<syntaxhighlight lang="joy">
<lang Joy>
DEFINE write-floats ==
['g 0] [formatf] enconcat map rollup
Line 699 ⟶ 921:
[[fputchars] 9 fputch] step 10 fputch] step
fclose.
</syntaxhighlight>
</lang>
 
Using it:
Line 711 ⟶ 933:
=={{header|jq}}==
''' Program''':
<langsyntaxhighlight lang="jq">[1, 2, 3, 1e11] as $x
| $x | map(sqrt) as $y
| range(0; $x|length) as $i
| "\($x[$i]) \($y[$i])"</langsyntaxhighlight>
''' Execution''':
To write the output to "filename":
<langsyntaxhighlight lang="sh">$ jq -n -r -f Write_float_arrays_to_a_text_file.jq > filename</langsyntaxhighlight>
 
=={{header|Julia}}==
<langsyntaxhighlight 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')</langsyntaxhighlight>
 
=={{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}}==
<langsyntaxhighlight lang="lingo">on saveFloatLists (filename, x, y, xprecision, yprecision)
eol = numtochar(10) -- LF
fp = xtra("fileIO").new()
Line 741 ⟶ 991:
end repeat
fp.closeFile()
end</langsyntaxhighlight>
 
<langsyntaxhighlight lang="lingo">x = [1.0, PI, sqrt(2)]
y = [2.0, log(10), sqrt(3)]
saveFloatLists("floats.txt", x, y, 3, 5)</langsyntaxhighlight>
 
=={{header|Lua}}==
<langsyntaxhighlight lang="lua">filename = "file.txt"
 
x = { 1, 2, 3, 1e11 }
Line 763 ⟶ 1,013:
end
 
io.close( fp )</langsyntaxhighlight>
 
=={{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="mathematica">exportPrec[path_, data1_, data2_, prec1_, prec2_] :=Export[path,Transpose[{Map[ToString[NumberForm[#, prec2]] &, data2],Map[ToString[NumberForm[#, prec1]] &, data1]}], "Table"]</lang>
Export[
path,
Transpose[{Map[ToString[NumberForm[#, prec2]] &, data2], Map[ToString[NumberForm[#, prec1]] &, data1]}],
"Table"
]</syntaxhighlight>
 
=={{header|MATLAB}} / {{header|Octave}}==
 
<langsyntaxhighlight Matlablang="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); </langsyntaxhighlight>
 
{{out}}
Line 784 ⟶ 1,070:
 
=={{header|Mercury}}==
<langsyntaxhighlight Mercurylang="mercury">:- module write_float_arrays.
:- interface.
 
Line 812 ⟶ 1,098:
 
write_dat(File, XPrec, YPrec, X, Y, !IO) :-
io.format(File, "%.*g\t%.*g\n", [i(XPrec), f(X), i(YPrec), f(Y)], !IO).</langsyntaxhighlight>
 
File contents:
Line 824 ⟶ 1,110:
 
=={{header|NetRexx}}==
<langsyntaxhighlight NetRexxlang="netrexx">/* NetRexx */
 
options replace format comments java crossref savelog symbols nobinary
Line 840 ⟶ 1,126:
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
Line 859 ⟶ 1,145:
 
return
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 869 ⟶ 1,155:
 
=={{header|NewLISP}}==
<langsyntaxhighlight NewLISPlang="newlisp">; file: write-float-array.lsp
; url: http://rosettacode.org/wiki/Write_float_arrays_to_a_text_file
; author: oofoe 2012-01-30
Line 894 ⟶ 1,180:
(print (read-file "filename.chan"))
 
(exit)</langsyntaxhighlight>
 
{{out}}
Line 905 ⟶ 1,191:
 
=={{header|Nim}}==
<langsyntaxhighlight lang="nim">import strutils, math, sequtils
 
const OutFileName = "floatarr2file.txt"
const
outFileName = "floatarr2file.txt"
proc sqrt*(x: int64): float {.importc: "sqrt", header: "<math.h>".}
 
const
xprecisionXPrecision = 3
yprecisionYprecision = 5
 
varlet a: seq[int64] = @[int64(1).0, 2.0, 3.0, 100_000_000_000.0]
varlet b: seq[float] = @[sqrt(a[0]), sqrt(a[1]), sqrt(a[2]), sqrt(a[3])]
var cres = zip(a,b)""
for t in zip(a, b):
var res: string = ""
res.add formatFloat(t[0], ffDefault, Xprecision) & " " &
for t in c:
res.add($formatFloat(float(t.a),ffDefault,xprecision) & "\t" & $ formatFloat(t.b[1], ffDefault,yprecision Yprecision) & "\n")
 
OutFileName.writeFile(outFileName, res)
var res2 = OutFileName.readFile(outFileName)
echo( res2)</langsyntaxhighlight>
{{out}}
<pre>1.00 1.0000
2.00 1.4142
3.00 1.7321
1.00e+11 3.1623e+05</pre>
 
=={{header|OCaml}}==
<langsyntaxhighlight lang="ocaml">let write_dat filename x y ?(xprec=3) ?(yprec=5) () =
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</langsyntaxhighlight>
Example usage
# let x = [1.0; 2.0; 3.0; 1e11];;
Line 961 ⟶ 1,244:
=={{header|PARI/GP}}==
{{works with|PARI/GP|2.5.0 and above}}
<langsyntaxhighlight lang="parigp">f(x,pr)={
Strprintf(if(x>=10^pr,
Str("%.",pr-1,"e")
Line 972 ⟶ 1,255:
write("filename",f(x[i],xprec),"\t",f(y[i],yprec))
)
};</langsyntaxhighlight>
 
=={{header|Pascal}}==
<langsyntaxhighlight lang="pascal">Program WriteNumbers;
 
const
Line 993 ⟶ 1,276:
writeln (filename, x[i]:baseDigits+xprecision, sqrt(x[i]):baseDigits+yprecision);
close (filename);
end.</langsyntaxhighlight>
File contents
<pre>
Line 1,003 ⟶ 1,286:
 
=={{header|Perl}}==
<langsyntaxhighlight lang="perl">use autodie;
 
sub writedat {
Line 1,020 ⟶ 1,303:
my @y = map sqrt, @x;
 
writedat("sqrt.dat", \@x, \@y);</langsyntaxhighlight>
File contents
<pre>
Line 1,031 ⟶ 1,314:
Alternatively, with the CPAN List::MoreUtils package:
 
<langsyntaxhighlight lang="perl">use autodie;
use List::MoreUtils qw(each_array);
 
Line 1,049 ⟶ 1,332:
my @y = map sqrt, @x;
 
writedat("sqrt.dat", \@x, \@y);</langsyntaxhighlight>
 
=={{header|Perl 6}}==
{{trans|Perl}}
<lang perl6>sub writedat ( $filename, @x, @y, $x_precision = 3, $y_precision = 5 ) {
my $fh = open $filename, :w;
 
for @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});
 
writedat( 'sqrt.dat', @x, @y );</lang>
File contents
<pre>1 1
2 1.4142
3 1.7321
1e+11 3.1623e+05</pre>
 
In Perl 6 Real::base can be used to convert to Str with arbitrary precision and any base you like. Using the hyper-operator >>. let us strip loops, many temporary variables and is a candidate for autothreading.
 
<lang perl6>sub writefloat($filename, @x, @y, :$x-precision = 3, :$y-precision = 5) {
constant TAB = "\t" xx *;
constant NL = "\n" xx *;
 
open($filename, :w).print(
flat @x>>.base(10, $x-precision) Z TAB Z @y>>.base(10, $y-precision) Z NL);
}
my @x = 1, 2, 3, 1e11;
writefloat('sqrt.dat', @x, @x>>.sqrt, :y-precision(20));</lang>
 
File contents
<pre>1.000 1.00000000000000000000
2.000 1.41421356237309510107
3.000 1.73205080756887719318
100000000000.000 316227.76601683790795505047</pre>
 
=={{header|Phix}}==
Copy of [[Write_float_arrays_to_a_text_file#Euphoria|Euphoria]]
<!--<syntaxhighlight lang="phix">-->
<lang Phix>constant x = {1, 2, 3, 1e11},
<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>
y = {1, 1.4142135623730951, 1.7320508075688772, 316227.76601683791}
<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>
integer fn = open("filename","w")
<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>
for i=1 to length(x) do
<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>
printf(fn,"%.3g\t%.5g\n",{x[i],y[i]})
<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>
end for
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
close(fn)</lang>
<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>
Line 1,111 ⟶ 1,356:
=={{header|PicoLisp}}==
An exponential format like "1e11" is not supported
<langsyntaxhighlight PicoLisplang="picolisp">(setq *Xprecision 3 *Yprecision 5)
 
(scl 7)
Line 1,121 ⟶ 1,366:
(round Y *Yprecision) ) )
(1.0 2.0 3.0)
(1.0 1.414213562 1.732050807) )</langsyntaxhighlight>
{{out}}
<pre>1.000 1.00000
Line 1,128 ⟶ 1,373:
 
=={{header|PL/I}}==
<langsyntaxhighlight PLlang="pl/Ii">*Process source attributes xref;
aaa: Proc Options(main);
declare X(5) float (9) initial (1, 2, 3, 4, 5),
Line 1,140 ⟶ 1,385:
(skip,e(19,x_precision),
x(2),e(24,y_precision));
end;</langsyntaxhighlight>
{{out}}
<pre> 1.000000000E+0000 9.0000000000000000E+0000
Line 1,149 ⟶ 1,394:
 
=={{header|PowerShell}}==
<syntaxhighlight lang="powershell">$x = @(1, 2, 3, 1e11)
<lang PowerShell>
$x = @(1, 2, 3, 1e11)
$y = @(1, 1.4142135623730951, 1.7320508075688772, 316227.76601683791)
$xprecision = 3
Line 1,157 ⟶ 1,401:
[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>
</lang>
<b>Output:</b>
<pre>
Line 1,168 ⟶ 1,412:
 
=={{header|PureBasic}}==
<langsyntaxhighlight PureBasiclang="purebasic">#Size = 4
 
DataSection
Line 1,195 ⟶ 1,439:
CloseFile(fileID)
EndIf
EndIf</langsyntaxhighlight>
{{out}} to text file:
<pre>1.000 1.00000
Line 1,204 ⟶ 1,448:
=={{header|Python}}==
{{works with|Python|2.6}}
<langsyntaxhighlight lang="python">import itertools
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)</langsyntaxhighlight>
Example usage
<langsyntaxhighlight lang="python">>>> import math
>>> x = [1, 2, 3, 1e11]
>>> y = map(math.sqrt, x)
Line 1,224 ⟶ 1,468:
2 1.4142
3 1.7321
1e+011 3.1623e+005</langsyntaxhighlight>
 
{{works with|Python|3}}
<langsyntaxhighlight lang="python">def writedat(filename, x, y, xprecision=3, yprecision=5):
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)</langsyntaxhighlight>
 
=={{header|R}}==
<langsyntaxhighlight Rlang="r">writexy <- function(file, x, y, xprecision=3, yprecision=3) {
fx <- formatC(x, digits=xprecision, format="g", flag="-")
{
fy <- formatC(y, digits=yprecision, format="g", flag="-")
#Format inputs as required, and join together
dfr <- data.frame(fx, fy)
fx <- formatC(x, digits=xprecision, format="g", flag="-")
write.table(dfr, file=file, sep="\t", row.names=F, col.names=F, quote=F)
fy <- formatC(y, digits=yprecision, format="g", flag="-")
dfr <- data.frame(fx, fy)
#Write to file. Note that this encloses the formatted number in quotes,
write.table(dfr, file=file, sep="\t", row.names=FALSE)
#... so we have to process the output
str <- readLines(file)
writeLines(gsub('"', '', str), file)
}
 
 
x <- c(1, 2, 3, 1e11)
y <- sqrt(x)
writexy('"test.txt'", x, y, yp=5)</langsyntaxhighlight>
 
=={{header|Racket}}==
<syntaxhighlight lang="racket">
<lang Racket>
#lang racket
 
Line 1,278 ⟶ 1,515:
100000000000 316227.76602
|#
</syntaxhighlight>
</lang>
 
=={{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}}==
<langsyntaxhighlight Ravenlang="raven">3 as $xprecision
5 as $yprecision
 
Line 1,300 ⟶ 1,572:
4 each as $i
$f $b $i get $a $i get print2
$results "" join "results.dat" write</langsyntaxhighlight>
{{out}}
results.dat file contains:
Line 1,309 ⟶ 1,581:
 
=={{header|REXX}}==
<langsyntaxhighlight 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.*/
Line 1,335 ⟶ 1,607:
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.*/</langsyntaxhighlight>
'''output''' &nbsp; when using the default (internal) data:
<pre>
Line 1,342 ⟶ 1,614:
3 1.7321
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>
 
Line 1,349 ⟶ 1,653:
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">
<lang RLaB>
>> x = rand(10,1); y = rand(10,1);
>> writem("mytextfile.txt", [x,y]);
</syntaxhighlight>
</lang>
 
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">
<lang RLaB>
>> x = rand(10,1); y = rand(10,1);
>> s = text( [x,y], "%10.8f" );
>> writem("mytextfile.txt", s);
</syntaxhighlight>
</lang>
 
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''.
Line 1,369 ⟶ 1,673:
 
=={{header|Ruby}}==
<langsyntaxhighlight lang="ruby"># prepare test data
x = [1, 2, 3, 1e11]
y = x.collect { |xx| Math.sqrt xx }
Line 1,381 ⟶ 1,685:
 
# print the result file
open('sqrt.dat', 'r') { |f| puts f.read }</langsyntaxhighlight>
Result:
<pre>1 1
Line 1,389 ⟶ 1,693:
 
=={{header|Run BASIC}}==
<langsyntaxhighlight lang="runbasic">x$ = "1, 2, 3, 1e11"
y$ = "1, 1.4142135623730951, 1.7320508075688772, 316227.76601683791"
 
Line 1,396 ⟶ 1,700:
print #f, using("##############.###",val(word$(x$,i,",")));"|";using("#######.#####",val(word$(y$,i,",")))
next i
close #f</langsyntaxhighlight>
{{out}}
<pre> 1.000| 1.00000
Line 1,404 ⟶ 1,708:
 
=={{header|SAS}}==
<langsyntaxhighlight lang="sas">data _null_;
input x y;
file "output.txt";
Line 1,414 ⟶ 1,718:
1e11 316227.76601683791
;
run;</langsyntaxhighlight>
 
=={{header|Scala}}==
{{libheader|Scala}}<langsyntaxhighlight lang="scala">import java.io.{File, FileWriter, IOException}
 
object FloatArray extends App {
Line 1,434 ⟶ 1,738:
case e: IOException => println(s"Running Example failed: ${e.getMessage}")
}
}</langsyntaxhighlight>
 
=={{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.<langsyntaxhighlight lang="seed7">$ include "seed7_05.s7i";
include "float.s7i";
include "math.s7i";
Line 1,452 ⟶ 1,756:
end for;
close(aFile);
end func;</langsyntaxhighlight>{{out|Result file ''filename''}}
1.000e+00 1.00000e+00
2.000e+00 1.41421e+00
Line 1,459 ⟶ 1,763:
 
=={{header|Sidef}}==
{{trans|Perl 6Raku}}
<langsyntaxhighlight lang="ruby">func writedat(filename, x, y, x_precision=3, y_precision=5) {
var fh = File.new(filename).open_w;
 
 
MultiArray.newfor a,b in (x, ~Z y).each { |x, y|
fh.printf("%.*g\t%.*g\n", x_precision, xa, y_precision, yb);
}
 
 
fh.close;
}
 
 
var x = [1, 2, 3, 1e11];
var y = x».map{.sqrt»();}
 
 
writedat('sqrt.dat', x, y);</langsyntaxhighlight>
{{out}}
<pre>
Line 1,481 ⟶ 1,785:
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}}==
<langsyntaxhighlight lang="sml">fun writeDat (filename, x, y, xprec, yprec) = let
val os = TextIO.openOut filename
fun write_line (a, b) =
Line 1,491 ⟶ 1,820:
ListPair.appEq write_line (x, y);
TextIO.closeOut os
end;</langsyntaxhighlight>
Example usage
- val x = [1.0, 2.0, 3.0, 1e11];
Line 1,507 ⟶ 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}}==
<langsyntaxhighlight lang="tcl">set x {1 2 3 1e11}
foreach a $x {lappend y [expr {sqrt($a)}]}
set fh [open sqrt.dat w]
Line 1,519 ⟶ 1,869:
set fh [open sqrt.dat]
puts [read $fh [file size sqrt.dat]]
close $fh</langsyntaxhighlight>
{{out}}
<pre>1 1
Line 1,525 ⟶ 1,875:
3 1.7321
1e+011 3.1623e+005</pre>
 
=={{header|VBA}}==
<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}}==
<langsyntaxhighlight 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
Line 1,536 ⟶ 2,002:
xs,ys := T(1.0, 2.0, 3.0, 1e11), xs.apply("sqrt");
xprecision,yprecision := 3,5;
writeFloatArraysToFile("floatArray.txt", xs,xprecision, ys,yprecision);</langsyntaxhighlight>
Note that closing the file is redundant as the garbage collector will also do that, which means you could write the function as:
<lang zkl>fcn writeFloatArraysToFile2(filename, xs,xprecision, ys,yprecision){
fmt:="%%.%dg\t%%.%dg".fmt(xprecision,yprecision).fmt; // "%.3g\t%.5g".fmt
xs.zip(ys).pump(File(filename,"w").writeln, Void.Xplode, fmt);
}</lang>
 
{{out}}
<pre>
Line 1,559 ⟶ 2,019:
Here we write the contents of the array g() to a file:
 
<langsyntaxhighlight lang="zxbasic">SAVE "myarray" DATA g()</langsyntaxhighlight>
PureFox
9,476

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/53020...348752"