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) |
|||
(18 intermediate revisions by 16 users not shown) | |||
Line 29:
=={{header|Ada}}==
<
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;</
=={{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}}
<
FILE f;
INT errno = open(f, filename, stand out channel);
Line 99:
print((line,new line))
OD
)</
{{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:
<
> 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</
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}}
<
x() = 1, 2, 3, 1E11
FOR i% = 0 TO 3
Line 144 ⟶ 224:
NEXT
CLOSE #outfile%</
{{out}}
<pre>
Line 154 ⟶ 234:
=={{header|C}}==
<
#include <math.h>
Line 171 ⟶ 251:
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</
=={{header|C sharp|C#}}==
<
class Program
Line 198 ⟶ 278:
outf.WriteLine(formatString, x[i], y[i]);
}
}</
{{out}}
Line 208 ⟶ 288:
=={{header|C++}}==
Function ''writedat()'':
<
void writedat(const char* filename,
InputIterator xbegin, InputIterator xend,
Line 220 ⟶ 300:
f << std::setprecision(xprecision) << *xbegin << '\t'
<< std::setprecision(yprecision) << *ybegin << '\n';
}</
Example:
<
#include <cmath> // ::sqrt()
#include <fstream>
Line 252 ⟶ 332:
}
return 0;
}</
{{out|Result}}
Line 263 ⟶ 343:
=={{header|COBOL}}==
<syntaxhighlight lang="cobol">
identification division.
program-id. wr-float.
Line 306 ⟶ 386:
.
end program wr-float.
</syntaxhighlight>
{{out|Result}}
<pre>
Line 316 ⟶ 396:
=={{header|Common Lisp}}==
<
(let* ((x (make-array 4 :initial-contents '(1 2 3 1e11)))
(y (map 'vector 'sqrt x))
Line 323 ⟶ 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 331 ⟶ 411:
=={{header|D}}==
<
void main() {
Line 346 ⟶ 426:
write("float_array.txt", tmp);
}</
{{out}}
<pre>1 1
Line 352 ⟶ 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}}==
<
def task(xs, ys, fname, precision\\[]) do
xprecision = Keyword.get(precision, :x, 2)
Line 375 ⟶ 499:
precision = [x: 3, y: 5]
Write_float_arrays.task(x, y, fname, precision)
IO.puts File.read!(fname)</
{{out}}
Line 393 ⟶ 517:
Erlang thinks 1 is an integer. To persuade it otherwise I have to use 1.0.
<syntaxhighlight lang="erlang">
-module( write_float_arrays ).
Line 416 ⟶ 540:
[ok = io:fwrite( IO, Format, [X, Y]) || {X, Y} <- lists:zip( Xs, Ys)],
file:close( IO ).
</syntaxhighlight>
{{out}}
Line 425 ⟶ 549:
=={{header|Euphoria}}==
<
y = {1, 1.4142135623730951, 1.7320508075688772, 316227.76601683791}
Line 434 ⟶ 558:
printf(fn,"%.3g\t%.5g\n",{x[n],y[n]})
end for
close(fn)</
=={{header|F Sharp|F#}}==
<
let main argv =
let x = [ 1.; 2.; 3.; 1e11 ]
Line 448 ⟶ 572:
let line = sprintf "%.*g\t%.*g"
List.iter2 (fun x y -> file.WriteLine (line xprecision x yprecision y)) x y
0</
Content of File, visualized with TAB=8
<pre>1 1
Line 458 ⟶ 582:
{{works with|GNU Forth}}
<
create y 1e f, 2e fsqrt f, 3e fsqrt f, 1e11 fsqrt f,
Line 472 ⟶ 596:
outfile-id stdout to outfile-id
close-file throw ;</
=={{header|Fortran}}==
=== Fortran 90 ===
{{works with|Fortran|90 and later}}
<
implicit none
Line 502 ⟶ 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 ===
<
integer i
double precision x(4), y(4)
Line 518 ⟶ 642:
open(unit=15, file='two_cols.txt', status='new')
write(15, '(f20.3,f21.4)') (x(i), y(i), i = 1, 4)
end</
=={{header|FreeBASIC}}==
<
Dim x(0 To 3) As Double = {1, 2, 3, 1e11}
Line 533 ⟶ 657:
Print #1, Using "#^^^^"; x(3);
Print #1, Spc(2); Using "##.####^^^^"; y(3)
Close #1</
Contents of output.txt :
{{out}}
Line 542 ⟶ 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}}==
<
import (
Line 573 ⟶ 740:
}
f.Close()
}</
File contents:
<pre>
Line 584 ⟶ 751:
=={{header|Haskell}}==
Probably not very idiomatic but oh well
<
import Text.Printf
import Control.Monad
Line 592 ⟶ 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</
Example usage
Prelude> let x = [1, 2, 3, 1e11]
Line 606 ⟶ 773:
Alternative solution without Printf
<
import Control.Monad
import Numeric
Line 613 ⟶ 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</
=={{header|HicEst}}==
<
CHARACTER :: outP = "Test.txt"
Line 624 ⟶ 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:
<
=={{header|Icon}} and {{header|Unicon}}==
Line 633 ⟶ 800:
The following works in both languages.
<
procedure main()
Line 639 ⟶ 806:
every put(y := [], sqrt(!x))
every fprintf(open("filename","w"),"%10.2e %10.4e\n", x[i := 1 to *x], y[i])
end</
Contents of <tt>filename</tt> after running:
Line 670 ⟶ 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.
Line 683 ⟶ 850:
=={{header|J}}==
<
x =. 1 2 3 1e11
Line 695 ⟶ 862:
data =. (0 j. xprecision,yprecision) ": x,.y
data fwrites filename</
Or, more concisely:
<
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 705 ⟶ 872:
Note that J's idea of precision here is "positions after the decimal point":
<
1.000 1.00000
2.000 1.41421
3.000 1.73205
100000000000.000 316227.76602</
=={{header|Java}}==
<
public class FloatArray {
Line 744 ⟶ 911:
} catch (IOException e) { }
}
}</
=={{header|Joy}}==
<syntaxhighlight lang="joy">
DEFINE write-floats ==
['g 0] [formatf] enconcat map rollup
Line 754 ⟶ 921:
[[fputchars] 9 fputch] step 10 fputch] step
fclose.
</syntaxhighlight>
Using it:
Line 766 ⟶ 933:
=={{header|jq}}==
''' Program''':
<
| $x | map(sqrt) as $y
| range(0; $x|length) as $i
| "\($x[$i]) \($y[$i])"</
''' Execution''':
To write the output to "filename":
<
=={{header|Julia}}==
<
yprecision = 5
x = round.([1, 2, 3, 1e11],xprecision)
y = round.([1, 1.4142135623730951, 1.7320508075688772, 316227.76601683791],yprecision)
writedlm("filename", [x y], '\t')</
=={{header|Kotlin}}==
<
import java.io.File
Line 799 ⟶ 966:
}
}
}</
Contents of 'output.txt':
Line 810 ⟶ 977:
=={{header|Lingo}}==
<
eol = numtochar(10) -- LF
fp = xtra("fileIO").new()
Line 824 ⟶ 991:
end repeat
fp.closeFile()
end</
<
y = [2.0, log(10), sqrt(3)]
saveFloatLists("floats.txt", x, y, 3, 5)</
=={{header|Lua}}==
<
x = { 1, 2, 3, 1e11 }
Line 846 ⟶ 1,013:
end
io.close( fp )</
=={{header|
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}}==
<
y = [1, 1.4142135623730951, 1.7320508075688772, 316227.76601683791];
fid = fopen('filename','w')
fprintf(fid,'%.3g\t%.5g\n',[x;y]);
fclose(fid); </
{{out}}
Line 867 ⟶ 1,070:
=={{header|Mercury}}==
<
:- interface.
Line 895 ⟶ 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).</
File contents:
Line 907 ⟶ 1,110:
=={{header|NetRexx}}==
<
options replace format comments java crossref savelog symbols nobinary
Line 923 ⟶ 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 942 ⟶ 1,145:
return
</syntaxhighlight>
{{out}}
<pre>
Line 952 ⟶ 1,155:
=={{header|NewLISP}}==
<
; url: http://rosettacode.org/wiki/Write_float_arrays_to_a_text_file
; author: oofoe 2012-01-30
Line 977 ⟶ 1,180:
(print (read-file "filename.chan"))
(exit)</
{{out}}
Line 988 ⟶ 1,191:
=={{header|Nim}}==
<
const OutFileName = "floatarr2file.txt"
const
var
for t in zip(a, b):
res.add formatFloat(t[0], ffDefault, Xprecision) & " " &
OutFileName.writeFile
var res2 = OutFileName.readFile(
echo
{{out}}
<pre>1.00
2.00
3.00
1.00e+11
=={{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 1,042 ⟶ 1,244:
=={{header|PARI/GP}}==
{{works with|PARI/GP|2.5.0 and above}}
<
Strprintf(if(x>=10^pr,
Str("%.",pr-1,"e")
Line 1,053 ⟶ 1,255:
write("filename",f(x[i],xprec),"\t",f(y[i],yprec))
)
};</
=={{header|Pascal}}==
<
const
Line 1,074 ⟶ 1,276:
writeln (filename, x[i]:baseDigits+xprecision, sqrt(x[i]):baseDigits+yprecision);
close (filename);
end.</
File contents
<pre>
Line 1,084 ⟶ 1,286:
=={{header|Perl}}==
<
sub writedat {
Line 1,101 ⟶ 1,303:
my @y = map sqrt, @x;
writedat("sqrt.dat", \@x, \@y);</
File contents
<pre>
Line 1,112 ⟶ 1,314:
Alternatively, with the CPAN List::MoreUtils package:
<
use List::MoreUtils qw(each_array);
Line 1,130 ⟶ 1,332:
my @y = map sqrt, @x;
writedat("sqrt.dat", \@x, \@y);</
=={{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>
Line 1,152 ⟶ 1,356:
=={{header|PicoLisp}}==
An exponential format like "1e11" is not supported
<
(scl 7)
Line 1,162 ⟶ 1,366:
(round Y *Yprecision) ) )
(1.0 2.0 3.0)
(1.0 1.414213562 1.732050807) )</
{{out}}
<pre>1.000 1.00000
Line 1,169 ⟶ 1,373:
=={{header|PL/I}}==
<
aaa: Proc Options(main);
declare X(5) float (9) initial (1, 2, 3, 4, 5),
Line 1,181 ⟶ 1,385:
(skip,e(19,x_precision),
x(2),e(24,y_precision));
end;</
{{out}}
<pre> 1.000000000E+0000 9.0000000000000000E+0000
Line 1,190 ⟶ 1,394:
=={{header|PowerShell}}==
<
$y = @(1, 1.4142135623730951, 1.7320508075688772, 316227.76601683791)
$xprecision = 3
Line 1,198 ⟶ 1,402:
}
($arr | format-table -HideTableHeaders | Out-String).Trim() > filename.txt
</syntaxhighlight>
<b>Output:</b>
<pre>
Line 1,208 ⟶ 1,412:
=={{header|PureBasic}}==
<
DataSection
Line 1,235 ⟶ 1,439:
CloseFile(fileID)
EndIf
EndIf</
{{out}} to text file:
<pre>1.000 1.00000
Line 1,244 ⟶ 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 1,264 ⟶ 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="-")
Line 1,284 ⟶ 1,488:
x <- c(1, 2, 3, 1e11)
y <- sqrt(x)
writexy("test.txt", x, y, yp=5)</
=={{header|Racket}}==
<syntaxhighlight lang="racket">
#lang racket
Line 1,311 ⟶ 1,515:
100000000000 316227.76602
|#
</syntaxhighlight>
=={{header|Raku}}==
Line 1,317 ⟶ 1,521:
===Perl 5-ish===
Written in the style of the 2nd Perl 5 example.
<syntaxhighlight lang="raku"
my $fh = open $filename, :w;
for flat @x Z @y -> $x, $y {
Line 1,328 ⟶ 1,532:
my @y = @x.map({.sqrt});
writefloat( 'sqrt.dat', @x, @y );</
{{out}}
<pre>1 1
Line 1,336 ⟶ 1,540:
===Idiomatic===
Written in a more idiomatic style.
<syntaxhighlight lang="raku"
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));</
{{out}}
<pre>1 1
Line 1,349 ⟶ 1,553:
=={{header|Raven}}==
<
5 as $yprecision
Line 1,368 ⟶ 1,572:
4 each as $i
$f $b $i get $a $i get print2
$results "" join "results.dat" write</
{{out}}
results.dat file contains:
Line 1,377 ⟶ 1,581:
=={{header|REXX}}==
<
numeric digits 1000 /*allow use of a huge number of digits.*/
oFID= 'filename' /*name of the output File IDentifier.*/
Line 1,403 ⟶ 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.*/</
'''output''' when using the default (internal) data:
<pre>
Line 1,413 ⟶ 1,617:
=={{header|Ring}}==
<
# Project : Write float arrays to a text file
Line 1,435 ⟶ 1,639:
end
fclose(fp)
</syntaxhighlight>
Output:
<pre>
Line 1,449 ⟶ 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">
>> 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''.
Line 1,469 ⟶ 1,673:
=={{header|Ruby}}==
<
x = [1, 2, 3, 1e11]
y = x.collect { |xx| Math.sqrt xx }
Line 1,481 ⟶ 1,685:
# print the result file
open('sqrt.dat', 'r') { |f| puts f.read }</
Result:
<pre>1 1
Line 1,489 ⟶ 1,693:
=={{header|Run BASIC}}==
<
y$ = "1, 1.4142135623730951, 1.7320508075688772, 316227.76601683791"
Line 1,496 ⟶ 1,700:
print #f, using("##############.###",val(word$(x$,i,",")));"|";using("#######.#####",val(word$(y$,i,",")))
next i
close #f</
{{out}}
<pre> 1.000| 1.00000
Line 1,504 ⟶ 1,708:
=={{header|SAS}}==
<
input x y;
file "output.txt";
Line 1,514 ⟶ 1,718:
1e11 316227.76601683791
;
run;</
=={{header|Scala}}==
{{libheader|Scala}}<
object FloatArray extends App {
Line 1,534 ⟶ 1,738:
case e: IOException => println(s"Running Example failed: ${e.getMessage}")
}
}</
=={{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.<
include "float.s7i";
include "math.s7i";
Line 1,552 ⟶ 1,756:
end for;
close(aFile);
end func;</
1.000e+00 1.00000e+00
2.000e+00 1.41421e+00
Line 1,560 ⟶ 1,764:
=={{header|Sidef}}==
{{trans|Raku}}
<
var fh = File(filename).open_w
Line 1,573 ⟶ 1,777:
var y = x.map{.sqrt}
writedat('sqrt.dat', x, y)</
{{out}}
<pre>
Line 1,583 ⟶ 1,787:
=={{header|Smalltalk}}==
{{works with | Smalltalk/X}}
<
y := x collect:#sqrt.
xprecision := 3.
Line 1,592 ⟶ 1,796:
'%.*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}}==
<
y = [1, 1.4142135623730951, 1.7320508075688772, 316227.76601683791]
xprecision = 3
Line 1,603 ⟶ 1,809:
s2 = #.str(y[i],"g"+yprecision)
#.writeline("file.txt",s1+#.tab+s2)
<</
=={{header|Standard ML}}==
<
val os = TextIO.openOut filename
fun write_line (a, b) =
Line 1,614 ⟶ 1,820:
ListPair.appEq write_line (x, y);
TextIO.closeOut os
end;</
Example usage
- val x = [1.0, 2.0, 3.0, 1e11];
Line 1,633 ⟶ 1,839:
=={{header|Stata}}==
<
clear
mat x=1\2\3\1e11
Line 1,643 ⟶ 1,849:
* Save as text file
export delim file.txt, delim(" ") novar datafmt replace</
{{out}}
Line 1,653 ⟶ 1,859:
=={{header|Tcl}}==
<
foreach a $x {lappend y [expr {sqrt($a)}]}
set fh [open sqrt.dat w]
Line 1,663 ⟶ 1,869:
set fh [open sqrt.dat]
puts [read $fh [file size sqrt.dat]]
close $fh</
{{out}}
<pre>1 1
Line 1,671 ⟶ 1,877:
=={{header|VBA}}==
<
x = [{1, 2, 3, 1e11}]
y = [{1, 1.4142135623730951, 1.7320508075688772, 316227.76601683791}]
Line 1,681 ⟶ 1,887:
Next i
Close TextFile
End Sub</
<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>
Line 1,693 ⟶ 1,930:
In the final example, we need to force exponential format as numbers of this size would normally be printed in decimal format.
<
import "./fmt" for Fmt
var x = [1, 2, 3, 1e11]
Line 1,706 ⟶ 1,943:
file.writeBytes(s)
}
}</
{{out}}
Line 1,715 ⟶ 1,952:
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}}==
<
pr1 = 3 : pr2 = 5
Line 1,730 ⟶ 1,990:
next i
close #f</
=={{header|zkl}}==
<
f :=File(filename,"w");
fmt:="%%.%dg\t%%.%dg".fmt(xprecision,yprecision).fmt; // "%.3g\t%.5g".fmt
Line 1,742 ⟶ 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);</
{{out}}
<pre>
Line 1,759 ⟶ 2,019:
Here we write the contents of the array g() to a file:
<
|