Write float arrays to a text file: Difference between revisions
m →{{header|Wren}}: Minor tidy |
|||
(16 intermediate revisions by 15 users not shown) | |||
Line 29: | Line 29: | ||
=={{header|Ada}}== |
=={{header|Ada}}== |
||
< |
<syntaxhighlight lang="ada">with Ada.Text_IO; use Ada.Text_IO; |
||
with Ada.Float_Text_IO; use Ada.Float_Text_IO; |
with Ada.Float_Text_IO; use Ada.Float_Text_IO; |
||
with Ada.Numerics.Elementary_Functions; use Ada.Numerics.Elementary_Functions; |
with Ada.Numerics.Elementary_Functions; use Ada.Numerics.Elementary_Functions; |
||
Line 62: | Line 62: | ||
Write_columns (File, X, Y); |
Write_columns (File, X, Y); |
||
Close (File); |
Close (File); |
||
end Write_Float_Array;</ |
end Write_Float_Array;</syntaxhighlight> |
||
=={{header|ALGOL 68}}== |
=={{header|ALGOL 68}}== |
||
Line 69: | 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]}} |
{{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}} |
{{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}} |
||
< |
<syntaxhighlight lang="algol68">PROC writedat = (STRING filename, []REAL x, y, INT x width, y width)VOID: ( |
||
FILE f; |
FILE f; |
||
INT errno = open(f, filename, stand out channel); |
INT errno = open(f, filename, stand out channel); |
||
Line 99: | Line 99: | ||
print((line,new line)) |
print((line,new line)) |
||
OD |
OD |
||
)</ |
)</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
Line 111: | Line 111: | ||
</pre> |
</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}}== |
=={{header|AWK}}== |
||
As usual, the order of array traversal in AWK is not necessarily the same as the input had: |
As usual, the order of array traversal in AWK is not necessarily the same as the input had: |
||
< |
<syntaxhighlight lang="awk">$ awk 'BEGIN{split("1 2 3 1e11",x); |
||
> split("1 1.4142135623730951 1.7320508075688772 316227.76601683791",y); |
> split("1 1.4142135623730951 1.7320508075688772 316227.76601683791",y); |
||
> for(i in x)printf("%6g %.5g\n",x[i],y[i])}' |
> for(i in x)printf("%6g %.5g\n",x[i],y[i])}' |
||
Line 119: | Line 187: | ||
1 1 |
1 1 |
||
2 1.4142 |
2 1.4142 |
||
3 1.7321</ |
3 1.7321</syntaxhighlight> |
||
For the text file part of the task, just redirect stdout to it. |
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}}== |
=={{header|BBC BASIC}}== |
||
{{works with|BBC BASIC for Windows}} |
{{works with|BBC BASIC for Windows}} |
||
< |
<syntaxhighlight lang="bbcbasic"> DIM x(3), y(3) |
||
x() = 1, 2, 3, 1E11 |
x() = 1, 2, 3, 1E11 |
||
FOR i% = 0 TO 3 |
FOR i% = 0 TO 3 |
||
Line 144: | Line 224: | ||
NEXT |
NEXT |
||
CLOSE #outfile%</ |
CLOSE #outfile%</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
Line 154: | Line 234: | ||
=={{header|C}}== |
=={{header|C}}== |
||
< |
<syntaxhighlight lang="c">#include <stdio.h> |
||
#include <math.h> |
#include <math.h> |
||
Line 171: | Line 251: | ||
return 0; |
return 0; |
||
}</ |
}</syntaxhighlight> |
||
The file <tt>"floatArray"</tt> then contains the following: |
The file <tt>"floatArray"</tt> then contains the following: |
||
<lang>1 1 |
<syntaxhighlight lang="text">1 1 |
||
2 1.4142 |
2 1.4142 |
||
3 1.7321 |
3 1.7321 |
||
1e+11 3.1623e+05</ |
1e+11 3.1623e+05</syntaxhighlight> |
||
=={{header|C sharp|C#}}== |
=={{header|C sharp|C#}}== |
||
< |
<syntaxhighlight lang="csharp">using System.IO; |
||
class Program |
class Program |
||
Line 198: | Line 278: | ||
outf.WriteLine(formatString, x[i], y[i]); |
outf.WriteLine(formatString, x[i], y[i]); |
||
} |
} |
||
}</ |
}</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
Line 208: | Line 288: | ||
=={{header|C++}}== |
=={{header|C++}}== |
||
Function ''writedat()'': |
Function ''writedat()'': |
||
< |
<syntaxhighlight lang="cpp">template<class InputIterator, class InputIterator2> |
||
void writedat(const char* filename, |
void writedat(const char* filename, |
||
InputIterator xbegin, InputIterator xend, |
InputIterator xbegin, InputIterator xend, |
||
Line 220: | Line 300: | ||
f << std::setprecision(xprecision) << *xbegin << '\t' |
f << std::setprecision(xprecision) << *xbegin << '\t' |
||
<< std::setprecision(yprecision) << *ybegin << '\n'; |
<< std::setprecision(yprecision) << *ybegin << '\n'; |
||
}</ |
}</syntaxhighlight> |
||
Example: |
Example: |
||
< |
<syntaxhighlight lang="cpp">#include <algorithm> |
||
#include <cmath> // ::sqrt() |
#include <cmath> // ::sqrt() |
||
#include <fstream> |
#include <fstream> |
||
Line 252: | Line 332: | ||
} |
} |
||
return 0; |
return 0; |
||
}</ |
}</syntaxhighlight> |
||
{{out|Result}} |
{{out|Result}} |
||
Line 263: | Line 343: | ||
=={{header|COBOL}}== |
=={{header|COBOL}}== |
||
<syntaxhighlight lang="cobol"> |
|||
<lang COBOL> |
|||
identification division. |
identification division. |
||
program-id. wr-float. |
program-id. wr-float. |
||
Line 306: | Line 386: | ||
. |
. |
||
end program wr-float. |
end program wr-float. |
||
</syntaxhighlight> |
|||
</lang> |
|||
{{out|Result}} |
{{out|Result}} |
||
<pre> |
<pre> |
||
Line 316: | Line 396: | ||
=={{header|Common Lisp}}== |
=={{header|Common Lisp}}== |
||
< |
<syntaxhighlight lang="lisp">(with-open-file (stream (make-pathname :name "filename") :direction :output) |
||
(let* ((x (make-array 4 :initial-contents '(1 2 3 1e11))) |
(let* ((x (make-array 4 :initial-contents '(1 2 3 1e11))) |
||
(y (map 'vector 'sqrt x)) |
(y (map 'vector 'sqrt x)) |
||
Line 323: | Line 403: | ||
(fmt (format nil "~~,1,~d,,G~~12t~~,~dG~~%" xprecision yprecision))) |
(fmt (format nil "~~,1,~d,,G~~12t~~,~dG~~%" xprecision yprecision))) |
||
(map nil (lambda (a b) |
(map nil (lambda (a b) |
||
(format stream fmt a b)) x y)))</ |
(format stream fmt a b)) x y)))</syntaxhighlight> |
||
Using [[CLISP]] I get |
Using [[CLISP]] I get |
||
1. 1.0000 |
1. 1.0000 |
||
Line 331: | Line 411: | ||
=={{header|D}}== |
=={{header|D}}== |
||
< |
<syntaxhighlight lang="d">import std.file, std.conv, std.string; |
||
void main() { |
void main() { |
||
Line 346: | Line 426: | ||
write("float_array.txt", tmp); |
write("float_array.txt", tmp); |
||
}</ |
}</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre>1 1 |
<pre>1 1 |
||
Line 352: | Line 432: | ||
3 1.7321 |
3 1.7321 |
||
1e+11 3.1623e+05</pre> |
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}}== |
=={{header|Elixir}}== |
||
< |
<syntaxhighlight lang="elixir">defmodule Write_float_arrays do |
||
def task(xs, ys, fname, precision\\[]) do |
def task(xs, ys, fname, precision\\[]) do |
||
xprecision = Keyword.get(precision, :x, 2) |
xprecision = Keyword.get(precision, :x, 2) |
||
Line 375: | Line 499: | ||
precision = [x: 3, y: 5] |
precision = [x: 3, y: 5] |
||
Write_float_arrays.task(x, y, fname, precision) |
Write_float_arrays.task(x, y, fname, precision) |
||
IO.puts File.read!(fname)</ |
IO.puts File.read!(fname)</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
Line 393: | Line 517: | ||
Erlang thinks 1 is an integer. To persuade it otherwise I have to use 1.0. |
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 ). |
-module( write_float_arrays ). |
||
Line 416: | Line 540: | ||
[ok = io:fwrite( IO, Format, [X, Y]) || {X, Y} <- lists:zip( Xs, Ys)], |
[ok = io:fwrite( IO, Format, [X, Y]) || {X, Y} <- lists:zip( Xs, Ys)], |
||
file:close( IO ). |
file:close( IO ). |
||
</syntaxhighlight> |
|||
</lang> |
|||
{{out}} |
{{out}} |
||
Line 425: | Line 549: | ||
=={{header|Euphoria}}== |
=={{header|Euphoria}}== |
||
< |
<syntaxhighlight lang="euphoria">constant x = {1, 2, 3, 1e11}, |
||
y = {1, 1.4142135623730951, 1.7320508075688772, 316227.76601683791} |
y = {1, 1.4142135623730951, 1.7320508075688772, 316227.76601683791} |
||
Line 434: | Line 558: | ||
printf(fn,"%.3g\t%.5g\n",{x[n],y[n]}) |
printf(fn,"%.3g\t%.5g\n",{x[n],y[n]}) |
||
end for |
end for |
||
close(fn)</ |
close(fn)</syntaxhighlight> |
||
=={{header|F Sharp|F#}}== |
=={{header|F Sharp|F#}}== |
||
< |
<syntaxhighlight lang="fsharp">[<EntryPoint>] |
||
let main argv = |
let main argv = |
||
let x = [ 1.; 2.; 3.; 1e11 ] |
let x = [ 1.; 2.; 3.; 1e11 ] |
||
Line 448: | Line 572: | ||
let line = sprintf "%.*g\t%.*g" |
let line = sprintf "%.*g\t%.*g" |
||
List.iter2 (fun x y -> file.WriteLine (line xprecision x yprecision y)) x y |
List.iter2 (fun x y -> file.WriteLine (line xprecision x yprecision y)) x y |
||
0</ |
0</syntaxhighlight> |
||
Content of File, visualized with TAB=8 |
Content of File, visualized with TAB=8 |
||
<pre>1 1 |
<pre>1 1 |
||
Line 458: | Line 582: | ||
{{works with|GNU Forth}} |
{{works with|GNU Forth}} |
||
< |
<syntaxhighlight 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, |
create y 1e f, 2e fsqrt f, 3e fsqrt f, 1e11 fsqrt f, |
||
Line 472: | Line 596: | ||
outfile-id stdout to outfile-id |
outfile-id stdout to outfile-id |
||
close-file throw ;</ |
close-file throw ;</syntaxhighlight> |
||
=={{header|Fortran}}== |
=={{header|Fortran}}== |
||
=== Fortran 90 === |
=== Fortran 90 === |
||
{{works with|Fortran|90 and later}} |
{{works with|Fortran|90 and later}} |
||
< |
<syntaxhighlight lang="fortran">program writefloats |
||
implicit none |
implicit none |
||
Line 502: | Line 626: | ||
end subroutine writexy |
end subroutine writexy |
||
end program writefloats</ |
end program writefloats</syntaxhighlight> |
||
The arrays x and y should have same bounds (and size); this constraint is not checked. |
The arrays x and y should have same bounds (and size); this constraint is not checked. |
||
=== Fortran 77 === |
=== Fortran 77 === |
||
< |
<syntaxhighlight lang="fortran"> program writefloats |
||
integer i |
integer i |
||
double precision x(4), y(4) |
double precision x(4), y(4) |
||
Line 518: | Line 642: | ||
open(unit=15, file='two_cols.txt', status='new') |
open(unit=15, file='two_cols.txt', status='new') |
||
write(15, '(f20.3,f21.4)') (x(i), y(i), i = 1, 4) |
write(15, '(f20.3,f21.4)') (x(i), y(i), i = 1, 4) |
||
end</ |
end</syntaxhighlight> |
||
=={{header|FreeBASIC}}== |
=={{header|FreeBASIC}}== |
||
< |
<syntaxhighlight lang="freebasic">' FB 1.05.0 Win64 |
||
Dim x(0 To 3) As Double = {1, 2, 3, 1e11} |
Dim x(0 To 3) As Double = {1, 2, 3, 1e11} |
||
Line 533: | Line 657: | ||
Print #1, Using "#^^^^"; x(3); |
Print #1, Using "#^^^^"; x(3); |
||
Print #1, Spc(2); Using "##.####^^^^"; y(3) |
Print #1, Spc(2); Using "##.####^^^^"; y(3) |
||
Close #1</ |
Close #1</syntaxhighlight> |
||
Contents of output.txt : |
Contents of output.txt : |
||
{{out}} |
{{out}} |
||
Line 542: | Line 666: | ||
1E+11 3.1623E+05 |
1E+11 3.1623E+05 |
||
</pre> |
</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}}== |
=={{header|Go}}== |
||
< |
<syntaxhighlight lang="go">package main |
||
import ( |
import ( |
||
Line 573: | Line 740: | ||
} |
} |
||
f.Close() |
f.Close() |
||
}</ |
}</syntaxhighlight> |
||
File contents: |
File contents: |
||
<pre> |
<pre> |
||
Line 584: | Line 751: | ||
=={{header|Haskell}}== |
=={{header|Haskell}}== |
||
Probably not very idiomatic but oh well |
Probably not very idiomatic but oh well |
||
< |
<syntaxhighlight lang="haskell">import System.IO |
||
import Text.Printf |
import Text.Printf |
||
import Control.Monad |
import Control.Monad |
||
Line 592: | Line 759: | ||
-- Haskell's printf doesn't support a precision given as an argument for some reason, so we insert it into the format manually: |
-- 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 |
let writeLine = hPrintf h $ "%." ++ show xprec ++ "g\t%." ++ show yprec ++ "g\n" in |
||
zipWithM_ writeLine x y</ |
zipWithM_ writeLine x y</syntaxhighlight> |
||
Example usage |
Example usage |
||
Prelude> let x = [1, 2, 3, 1e11] |
Prelude> let x = [1, 2, 3, 1e11] |
||
Line 606: | Line 773: | ||
Alternative solution without Printf |
Alternative solution without Printf |
||
< |
<syntaxhighlight lang="haskell">import System.IO |
||
import Control.Monad |
import Control.Monad |
||
import Numeric |
import Numeric |
||
Line 613: | Line 780: | ||
withFile filename WriteMode $ \h -> |
withFile filename WriteMode $ \h -> |
||
let writeLine a b = hPutStrLn h $ showGFloat (Just xprec) a "" ++ "\t" ++ showGFloat (Just yprec) b "" in |
let writeLine a b = hPutStrLn h $ showGFloat (Just xprec) a "" ++ "\t" ++ showGFloat (Just yprec) b "" in |
||
zipWithM_ writeLine x y</ |
zipWithM_ writeLine x y</syntaxhighlight> |
||
=={{header|HicEst}}== |
=={{header|HicEst}}== |
||
< |
<syntaxhighlight lang="hicest">REAL :: n=4, x(n), y(n) |
||
CHARACTER :: outP = "Test.txt" |
CHARACTER :: outP = "Test.txt" |
||
Line 624: | Line 791: | ||
DO i = 1, n |
DO i = 1, n |
||
WRITE(FIle=outP, Format='F5, F10.3') x(i), y(i) |
WRITE(FIle=outP, Format='F5, F10.3') x(i), y(i) |
||
ENDDO </ |
ENDDO </syntaxhighlight> |
||
Alternative: Display or Edit the formatted arrays in a [http://www.HicEst.com/MatrixExplorer spreadsheet-like dialog] with a common scroll bar. |
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: |
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}}== |
=={{header|Icon}} and {{header|Unicon}}== |
||
Line 633: | Line 800: | ||
The following works in both languages. |
The following works in both languages. |
||
< |
<syntaxhighlight lang="unicon">link printf |
||
procedure main() |
procedure main() |
||
Line 639: | Line 806: | ||
every put(y := [], sqrt(!x)) |
every put(y := [], sqrt(!x)) |
||
every fprintf(open("filename","w"),"%10.2e %10.4e\n", x[i := 1 to *x], y[i]) |
every fprintf(open("filename","w"),"%10.2e %10.4e\n", x[i := 1 to *x], y[i]) |
||
end</ |
end</syntaxhighlight> |
||
Contents of <tt>filename</tt> after running: |
Contents of <tt>filename</tt> after running: |
||
Line 670: | Line 837: | ||
The file <tt>"datafile.txt"</tt> then contains the following: |
The file <tt>"datafile.txt"</tt> then contains the following: |
||
< |
<syntaxhighlight lang="idl">1 1 |
||
2 1.4142 |
2 1.4142 |
||
3 1.7321 |
3 1.7321 |
||
1E+011 3.1623E+005</ |
1E+011 3.1623E+005</syntaxhighlight> |
||
This is fairly ugly and un-IDLish. |
This is fairly ugly and un-IDLish. |
||
Line 683: | Line 850: | ||
=={{header|J}}== |
=={{header|J}}== |
||
< |
<syntaxhighlight lang="j">require 'files' NB. for fwrites |
||
x =. 1 2 3 1e11 |
x =. 1 2 3 1e11 |
||
Line 695: | Line 862: | ||
data =. (0 j. xprecision,yprecision) ": x,.y |
data =. (0 j. xprecision,yprecision) ": x,.y |
||
data fwrites filename</ |
data fwrites filename</syntaxhighlight> |
||
Or, more concisely: |
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). |
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: | Line 872: | ||
Note that J's idea of precision here is "positions after the decimal point": |
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 |
1.000 1.00000 |
||
2.000 1.41421 |
2.000 1.41421 |
||
3.000 1.73205 |
3.000 1.73205 |
||
100000000000.000 316227.76602</ |
100000000000.000 316227.76602</syntaxhighlight> |
||
=={{header|Java}}== |
=={{header|Java}}== |
||
< |
<syntaxhighlight lang="java5">import java.io.*; |
||
public class FloatArray { |
public class FloatArray { |
||
Line 744: | Line 911: | ||
} catch (IOException e) { } |
} catch (IOException e) { } |
||
} |
} |
||
}</ |
}</syntaxhighlight> |
||
=={{header|Joy}}== |
=={{header|Joy}}== |
||
<syntaxhighlight lang="joy"> |
|||
<lang Joy> |
|||
DEFINE write-floats == |
DEFINE write-floats == |
||
['g 0] [formatf] enconcat map rollup |
['g 0] [formatf] enconcat map rollup |
||
Line 754: | Line 921: | ||
[[fputchars] 9 fputch] step 10 fputch] step |
[[fputchars] 9 fputch] step 10 fputch] step |
||
fclose. |
fclose. |
||
</syntaxhighlight> |
|||
</lang> |
|||
Using it: |
Using it: |
||
Line 766: | Line 933: | ||
=={{header|jq}}== |
=={{header|jq}}== |
||
''' Program''': |
''' Program''': |
||
< |
<syntaxhighlight lang="jq">[1, 2, 3, 1e11] as $x |
||
| $x | map(sqrt) as $y |
| $x | map(sqrt) as $y |
||
| range(0; $x|length) as $i |
| range(0; $x|length) as $i |
||
| "\($x[$i]) \($y[$i])"</ |
| "\($x[$i]) \($y[$i])"</syntaxhighlight> |
||
''' Execution''': |
''' Execution''': |
||
To write the output to "filename": |
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}}== |
=={{header|Julia}}== |
||
< |
<syntaxhighlight lang="julia">xprecision = 3 |
||
yprecision = 5 |
yprecision = 5 |
||
x = round.([1, 2, 3, 1e11],xprecision) |
x = round.([1, 2, 3, 1e11],xprecision) |
||
y = round.([1, 1.4142135623730951, 1.7320508075688772, 316227.76601683791],yprecision) |
y = round.([1, 1.4142135623730951, 1.7320508075688772, 316227.76601683791],yprecision) |
||
writedlm("filename", [x y], '\t')</ |
writedlm("filename", [x y], '\t')</syntaxhighlight> |
||
=={{header|Kotlin}}== |
=={{header|Kotlin}}== |
||
< |
<syntaxhighlight lang="scala">// version 1.1.2 |
||
import java.io.File |
import java.io.File |
||
Line 799: | Line 966: | ||
} |
} |
||
} |
} |
||
}</ |
}</syntaxhighlight> |
||
Contents of 'output.txt': |
Contents of 'output.txt': |
||
Line 810: | Line 977: | ||
=={{header|Lingo}}== |
=={{header|Lingo}}== |
||
< |
<syntaxhighlight lang="lingo">on saveFloatLists (filename, x, y, xprecision, yprecision) |
||
eol = numtochar(10) -- LF |
eol = numtochar(10) -- LF |
||
fp = xtra("fileIO").new() |
fp = xtra("fileIO").new() |
||
Line 824: | Line 991: | ||
end repeat |
end repeat |
||
fp.closeFile() |
fp.closeFile() |
||
end</ |
end</syntaxhighlight> |
||
< |
<syntaxhighlight lang="lingo">x = [1.0, PI, sqrt(2)] |
||
y = [2.0, log(10), sqrt(3)] |
y = [2.0, log(10), sqrt(3)] |
||
saveFloatLists("floats.txt", x, y, 3, 5)</ |
saveFloatLists("floats.txt", x, y, 3, 5)</syntaxhighlight> |
||
=={{header|Lua}}== |
=={{header|Lua}}== |
||
< |
<syntaxhighlight lang="lua">filename = "file.txt" |
||
x = { 1, 2, 3, 1e11 } |
x = { 1, 2, 3, 1e11 } |
||
Line 846: | Line 1,013: | ||
end |
end |
||
io.close( fp )</ |
io.close( fp )</syntaxhighlight> |
||
=={{header| |
=={{header|M2000 Interpreter}}== |
||
Precision here is just Round (as school rounding) |
|||
<lang Mathematica>exportPrec[path_, data1_, data2_, prec1_, prec2_]:=Export[path,Transpose[{Map[ToString[NumberForm[#, prec2]] &, data2],Map[ToString[NumberForm[#, prec1]] &, data1]}], "Table"]</lang> |
|||
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}}== |
=={{header|MATLAB}} / {{header|Octave}}== |
||
< |
<syntaxhighlight lang="matlab"> x = [1, 2, 3, 1e11]; |
||
y = [1, 1.4142135623730951, 1.7320508075688772, 316227.76601683791]; |
y = [1, 1.4142135623730951, 1.7320508075688772, 316227.76601683791]; |
||
fid = fopen('filename','w') |
fid = fopen('filename','w') |
||
fprintf(fid,'%.3g\t%.5g\n',[x;y]); |
fprintf(fid,'%.3g\t%.5g\n',[x;y]); |
||
fclose(fid); </ |
fclose(fid); </syntaxhighlight> |
||
{{out}} |
{{out}} |
||
Line 867: | Line 1,070: | ||
=={{header|Mercury}}== |
=={{header|Mercury}}== |
||
< |
<syntaxhighlight lang="mercury">:- module write_float_arrays. |
||
:- interface. |
:- interface. |
||
Line 895: | Line 1,098: | ||
write_dat(File, XPrec, YPrec, X, Y, !IO) :- |
write_dat(File, XPrec, YPrec, X, Y, !IO) :- |
||
io.format(File, "%.*g\t%.*g\n", [i(XPrec), f(X), i(YPrec), f(Y)], !IO).</ |
io.format(File, "%.*g\t%.*g\n", [i(XPrec), f(X), i(YPrec), f(Y)], !IO).</syntaxhighlight> |
||
File contents: |
File contents: |
||
Line 907: | Line 1,110: | ||
=={{header|NetRexx}}== |
=={{header|NetRexx}}== |
||
< |
<syntaxhighlight lang="netrexx">/* NetRexx */ |
||
options replace format comments java crossref savelog symbols nobinary |
options replace format comments java crossref savelog symbols nobinary |
||
Line 923: | Line 1,126: | ||
return |
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. |
-- This function formats the input arrays. |
||
-- It has defaults for the x & y precision values of 3 & 5 |
-- 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) - |
method formatArrays(outFile, xf = Rexx[], yf = Rexx[], xprecision = 3, yprecision = 5) - |
||
public static signals IllegalArgumentException, FileNotFoundException, IOException |
public static signals IllegalArgumentException, FileNotFoundException, IOException |
||
Line 942: | Line 1,145: | ||
return |
return |
||
</syntaxhighlight> |
|||
</lang> |
|||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
Line 952: | Line 1,155: | ||
=={{header|NewLISP}}== |
=={{header|NewLISP}}== |
||
< |
<syntaxhighlight lang="newlisp">; file: write-float-array.lsp |
||
; url: http://rosettacode.org/wiki/Write_float_arrays_to_a_text_file |
; url: http://rosettacode.org/wiki/Write_float_arrays_to_a_text_file |
||
; author: oofoe 2012-01-30 |
; author: oofoe 2012-01-30 |
||
Line 977: | Line 1,180: | ||
(print (read-file "filename.chan")) |
(print (read-file "filename.chan")) |
||
(exit)</ |
(exit)</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
Line 988: | Line 1,191: | ||
=={{header|Nim}}== |
=={{header|Nim}}== |
||
< |
<syntaxhighlight lang="nim">import strutils, math, sequtils |
||
const OutFileName = "floatarr2file.txt" |
|||
const |
|||
outFileName = "floatarr2file.txt" |
|||
const |
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 |
var res = "" |
||
for t in zip(a, b): |
|||
var res: string = "" |
|||
res.add formatFloat(t[0], ffDefault, Xprecision) & " " & |
|||
for t in c: |
|||
formatFloat(t[1], ffDefault, Yprecision) & "\n" |
|||
writeFile |
OutFileName.writeFile res |
||
var res2 = readFile( |
var res2 = OutFileName.readFile() |
||
echo |
echo res2</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre>1.00 |
<pre>1.00 1.0000 |
||
2.00 |
2.00 1.4142 |
||
3.00 |
3.00 1.7321 |
||
1.00e+11 |
1.00e+11 3.1623e+05</pre> |
||
=={{header|OCaml}}== |
=={{header|OCaml}}== |
||
< |
<syntaxhighlight lang="ocaml">let write_dat filename x y ?(xprec=3) ?(yprec=5) () = |
||
let oc = open_out filename in |
let oc = open_out filename in |
||
let write_line a b = Printf.fprintf oc "%.*g\t%.*g\n" xprec a yprec b in |
let write_line a b = Printf.fprintf oc "%.*g\t%.*g\n" xprec a yprec b in |
||
List.iter2 write_line x y; |
List.iter2 write_line x y; |
||
close_out oc</ |
close_out oc</syntaxhighlight> |
||
Example usage |
Example usage |
||
# let x = [1.0; 2.0; 3.0; 1e11];; |
# let x = [1.0; 2.0; 3.0; 1e11];; |
||
Line 1,042: | Line 1,244: | ||
=={{header|PARI/GP}}== |
=={{header|PARI/GP}}== |
||
{{works with|PARI/GP|2.5.0 and above}} |
{{works with|PARI/GP|2.5.0 and above}} |
||
< |
<syntaxhighlight lang="parigp">f(x,pr)={ |
||
Strprintf(if(x>=10^pr, |
Strprintf(if(x>=10^pr, |
||
Str("%.",pr-1,"e") |
Str("%.",pr-1,"e") |
||
Line 1,053: | Line 1,255: | ||
write("filename",f(x[i],xprec),"\t",f(y[i],yprec)) |
write("filename",f(x[i],xprec),"\t",f(y[i],yprec)) |
||
) |
) |
||
};</ |
};</syntaxhighlight> |
||
=={{header|Pascal}}== |
=={{header|Pascal}}== |
||
< |
<syntaxhighlight lang="pascal">Program WriteNumbers; |
||
const |
const |
||
Line 1,074: | Line 1,276: | ||
writeln (filename, x[i]:baseDigits+xprecision, sqrt(x[i]):baseDigits+yprecision); |
writeln (filename, x[i]:baseDigits+xprecision, sqrt(x[i]):baseDigits+yprecision); |
||
close (filename); |
close (filename); |
||
end.</ |
end.</syntaxhighlight> |
||
File contents |
File contents |
||
<pre> |
<pre> |
||
Line 1,084: | Line 1,286: | ||
=={{header|Perl}}== |
=={{header|Perl}}== |
||
< |
<syntaxhighlight lang="perl">use autodie; |
||
sub writedat { |
sub writedat { |
||
Line 1,101: | Line 1,303: | ||
my @y = map sqrt, @x; |
my @y = map sqrt, @x; |
||
writedat("sqrt.dat", \@x, \@y);</ |
writedat("sqrt.dat", \@x, \@y);</syntaxhighlight> |
||
File contents |
File contents |
||
<pre> |
<pre> |
||
Line 1,112: | Line 1,314: | ||
Alternatively, with the CPAN List::MoreUtils package: |
Alternatively, with the CPAN List::MoreUtils package: |
||
< |
<syntaxhighlight lang="perl">use autodie; |
||
use List::MoreUtils qw(each_array); |
use List::MoreUtils qw(each_array); |
||
Line 1,130: | Line 1,332: | ||
my @y = map sqrt, @x; |
my @y = map sqrt, @x; |
||
writedat("sqrt.dat", \@x, \@y);</ |
writedat("sqrt.dat", \@x, \@y);</syntaxhighlight> |
||
=={{header|Phix}}== |
=={{header|Phix}}== |
||
Copy of [[Write_float_arrays_to_a_text_file#Euphoria|Euphoria]] |
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: |
File contents: |
||
<pre> |
<pre> |
||
Line 1,152: | Line 1,356: | ||
=={{header|PicoLisp}}== |
=={{header|PicoLisp}}== |
||
An exponential format like "1e11" is not supported |
An exponential format like "1e11" is not supported |
||
< |
<syntaxhighlight lang="picolisp">(setq *Xprecision 3 *Yprecision 5) |
||
(scl 7) |
(scl 7) |
||
Line 1,162: | Line 1,366: | ||
(round Y *Yprecision) ) ) |
(round Y *Yprecision) ) ) |
||
(1.0 2.0 3.0) |
(1.0 2.0 3.0) |
||
(1.0 1.414213562 1.732050807) )</ |
(1.0 1.414213562 1.732050807) )</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre>1.000 1.00000 |
<pre>1.000 1.00000 |
||
Line 1,169: | Line 1,373: | ||
=={{header|PL/I}}== |
=={{header|PL/I}}== |
||
< |
<syntaxhighlight lang="pl/i">*Process source attributes xref; |
||
aaa: Proc Options(main); |
aaa: Proc Options(main); |
||
declare X(5) float (9) initial (1, 2, 3, 4, 5), |
declare X(5) float (9) initial (1, 2, 3, 4, 5), |
||
Line 1,181: | Line 1,385: | ||
(skip,e(19,x_precision), |
(skip,e(19,x_precision), |
||
x(2),e(24,y_precision)); |
x(2),e(24,y_precision)); |
||
end;</ |
end;</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre> 1.000000000E+0000 9.0000000000000000E+0000 |
<pre> 1.000000000E+0000 9.0000000000000000E+0000 |
||
Line 1,190: | Line 1,394: | ||
=={{header|PowerShell}}== |
=={{header|PowerShell}}== |
||
< |
<syntaxhighlight lang="powershell">$x = @(1, 2, 3, 1e11) |
||
$y = @(1, 1.4142135623730951, 1.7320508075688772, 316227.76601683791) |
$y = @(1, 1.4142135623730951, 1.7320508075688772, 316227.76601683791) |
||
$xprecision = 3 |
$xprecision = 3 |
||
Line 1,198: | Line 1,402: | ||
} |
} |
||
($arr | format-table -HideTableHeaders | Out-String).Trim() > filename.txt |
($arr | format-table -HideTableHeaders | Out-String).Trim() > filename.txt |
||
</syntaxhighlight> |
|||
</lang> |
|||
<b>Output:</b> |
<b>Output:</b> |
||
<pre> |
<pre> |
||
Line 1,208: | Line 1,412: | ||
=={{header|PureBasic}}== |
=={{header|PureBasic}}== |
||
< |
<syntaxhighlight lang="purebasic">#Size = 4 |
||
DataSection |
DataSection |
||
Line 1,235: | Line 1,439: | ||
CloseFile(fileID) |
CloseFile(fileID) |
||
EndIf |
EndIf |
||
EndIf</ |
EndIf</syntaxhighlight> |
||
{{out}} to text file: |
{{out}} to text file: |
||
<pre>1.000 1.00000 |
<pre>1.000 1.00000 |
||
Line 1,244: | Line 1,448: | ||
=={{header|Python}}== |
=={{header|Python}}== |
||
{{works with|Python|2.6}} |
{{works with|Python|2.6}} |
||
< |
<syntaxhighlight lang="python">import itertools |
||
def writedat(filename, x, y, xprecision=3, yprecision=5): |
def writedat(filename, x, y, xprecision=3, yprecision=5): |
||
with open(filename,'w') as f: |
with open(filename,'w') as f: |
||
for a, b in itertools.izip(x, y): |
for a, b in itertools.izip(x, y): |
||
print >> f, "%.*g\t%.*g" % (xprecision, a, yprecision, b)</ |
print >> f, "%.*g\t%.*g" % (xprecision, a, yprecision, b)</syntaxhighlight> |
||
Example usage |
Example usage |
||
< |
<syntaxhighlight lang="python">>>> import math |
||
>>> x = [1, 2, 3, 1e11] |
>>> x = [1, 2, 3, 1e11] |
||
>>> y = map(math.sqrt, x) |
>>> y = map(math.sqrt, x) |
||
Line 1,264: | Line 1,468: | ||
2 1.4142 |
2 1.4142 |
||
3 1.7321 |
3 1.7321 |
||
1e+011 3.1623e+005</ |
1e+011 3.1623e+005</syntaxhighlight> |
||
{{works with|Python|3}} |
{{works with|Python|3}} |
||
< |
<syntaxhighlight lang="python">def writedat(filename, x, y, xprecision=3, yprecision=5): |
||
with open(filename,'w') as f: |
with open(filename,'w') as f: |
||
for a, b in zip(x, y): |
for a, b in zip(x, y): |
||
print("%.*g\t%.*g" % (xprecision, a, yprecision, b), file=f) |
print("%.*g\t%.*g" % (xprecision, a, yprecision, b), file=f) |
||
#or, using the new-style formatting: |
#or, using the new-style formatting: |
||
#print("{1:.{0}g}\t{3:.{2}g}".format(xprecision, a, yprecision, b), file=f)</ |
#print("{1:.{0}g}\t{3:.{2}g}".format(xprecision, a, yprecision, b), file=f)</syntaxhighlight> |
||
=={{header|R}}== |
=={{header|R}}== |
||
< |
<syntaxhighlight lang="r">writexy <- function(file, x, y, xprecision=3, yprecision=3) { |
||
fx <- formatC(x, digits=xprecision, format="g", flag="-") |
fx <- formatC(x, digits=xprecision, format="g", flag="-") |
||
fy <- formatC(y, digits=yprecision, format="g", flag="-") |
fy <- formatC(y, digits=yprecision, format="g", flag="-") |
||
Line 1,284: | Line 1,488: | ||
x <- c(1, 2, 3, 1e11) |
x <- c(1, 2, 3, 1e11) |
||
y <- sqrt(x) |
y <- sqrt(x) |
||
writexy("test.txt", x, y, yp=5)</ |
writexy("test.txt", x, y, yp=5)</syntaxhighlight> |
||
=={{header|Racket}}== |
=={{header|Racket}}== |
||
<syntaxhighlight lang="racket"> |
|||
<lang Racket> |
|||
#lang racket |
#lang racket |
||
Line 1,311: | Line 1,515: | ||
100000000000 316227.76602 |
100000000000 316227.76602 |
||
|# |
|# |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|Raku}}== |
=={{header|Raku}}== |
||
Line 1,317: | Line 1,521: | ||
===Perl 5-ish=== |
===Perl 5-ish=== |
||
Written in the style of the 2nd Perl 5 example. |
Written in the style of the 2nd Perl 5 example. |
||
<lang |
<syntaxhighlight lang="raku" line>sub writefloat ( $filename, @x, @y, $x_precision = 3, $y_precision = 5 ) { |
||
my $fh = open $filename, :w; |
my $fh = open $filename, :w; |
||
for flat @x Z @y -> $x, $y { |
for flat @x Z @y -> $x, $y { |
||
Line 1,328: | Line 1,532: | ||
my @y = @x.map({.sqrt}); |
my @y = @x.map({.sqrt}); |
||
writefloat( 'sqrt.dat', @x, @y );</ |
writefloat( 'sqrt.dat', @x, @y );</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre>1 1 |
<pre>1 1 |
||
Line 1,336: | Line 1,540: | ||
===Idiomatic=== |
===Idiomatic=== |
||
Written in a more idiomatic style. |
Written in a more idiomatic style. |
||
<lang |
<syntaxhighlight lang="raku" line>sub writefloat($filename, @x, @y, :$x-precision = 3, :$y-precision = 3) { |
||
open($filename, :w).print: |
open($filename, :w).print: |
||
join '', flat (@x».fmt("%.{$x-precision}g") X "\t") Z (@y».fmt("%.{$y-precision}g") X "\n"); |
join '', flat (@x».fmt("%.{$x-precision}g") X "\t") Z (@y».fmt("%.{$y-precision}g") X "\n"); |
||
} |
} |
||
my @x = 1, 2, 3, 1e11; |
my @x = 1, 2, 3, 1e11; |
||
writefloat('sqrt.dat', @x, @x».sqrt, :y-precision(5));</ |
writefloat('sqrt.dat', @x, @x».sqrt, :y-precision(5));</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre>1 1 |
<pre>1 1 |
||
Line 1,349: | Line 1,553: | ||
=={{header|Raven}}== |
=={{header|Raven}}== |
||
< |
<syntaxhighlight lang="raven">3 as $xprecision |
||
5 as $yprecision |
5 as $yprecision |
||
Line 1,368: | Line 1,572: | ||
4 each as $i |
4 each as $i |
||
$f $b $i get $a $i get print2 |
$f $b $i get $a $i get print2 |
||
$results "" join "results.dat" write</ |
$results "" join "results.dat" write</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
results.dat file contains: |
results.dat file contains: |
||
Line 1,377: | Line 1,581: | ||
=={{header|REXX}}== |
=={{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.*/ |
numeric digits 1000 /*allow use of a huge number of digits.*/ |
||
oFID= 'filename' /*name of the output File IDentifier.*/ |
oFID= 'filename' /*name of the output File IDentifier.*/ |
||
Line 1,403: | Line 1,607: | ||
z=int || fraction || exponent /*format # (as per rules)*/ |
z=int || fraction || exponent /*format # (as per rules)*/ |
||
if datatype(z,'W') then return format(oz/1,,0) /*is it a whole number ? */ |
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.*/</ |
return format(oz/1,,,3,0) /*3 dec. digs in exponent.*/</syntaxhighlight> |
||
'''output''' when using the default (internal) data: |
'''output''' when using the default (internal) data: |
||
<pre> |
<pre> |
||
Line 1,413: | Line 1,617: | ||
=={{header|Ring}}== |
=={{header|Ring}}== |
||
< |
<syntaxhighlight lang="ring"> |
||
# Project : Write float arrays to a text file |
# Project : Write float arrays to a text file |
||
Line 1,435: | Line 1,639: | ||
end |
end |
||
fclose(fp) |
fclose(fp) |
||
</syntaxhighlight> |
|||
</lang> |
|||
Output: |
Output: |
||
<pre> |
<pre> |
||
Line 1,449: | Line 1,653: | ||
1. Direct writing of the numerical data to the file of an array using function ''writem''. Here the writing format |
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''. |
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); |
>> x = rand(10,1); y = rand(10,1); |
||
>> writem("mytextfile.txt", [x,y]); |
>> 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''. |
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. |
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); |
>> x = rand(10,1); y = rand(10,1); |
||
>> s = text( [x,y], "%10.8f" ); |
>> s = text( [x,y], "%10.8f" ); |
||
>> writem("mytextfile.txt", s); |
>> 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''. |
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: | Line 1,673: | ||
=={{header|Ruby}}== |
=={{header|Ruby}}== |
||
< |
<syntaxhighlight lang="ruby"># prepare test data |
||
x = [1, 2, 3, 1e11] |
x = [1, 2, 3, 1e11] |
||
y = x.collect { |xx| Math.sqrt xx } |
y = x.collect { |xx| Math.sqrt xx } |
||
Line 1,481: | Line 1,685: | ||
# print the result file |
# print the result file |
||
open('sqrt.dat', 'r') { |f| puts f.read }</ |
open('sqrt.dat', 'r') { |f| puts f.read }</syntaxhighlight> |
||
Result: |
Result: |
||
<pre>1 1 |
<pre>1 1 |
||
Line 1,489: | Line 1,693: | ||
=={{header|Run BASIC}}== |
=={{header|Run BASIC}}== |
||
< |
<syntaxhighlight lang="runbasic">x$ = "1, 2, 3, 1e11" |
||
y$ = "1, 1.4142135623730951, 1.7320508075688772, 316227.76601683791" |
y$ = "1, 1.4142135623730951, 1.7320508075688772, 316227.76601683791" |
||
Line 1,496: | Line 1,700: | ||
print #f, using("##############.###",val(word$(x$,i,",")));"|";using("#######.#####",val(word$(y$,i,","))) |
print #f, using("##############.###",val(word$(x$,i,",")));"|";using("#######.#####",val(word$(y$,i,","))) |
||
next i |
next i |
||
close #f</ |
close #f</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre> 1.000| 1.00000 |
<pre> 1.000| 1.00000 |
||
Line 1,504: | Line 1,708: | ||
=={{header|SAS}}== |
=={{header|SAS}}== |
||
< |
<syntaxhighlight lang="sas">data _null_; |
||
input x y; |
input x y; |
||
file "output.txt"; |
file "output.txt"; |
||
Line 1,514: | Line 1,718: | ||
1e11 316227.76601683791 |
1e11 316227.76601683791 |
||
; |
; |
||
run;</ |
run;</syntaxhighlight> |
||
=={{header|Scala}}== |
=={{header|Scala}}== |
||
{{libheader|Scala}}< |
{{libheader|Scala}}<syntaxhighlight lang="scala">import java.io.{File, FileWriter, IOException} |
||
object FloatArray extends App { |
object FloatArray extends App { |
||
Line 1,534: | Line 1,738: | ||
case e: IOException => println(s"Running Example failed: ${e.getMessage}") |
case e: IOException => println(s"Running Example failed: ${e.getMessage}") |
||
} |
} |
||
}</ |
}</syntaxhighlight> |
||
=={{header|Seed7}}== |
=={{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.< |
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 "float.s7i"; |
||
include "math.s7i"; |
include "math.s7i"; |
||
Line 1,552: | Line 1,756: | ||
end for; |
end for; |
||
close(aFile); |
close(aFile); |
||
end func;</ |
end func;</syntaxhighlight>{{out|Result file ''filename''}} |
||
1.000e+00 1.00000e+00 |
1.000e+00 1.00000e+00 |
||
2.000e+00 1.41421e+00 |
2.000e+00 1.41421e+00 |
||
Line 1,560: | Line 1,764: | ||
=={{header|Sidef}}== |
=={{header|Sidef}}== |
||
{{trans|Raku}} |
{{trans|Raku}} |
||
< |
<syntaxhighlight lang="ruby">func writedat(filename, x, y, x_precision=3, y_precision=5) { |
||
var fh = File(filename).open_w |
var fh = File(filename).open_w |
||
Line 1,573: | Line 1,777: | ||
var y = x.map{.sqrt} |
var y = x.map{.sqrt} |
||
writedat('sqrt.dat', x, y)</ |
writedat('sqrt.dat', x, y)</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
Line 1,583: | Line 1,787: | ||
=={{header|Smalltalk}}== |
=={{header|Smalltalk}}== |
||
{{works with | Smalltalk/X}} |
{{works with | Smalltalk/X}} |
||
< |
<syntaxhighlight lang="smalltalk">x := #( 1 2 3 1e11 ). |
||
y := x collect:#sqrt. |
y := x collect:#sqrt. |
||
xprecision := 3. |
xprecision := 3. |
||
Line 1,592: | Line 1,796: | ||
'%.*g\t%.*g\n' printf:{ xprecision . xI . yprecision . yI } on:fileStream |
'%.*g\t%.*g\n' printf:{ xprecision . xI . yprecision . yI } on:fileStream |
||
] |
] |
||
]</ |
]</syntaxhighlight> |
||
obviously, with fix precisions, the following printing expression is more readable: |
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}}== |
=={{header|SPL}}== |
||
< |
<syntaxhighlight lang="spl">x = [1, 2, 3, 10^11] |
||
y = [1, 1.4142135623730951, 1.7320508075688772, 316227.76601683791] |
y = [1, 1.4142135623730951, 1.7320508075688772, 316227.76601683791] |
||
xprecision = 3 |
xprecision = 3 |
||
Line 1,605: | Line 1,809: | ||
s2 = #.str(y[i],"g"+yprecision) |
s2 = #.str(y[i],"g"+yprecision) |
||
#.writeline("file.txt",s1+#.tab+s2) |
#.writeline("file.txt",s1+#.tab+s2) |
||
<</ |
<</syntaxhighlight> |
||
=={{header|Standard ML}}== |
=={{header|Standard ML}}== |
||
< |
<syntaxhighlight lang="sml">fun writeDat (filename, x, y, xprec, yprec) = let |
||
val os = TextIO.openOut filename |
val os = TextIO.openOut filename |
||
fun write_line (a, b) = |
fun write_line (a, b) = |
||
Line 1,616: | Line 1,820: | ||
ListPair.appEq write_line (x, y); |
ListPair.appEq write_line (x, y); |
||
TextIO.closeOut os |
TextIO.closeOut os |
||
end;</ |
end;</syntaxhighlight> |
||
Example usage |
Example usage |
||
- val x = [1.0, 2.0, 3.0, 1e11]; |
- val x = [1.0, 2.0, 3.0, 1e11]; |
||
Line 1,635: | Line 1,839: | ||
=={{header|Stata}}== |
=={{header|Stata}}== |
||
< |
<syntaxhighlight lang="stata">* Create the dataset |
||
clear |
clear |
||
mat x=1\2\3\1e11 |
mat x=1\2\3\1e11 |
||
Line 1,645: | Line 1,849: | ||
* Save as text file |
* Save as text file |
||
export delim file.txt, delim(" ") novar datafmt replace</ |
export delim file.txt, delim(" ") novar datafmt replace</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
Line 1,655: | Line 1,859: | ||
=={{header|Tcl}}== |
=={{header|Tcl}}== |
||
< |
<syntaxhighlight lang="tcl">set x {1 2 3 1e11} |
||
foreach a $x {lappend y [expr {sqrt($a)}]} |
foreach a $x {lappend y [expr {sqrt($a)}]} |
||
set fh [open sqrt.dat w] |
set fh [open sqrt.dat w] |
||
Line 1,665: | Line 1,869: | ||
set fh [open sqrt.dat] |
set fh [open sqrt.dat] |
||
puts [read $fh [file size sqrt.dat]] |
puts [read $fh [file size sqrt.dat]] |
||
close $fh</ |
close $fh</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre>1 1 |
<pre>1 1 |
||
Line 1,673: | Line 1,877: | ||
=={{header|VBA}}== |
=={{header|VBA}}== |
||
< |
<syntaxhighlight lang="vb">Public Sub main() |
||
x = [{1, 2, 3, 1e11}] |
x = [{1, 2, 3, 1e11}] |
||
y = [{1, 1.4142135623730951, 1.7320508075688772, 316227.76601683791}] |
y = [{1, 1.4142135623730951, 1.7320508075688772, 316227.76601683791}] |
||
Line 1,683: | Line 1,887: | ||
Next i |
Next i |
||
Close TextFile |
Close TextFile |
||
End Sub</ |
End Sub</syntaxhighlight>{{out}} |
||
<pre>1,000E000 1,00000E000 |
<pre>1,000E000 1,00000E000 |
||
2,000E000 1,41421E000 |
2,000E000 1,41421E000 |
||
3,000E000 1,73205E000 |
3,000E000 1,73205E000 |
||
1,000E011 3,16228E005 |
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> |
</pre> |
||
Line 1,695: | Line 1,930: | ||
In the final example, we need to force exponential format as numbers of this size would normally be printed in decimal format. |
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 |
import "./fmt" for Fmt |
||
var x = [1, 2, 3, 1e11] |
var x = [1, 2, 3, 1e11] |
||
Line 1,708: | Line 1,943: | ||
file.writeBytes(s) |
file.writeBytes(s) |
||
} |
} |
||
}</ |
}</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
Line 1,717: | Line 1,952: | ||
3 1.7321 |
3 1.7321 |
||
1e11 3.1623e05 |
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> |
</pre> |
||
=={{header|Yabasic}}== |
=={{header|Yabasic}}== |
||
< |
<syntaxhighlight lang="yabasic">x$ = "1 2 3 1e11" |
||
pr1 = 3 : pr2 = 5 |
pr1 = 3 : pr2 = 5 |
||
Line 1,732: | Line 1,990: | ||
next i |
next i |
||
close #f</ |
close #f</syntaxhighlight> |
||
=={{header|zkl}}== |
=={{header|zkl}}== |
||
< |
<syntaxhighlight lang="zkl">fcn writeFloatArraysToFile(filename, xs,xprecision, ys,yprecision){ |
||
f :=File(filename,"w"); |
f :=File(filename,"w"); |
||
fmt:="%%.%dg\t%%.%dg".fmt(xprecision,yprecision).fmt; // "%.3g\t%.5g".fmt |
fmt:="%%.%dg\t%%.%dg".fmt(xprecision,yprecision).fmt; // "%.3g\t%.5g".fmt |
||
Line 1,744: | Line 2,002: | ||
xs,ys := T(1.0, 2.0, 3.0, 1e11), xs.apply("sqrt"); |
xs,ys := T(1.0, 2.0, 3.0, 1e11), xs.apply("sqrt"); |
||
xprecision,yprecision := 3,5; |
xprecision,yprecision := 3,5; |
||
writeFloatArraysToFile("floatArray.txt", xs,xprecision, ys,yprecision);</ |
writeFloatArraysToFile("floatArray.txt", xs,xprecision, ys,yprecision);</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
Line 1,761: | Line 2,019: | ||
Here we write the contents of the array g() to a file: |
Here we write the contents of the array g() to a file: |
||
< |
<syntaxhighlight lang="zxbasic">SAVE "myarray" DATA g()</syntaxhighlight> |
Latest revision as of 11:12, 17 February 2024
![Task](http://static.miraheze.org/rosettacodewiki/thumb/b/ba/Rcode-button-task-crushed.png/64px-Rcode-button-task-crushed.png)
You are encouraged to solve this task according to the task description, using any language you may know.
- 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:
x = {1, 2, 3, 1e11}; y = {1, 1.4142135623730951, 1.7320508075688772, 316227.76601683791}; /* sqrt(x) */ xprecision = 3; yprecision = 5;
The file should look like:
1 1 2 1.4142 3 1.7321 1e+011 3.1623e+005
This task is intended as a subtask for Measure relative performance of sorting algorithms implementations.
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;
procedure Write_Float_Array is
type Float_Array is array (1..4) of Float;
procedure Write_Columns
( File : File_Type;
X : Float_Array;
Y : Float_Array;
X_Pres : Natural := 3;
Y_Pres : Natural := 5
) is
begin
for I in Float_Array'range loop
Put (File => File, Item => X(I), Fore => 1, Aft => X_Pres - 1);
Put (File, " ");
Put (File => File, Item => Y(I), Fore => 1, Aft => Y_Pres - 1);
New_Line (File);
end loop;
end Write_Columns;
File : File_Type;
X : Float_Array := (1.0, 2.0, 3.0, 1.0e11);
Y : Float_Array;
begin
Put ("Tell us the file name to write:");
Create (File, Out_File, Get_Line);
for I in Float_Array'range loop
Y(I) := Sqrt (X (I));
end loop;
Write_columns (File, X, Y);
Close (File);
end Write_Float_Array;
ALGOL 68
PROC writedat = (STRING filename, []REAL x, y, INT x width, y width)VOID: (
FILE f;
INT errno = open(f, filename, stand out channel);
IF errno NE 0 THEN stop FI;
FOR i TO UPB x DO
# FORMAT := IF the absolute exponent is small enough, THEN use fixed ELSE use float FI; #
FORMAT repr x := ( ABS log(x[i])<x width | $g(-x width,x width-2)$ | $g(-x width,x width-4,-1)$ ),
repr y := ( ABS log(y[i])<y width | $g(-y width,y width-2)$ | $g(-y width,y width-4,-1)$ );
putf(f, (repr x, x[i], $" "$, repr y, y[i], $l$))
OD;
close(f)
);
# Example usage: #
test:(
[]REAL x = (1, 2, 3, 1e11);
[UPB x]REAL y; FOR i TO UPB x DO y[i]:=sqrt(x[i]) OD;
printf(($"x before:"$, $xg$, x, $l$));
printf(($"y before:"$, $xg$, y, $l$));
writedat("sqrt.dat", x, y, 3+2, 5+2);
printf($"After:"l$);
FILE sqrt dat;
INT errno = open(sqrt dat, "sqrt.dat", stand in channel);
IF errno NE 0 THEN stop FI;
on logical file end(sqrt dat, (REF FILE sqrt dat)BOOL: stop);
TO UPB x DO
STRING line;
get(sqrt dat, (line, new line));
print((line,new line))
OD
)
- Output:
x before: +1.00000000000000e +0 +2.00000000000000e +0 +3.00000000000000e +0 +1.00000000000000e +11 y before: +1.00000000000000e +0 +1.41421356237310e +0 +1.73205080756888e +0 +3.16227766016838e +5 After: 1.000 1.00000 2.000 1.41421 3.000 1.73205 1e11 316228
Amazing Hopper
Version hopper-FLOW:
#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
- Output:
$ cat filename.txt 1 1 2 1.41421 3 1.73205 1e+11 316228
Applesoft BASIC
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
AWK
As usual, the order of array traversal in AWK is not necessarily the same as the input had:
$ 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])}'
1e+11 3.1623e+05
1 1
2 1.4142
3 1.7321
For the text file part of the task, just redirect stdout to it.
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
BBC BASIC
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%
- Output:
1 1 2 1.4142 3 1.7321 1E11 3.1623E5
C
#include <stdio.h>
#include <math.h>
int main(int argc, char **argv) {
float x[4] = {1,2,3,1e11}, y[4];
int i = 0;
FILE *filePtr;
filePtr = fopen("floatArray","w");
for (i = 0; i < 4; i++) {
y[i] = sqrt(x[i]);
fprintf(filePtr, "%.3g\t%.5g\n", x[i], y[i]);
}
return 0;
}
The file "floatArray" then contains the following:
1 1
2 1.4142
3 1.7321
1e+11 3.1623e+05
C#
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 };
int xprecision = 3;
int yprecision = 5;
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]);
}
}
- Output:
1 1 2 1.4142 3 1.7321 1E+11 3.1623E+05
C++
Function writedat():
template<class InputIterator, class InputIterator2>
void writedat(const char* filename,
InputIterator xbegin, InputIterator xend,
InputIterator2 ybegin, InputIterator2 yend,
int xprecision=3, int yprecision=5)
{
std::ofstream f;
f.exceptions(std::ofstream::failbit | std::ofstream::badbit);
f.open(filename);
for ( ; xbegin != xend and ybegin != yend; ++xbegin, ++ybegin)
f << std::setprecision(xprecision) << *xbegin << '\t'
<< std::setprecision(yprecision) << *ybegin << '\n';
}
Example:
#include <algorithm>
#include <cmath> // ::sqrt()
#include <fstream>
#include <iomanip> // setprecision()
#include <iostream>
#include <string>
#include <vector>
int main()
{
try {
// prepare test data
double x[] = {1, 2, 3, 1e11};
const size_t xsize = sizeof(x) / sizeof(*x);
std::vector<double> y(xsize);
std::transform(&x[0], &x[xsize], y.begin(), ::sqrt);
// write file using default precisions
writedat("sqrt.dat", &x[0], &x[xsize], y.begin(), y.end());
// print the result file
std::ifstream f("sqrt.dat");
for (std::string line; std::getline(f, line); )
std::cout << line << std::endl;
}
catch(std::exception& e) {
std::cerr << "writedat: exception: '" << e.what() << "'\n";
return 1;
}
return 0;
}
- Result:
1 1 2 1.4142 3 1.7321 1e+11 3.1623e+05
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.
- Result:
1.00E+00 1.0000E+00 2.00E+00 1.4142E+00 3.00E+00 1.7321E+00 1.00E+11 3.1623E+05
Common 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))
(xprecision 3)
(yprecision 5)
(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 2. 1.4142 3. 1.7321 1.0E+011 3.16228E+5
D
import std.file, std.conv, std.string;
void main() {
auto x = [1.0, 2, 3, 1e11];
auto y = [1.0, 1.4142135623730951,
1.7320508075688772, 316227.76601683791];
int xPrecision = 3,
yPrecision = 5;
string tmp;
foreach (i, fx; x)
tmp ~= format("%." ~ text(xPrecision) ~ "g %." ~
text(yPrecision) ~ "g\r\n", fx, y[i]);
write("float_array.txt", tmp);
}
- Output:
1 1 2 1.4142 3 1.7321 1e+11 3.1623e+05
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.
- Output:
1 1 2 1.4142 3 1.7321 1E011 3.1623E005
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)
- Output:
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
Erlang
Erlang thinks 1 is an integer. To persuade it otherwise I have to use 1.0.
-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 ).
- Output:
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">>
Euphoria
constant x = {1, 2, 3, 1e11},
y = {1, 1.4142135623730951, 1.7320508075688772, 316227.76601683791}
integer fn
fn = open("filename","w")
for n = 1 to length(x) do
printf(fn,"%.3g\t%.5g\n",{x[n],y[n]})
end for
close(fn)
F#
[<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
Content of File, visualized with TAB=8
1 1 2 1.4142 3 1.7321 1e+11 3.1623e+05
Forth
create x 1e f, 2e f, 3e f, 1e11 f,
create y 1e f, 2e fsqrt f, 3e fsqrt f, 1e11 fsqrt f,
: main
s" sqrt.txt" w/o open-file throw to outfile-id
4 0 do
4 set-precision
x i floats + f@ f.
6 set-precision
y i floats + f@ f. cr
loop
outfile-id stdout to outfile-id
close-file throw ;
Fortran
Fortran 90
program writefloats
implicit none
real, dimension(10) :: a, sqrta
integer :: i
integer, parameter :: unit = 40
a = (/ (i, i=1,10) /)
sqrta = sqrt(a)
open(unit, file="xydata.txt", status="new", action="write")
call writexy(unit, a, sqrta)
close(unit)
contains
subroutine writexy(u, x, y)
real, dimension(:), intent(in) :: x, y
integer, intent(in) :: u
integer :: i
write(u, "(2F10.4)") (x(i), y(i), i=lbound(x,1), ubound(x,1))
end subroutine writexy
end program writefloats
The arrays x and y should have same bounds (and size); this constraint is not checked.
Fortran 77
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
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
Contents of output.txt :
- Output:
1 1.0000 2 1.4142 3 1.7321 1E+11 3.1623E+05
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
- Output:
1 1.0000 2 1.4142 3 1.7321 1e+11 3.1623e+05
Go
package main
import (
"fmt"
"os"
)
var (
x = []float64{1, 2, 3, 1e11}
y = []float64{1, 1.4142135623730951, 1.7320508075688772, 316227.76601683791}
xprecision = 3
yprecision = 5
)
func main() {
if len(x) != len(y) {
fmt.Println("x, y different length")
return
}
f, err := os.Create("filename")
if err != nil {
fmt.Println(err)
return
}
for i := range x {
fmt.Fprintf(f, "%.*e, %.*e\n", xprecision-1, x[i], yprecision-1, y[i])
}
f.Close()
}
File contents:
1.00e+00, 1.0000e+00 2.00e+00, 1.4142e+00 3.00e+00, 1.7321e+00 1.00e+11, 3.1623e+05
Haskell
Probably not very idiomatic but oh well
import System.IO
import Text.Printf
import Control.Monad
writeDat filename x y xprec yprec =
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 $ "%." ++ show xprec ++ "g\t%." ++ show yprec ++ "g\n" in
zipWithM_ writeLine x y
Example usage
Prelude> let x = [1, 2, 3, 1e11] Prelude> let y = map sqrt x Prelude> y [1.0,1.4142135623730951,1.7320508075688772,316227.7660168379] Prelude> writeDat "sqrt.dat" x y 3 5 Prelude> readFile "sqrt.dat" >>= putStr 1.000 1.00000 2.000 1.41421 3.000 1.73205 1.000e11 316227.76602
Alternative solution without Printf
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
HicEst
REAL :: n=4, x(n), y(n)
CHARACTER :: outP = "Test.txt"
OPEN(FIle = outP)
x = (1, 2, 3, 1E11)
y = x ^ 0.5
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 spreadsheet-like dialog with a common scroll bar. The menu More - Export - File writes the formatted arrays to a file:
DLG(Text=x, Format='i12', Edit=y, Format='F10.2', Y=0)
Icon and Unicon
The following works in both languages.
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
Contents of filename after running:
->cat filename 1.00e0 1.0000e0 2.00e0 1.4142e0 3.00e0 1.7321e0 1.00e+11 3.1623e+5 ->
IDL
; the data: x = [1,2,3,1e11] y=sqrt(x) xprecision=3 yprecision=5 ; NOT how one would do things in IDL, but in the spirit of the task - the output format: form = string(xprecision,yprecision,format='("(G0.",I0.0,",1x,G0.",I0.0,")")') ; file I/O: openw,unit,"datafile.txt",/get for i = 1L, n_elements(x) do printf, unit, x[i-1],y[i-1],format=form free_lun,unit
The file "datafile.txt" then contains the following:
1 1
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.
J
require 'files' NB. for fwrites
x =. 1 2 3 1e11
y =. %: x NB. y is sqrt(x)
xprecision =. 3
yprecision =. 5
filename =. 'whatever.txt'
data =. (0 j. xprecision,yprecision) ": x,.y
data fwrites filename
Or, more concisely:
((0 j. 3 5) ": (,.%:) 1 2 3 1e11) fwrites 'whatever.txt' [ require 'fwrites'
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":
(0 j. 3 5) ": (,.%:) 1 2 3 1e11
1.000 1.00000
2.000 1.41421
3.000 1.73205
100000000000.000 316227.76602
Java
import java.io.*;
public class FloatArray {
public static void writeDat(String filename, double[] x, double[] y,
int xprecision, int yprecision)
throws IOException {
assert x.length == y.length;
PrintWriter out = new PrintWriter(filename);
for (int i = 0; i < x.length; i++)
out.printf("%."+xprecision+"g\t%."+yprecision+"g\n", x[i], y[i]);
out.close();
}
public static void main(String[] args) {
double[] x = {1, 2, 3, 1e11};
double[] y = new double[x.length];
for (int i = 0; i < x.length; i++)
y[i] = Math.sqrt(x[i]);
try {
writeDat("sqrt.dat", x, y, 3, 5);
} catch (IOException e) {
System.err.println("writeDat: exception: "+e);
}
try {
BufferedReader br = new BufferedReader(new FileReader("sqrt.dat"));
String line;
while ((line = br.readLine()) != null)
System.out.println(line);
} catch (IOException e) { }
}
}
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.
Using it:
[1.0 2.0 3.0 1e11] 3 [1.0 1.41421356 1.73205080 316227.7660168] 5 write-floats.
jq
Program:
[1, 2, 3, 1e11] as $x
| $x | map(sqrt) as $y
| range(0; $x|length) as $i
| "\($x[$i]) \($y[$i])"
Execution: To write the output to "filename":
$ jq -n -r -f Write_float_arrays_to_a_text_file.jq > filename
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')
Kotlin
// 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)
}
}
}
Contents of 'output.txt':
1.00 1.0000 2.00 1.4142 3.00 1.7321 1.00e+11 3.1623e+05
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
x = [1.0, PI, sqrt(2)]
y = [2.0, log(10), sqrt(3)]
saveFloatLists("floats.txt", x, y, 3, 5)
Lua
filename = "file.txt"
x = { 1, 2, 3, 1e11 }
y = { 1, 1.4142135623730951, 1.7320508075688772, 316227.76601683791 };
xprecision = 3;
yprecision = 5;
fstr = "%."..tostring(xprecision).."f ".."%."..tostring(yprecision).."f\n"
fp = io.open( filename, "w+" )
for i = 1, #x do
fp:write( string.format( fstr, x[i], y[i] ) )
end
io.close( fp )
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
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
- Output:
1 1 2 1.4142 3 1.7321 100000000000 316227.766
Mathematica /Wolfram Language
exportPrec[path_, data1_, data2_, prec1_, prec2_] :=
Export[
path,
Transpose[{Map[ToString[NumberForm[#, prec2]] &, data2], Map[ToString[NumberForm[#, prec1]] &, data1]}],
"Table"
]
MATLAB / Octave
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);
- Output:
1 1 2 1.4142 3 1.7321 1e+11 3.1623e+05
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).
File contents:
1 1 2 1.4142 3 1.7321 1e+11 3.1623e+05
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
- Output:
1.000 1.00000 2.000 1.41421 3.000 1.73205 1.000E+11 3.16228E+5
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)
- Output:
File contents: 1 1 2 1.4142 3 1.7321 1e+011 3.1623e+005
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
- Output:
1.00 1.0000 2.00 1.4142 3.00 1.7321 1.00e+11 3.1623e+05
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
Example usage
# let x = [1.0; 2.0; 3.0; 1e11];; val x : float list = [1.; 2.; 3.; 100000000000.] # let y = List.map sqrt x;; val y : float list = [1.; 1.41421356237309515; 1.73205080756887719; 316227.766016837908] # write_dat "sqrt.dat" x y ();; - : unit = () # let ic = open_in "sqrt.dat";; val ic : in_channel = <abstr> # try while true do print_endline (input_line ic) done with End_of_file -> ();; 1 1 2 1.4142 3 1.7321 1e+11 3.1623e+05 - : unit = ()
PARI/GP
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))
)
};
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.
File contents
1.00E+000 1.0000E+000 2.00E+000 1.4142E+000 3.00E+000 1.7321E+000 1.00E+011 3.1623E+005
Perl
use autodie;
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;
}
my @x = (1, 2, 3, 1e11);
my @y = map sqrt, @x;
writedat("sqrt.dat", \@x, \@y);
File contents
1 1 2 1.4142 3 1.7321 1e+11 3.1623e+05
Alternatively, with the CPAN List::MoreUtils package:
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);
Phix
Copy of Euphoria
constant x = {1, 2, 3, 1e11}, y = {1, 1.4142135623730951, 1.7320508075688772, 316227.76601683791} integer fn = open("filename","w") for i=1 to length(x) do printf(fn,"%.3g\t%.5g\n",{x[i],y[i]}) end for close(fn)
File contents:
1 1 2 1.4142 3 1.7321 1e+11 3.1623e+5
PicoLisp
An exponential format like "1e11" is not supported
(setq *Xprecision 3 *Yprecision 5)
(scl 7)
(mapc
'((X Y)
(prinl
(round X *Xprecision)
" "
(round Y *Yprecision) ) )
(1.0 2.0 3.0)
(1.0 1.414213562 1.732050807) )
- Output:
1.000 1.00000 2.000 1.41421 3.000 1.73205
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;
- Output:
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
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
Output:
1 1 2 1.4142 3 1.7321 1e+11 3.1623e+05
PureBasic
#Size = 4
DataSection
Data.f 1, 2, 3, 1e11 ;x values, how many values needed is determined by #Size
EndDataSection
Dim x.f(#Size - 1)
Dim y.f(#Size - 1)
Define i
For i = 0 To #Size - 1
Read.f x(i)
y(i) = Sqr(x(i))
Next
Define file$, fileID, xprecision = 3, yprecision = 5, output$
file$ = SaveFileRequester("Text file for float data", "xydata.txt","Text file | *.txt", 0)
If file$
fileID = OpenFile(#PB_Any, file$)
If fileID
For i = 0 To #Size - 1
output$ = StrF(x(i), xprecision) + Chr(9) + StrF(y(i), yprecision)
WriteStringN(fileID, output$)
Next
CloseFile(fileID)
EndIf
EndIf
- Output:
to text file
1.000 1.00000 2.000 1.41421 3.000 1.73205 99999997952.000 316227.75000
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)
Example usage
>>> import math
>>> x = [1, 2, 3, 1e11]
>>> y = map(math.sqrt, x)
>>> y
[1.0, 1.4142135623730951, 1.7320508075688772, 316227.76601683791]
>>> writedat("sqrt.dat", x, y)
>>> # check
...
>>> for line in open('sqrt.dat'):
... print line,
...
1 1
2 1.4142
3 1.7321
1e+011 3.1623e+005
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)
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="-")
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("test.txt", x, y, yp=5)
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
|#
Raku
(formerly Perl 6)
Perl 5-ish
Written in the style of the 2nd Perl 5 example.
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 );
- Output:
1 1 2 1.4142 3 1.7321 1e+11 3.1623e+05
Idiomatic
Written in a more idiomatic style.
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));
- Output:
1 1 2 1.4142 3 1.7321 1e+11 3.1623e+05
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
- Output:
results.dat file contains:
1 1 2 1.4142 3 1.7321 1e+11 3.1623e+05
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.*/
output when using the default (internal) data:
1 1 2 1.4142 3 1.7321 1e+011 3.1623e+005
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)
Output:
1 | 1 2 | 1.4142135623730 3 | 1.7320508075688 100000000000.0000000000000 | 316227.76601683
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.
>> x = rand(10,1); y = rand(10,1);
>> writem("mytextfile.txt", [x,y]);
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.
>> x = rand(10,1); y = rand(10,1);
>> s = text( [x,y], "%10.8f" );
>> writem("mytextfile.txt", s);
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.
Ruby
# prepare test data
x = [1, 2, 3, 1e11]
y = x.collect { |xx| Math.sqrt xx }
xprecision = 3
yprecision = 5
# write the arrays
open('sqrt.dat', 'w') do |f|
x.zip(y) { |xx, yy| f.printf("%.*g\t%.*g\n", xprecision, xx, yprecision, yy) }
end
# print the result file
open('sqrt.dat', 'r') { |f| puts f.read }
Result:
1 1 2 1.4142 3 1.7321 1e+11 3.1623e+05
Run BASIC
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
- Output:
1.000| 1.00000 2.000| 1.41421 3.000| 1.73205 100000000000.000| 316227.76602
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;
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}")
}
}
Seed7
The library math.s7i defines the function sqrt. The operators sci and exp (defined in float.s7i) support writing floating point numbers in scientific notation.
$ 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;
- 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
Sidef
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)
- Output:
1 1 2 1.4142 3 1.7321 1e+11 3.1623e+05
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
]
]
obviously, with fix precisions, the following printing expression is more readable:
'%.3g\t%.5g\n' printf:{ xI . yI } on:fileStream
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)
<
Standard ML
fun writeDat (filename, x, y, xprec, yprec) = let
val os = TextIO.openOut filename
fun write_line (a, b) =
TextIO.output (os, Real.fmt (StringCvt.GEN (SOME xprec)) a ^ "\t" ^
Real.fmt (StringCvt.GEN (SOME yprec)) b ^ "\n")
in
ListPair.appEq write_line (x, y);
TextIO.closeOut os
end;
Example usage
- val x = [1.0, 2.0, 3.0, 1e11]; val x = [1.0,2.0,3.0,100000000000.0] : real list - val y = map Math.sqrt x; val y = [1.0,1.41421356237,1.73205080757,316227.766017] : real list - writeDat ("sqrt.dat", x, y, 3, 5); val it = () : unit - val is = TextIO.openIn "sqrt.dat"; val is = - : TextIO.instream - print (TextIO.inputAll is); 1.0 1.0 2.0 1.4142 3.0 1.7321 1E11 3.1623E05 val it = () : unit
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
- Output:
1 1 2 1.4142 3 1.7321 1.0e+11 316228
Tcl
set x {1 2 3 1e11}
foreach a $x {lappend y [expr {sqrt($a)}]}
set fh [open sqrt.dat w]
foreach a $x b $y {
puts $fh [format "%.*g\t%.*g" $xprecision $a $yprecision $b]
}
close $fh
set fh [open sqrt.dat]
puts [read $fh [file size sqrt.dat]]
close $fh
- Output:
1 1 2 1.4142 3 1.7321 1e+011 3.1623e+005
VBA
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
- Output:
1,000E000 1,00000E000 2,000E000 1,41421E000 3,000E000 1,73205E000 1,000E011 3,16228E005
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')?
}
}
- Output:
1, 1 2, 1.414 3, 1.732 1e+11, 316227.766
Wren
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.
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)
}
}
- Output:
The contents of filename.txt:
1 1 2 1.4142 3 1.7321 1e11 3.1623e05
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.
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));
]
- Output:
1 1 2 1.4142 3 1.7321 1e11 3.1623e5
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
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);
- Output:
$ cat floatArray 1 1 2 1.4142 3 1.7321 1e+11 3.1623e+05
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:
SAVE "myarray" DATA g()
- Programming Tasks
- Solutions by Programming Task
- File handling
- GUISS/Omit
- M4/Omit
- Retro/Omit
- UNIX Shell/Omit
- Ada
- ALGOL 68
- Amazing Hopper
- Applesoft BASIC
- AWK
- BASIC256
- BBC BASIC
- C
- C sharp
- C++
- COBOL
- Common Lisp
- D
- Delphi
- System.SysUtils
- System.IoUtils
- Elixir
- Erlang
- Euphoria
- F Sharp
- Forth
- Fortran
- FreeBASIC
- FutureBasic
- Go
- Haskell
- HicEst
- Icon
- Unicon
- IDL
- J
- Java
- Joy
- Jq
- Julia
- Kotlin
- Lingo
- Lua
- M2000 Interpreter
- Mathematica
- Wolfram Language
- MATLAB
- Octave
- Mercury
- NetRexx
- NewLISP
- Nim
- OCaml
- PARI/GP
- Pascal
- Perl
- Phix
- PicoLisp
- PL/I
- PowerShell
- PureBasic
- Python
- R
- Racket
- Raku
- Raven
- REXX
- Ring
- RLaB
- Ruby
- Run BASIC
- SAS
- Scala
- Seed7
- Sidef
- Smalltalk
- SPL
- Standard ML
- Stata
- Tcl
- VBA
- V (Vlang)
- V (Vlang) examples needing attention
- Examples needing attention
- Wren
- Wren-fmt
- XPL0
- Yabasic
- Zkl
- ZX Spectrum Basic