Write float arrays to a text file: Difference between revisions
Write float arrays to a text file (view source)
Revision as of 11:12, 17 February 2024
, 3 months ago→{{header|Wren}}: Minor tidy
m (→{{header|Joy}}) |
m (→{{header|Wren}}: Minor tidy) |
||
(6 intermediate revisions by 5 users not shown) | |||
Line 29:
=={{header|Ada}}==
<
with Ada.Float_Text_IO; use Ada.Float_Text_IO;
with Ada.Numerics.Elementary_Functions; use Ada.Numerics.Elementary_Functions;
Line 62:
Write_columns (File, X, Y);
Close (File);
end Write_Float_Array;</
=={{header|ALGOL 68}}==
Line 69:
{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-1.18.0/algol68g-1.18.0-9h.tiny.el5.centos.fc11.i386.rpm/download 1.18.0-9h.tiny]}}
{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d] - due to extensive use of FORMATted transput}}
<
FILE f;
INT errno = open(f, filename, stand out channel);
Line 99:
print((line,new line))
OD
)</
{{out}}
<pre>
Line 113:
=={{header|Amazing Hopper}}==
Version hopper-FLOW:
<syntaxhighlight lang="amazing hopper">
#include <flow.h>
Line 127:
TOK-SEP( TAB ), SAVE-MAT(f, "filename.txt" )
END
</syntaxhighlight>
{{out}}
<pre>
Line 138:
=={{header|Applesoft BASIC}}==
<
110 F$ = "FILENAME.TXT"
120 READ X(0),X(1),X(2),X(3),Y(0),Y(1),Y(2),Y(3)
Line 178:
480 Q = NOT (O < 1)
490 NEXT Q
500 RETURN</
=={{header|AWK}}==
As usual, the order of array traversal in AWK is not necessarily the same as the input had:
<
> split("1 1.4142135623730951 1.7320508075688772 316227.76601683791",y);
> for(i in x)printf("%6g %.5g\n",x[i],y[i])}'
Line 187:
1 1
2 1.4142
3 1.7321</
For the text file part of the task, just redirect stdout to it.
=={{header|BASIC256}}==
<
x$ = explode(x$, " ")
Line 200:
writeline f, int(x$[i]) + chr(9) + round(sqrt(x$[i]),4)
next i
close f</
=={{header|BBC BASIC}}==
{{works with|BBC BASIC for Windows}}
<
x() = 1, 2, 3, 1E11
FOR i% = 0 TO 3
Line 224:
NEXT
CLOSE #outfile%</
{{out}}
<pre>
Line 234:
=={{header|C}}==
<
#include <math.h>
Line 251:
return 0;
}</
The file <tt>"floatArray"</tt> then contains the following:
<syntaxhighlight lang="text">1 1
2 1.4142
3 1.7321
1e+11 3.1623e+05</
=={{header|C sharp|C#}}==
<
class Program
Line 278:
outf.WriteLine(formatString, x[i], y[i]);
}
}</
{{out}}
Line 288:
=={{header|C++}}==
Function ''writedat()'':
<
void writedat(const char* filename,
InputIterator xbegin, InputIterator xend,
Line 300:
f << std::setprecision(xprecision) << *xbegin << '\t'
<< std::setprecision(yprecision) << *ybegin << '\n';
}</
Example:
<
#include <cmath> // ::sqrt()
#include <fstream>
Line 332:
}
return 0;
}</
{{out|Result}}
Line 343:
=={{header|COBOL}}==
<syntaxhighlight lang="cobol">
identification division.
program-id. wr-float.
Line 386:
.
end program wr-float.
</syntaxhighlight>
{{out|Result}}
<pre>
Line 396:
=={{header|Common Lisp}}==
<
(let* ((x (make-array 4 :initial-contents '(1 2 3 1e11)))
(y (map 'vector 'sqrt x))
Line 403:
(fmt (format nil "~~,1,~d,,G~~12t~~,~dG~~%" xprecision yprecision)))
(map nil (lambda (a b)
(format stream fmt a b)) x y)))</
Using [[CLISP]] I get
1. 1.0000
Line 411:
=={{header|D}}==
<
void main() {
Line 426:
write("float_array.txt", tmp);
}</
{{out}}
<pre>1 1
Line 435:
{{libheader| System.SysUtils}}
{{libheader| System.IoUtils}}
<syntaxhighlight lang="delphi">
program Write_float_arrays_to_a_text_file;
Line 470:
TFile.WriteAllLines('FloatArrayColumns.txt', Merge(ToString(x), ToString(y)));
end.</
{{out}}
<pre>1 1
Line 478:
=={{header|Elixir}}==
<
def task(xs, ys, fname, precision\\[]) do
xprecision = Keyword.get(precision, :x, 2)
Line 499:
precision = [x: 3, y: 5]
Write_float_arrays.task(x, y, fname, precision)
IO.puts File.read!(fname)</
{{out}}
Line 517:
Erlang thinks 1 is an integer. To persuade it otherwise I have to use 1.0.
<syntaxhighlight lang="erlang">
-module( write_float_arrays ).
Line 540:
[ok = io:fwrite( IO, Format, [X, Y]) || {X, Y} <- lists:zip( Xs, Ys)],
file:close( IO ).
</syntaxhighlight>
{{out}}
Line 549:
=={{header|Euphoria}}==
<
y = {1, 1.4142135623730951, 1.7320508075688772, 316227.76601683791}
Line 558:
printf(fn,"%.3g\t%.5g\n",{x[n],y[n]})
end for
close(fn)</
=={{header|F Sharp|F#}}==
<
let main argv =
let x = [ 1.; 2.; 3.; 1e11 ]
Line 572:
let line = sprintf "%.*g\t%.*g"
List.iter2 (fun x y -> file.WriteLine (line xprecision x yprecision y)) x y
0</
Content of File, visualized with TAB=8
<pre>1 1
Line 582:
{{works with|GNU Forth}}
<
create y 1e f, 2e fsqrt f, 3e fsqrt f, 1e11 fsqrt f,
Line 596:
outfile-id stdout to outfile-id
close-file throw ;</
=={{header|Fortran}}==
=== Fortran 90 ===
{{works with|Fortran|90 and later}}
<
implicit none
Line 626:
end subroutine writexy
end program writefloats</
The arrays x and y should have same bounds (and size); this constraint is not checked.
=== Fortran 77 ===
<
integer i
double precision x(4), y(4)
Line 642:
open(unit=15, file='two_cols.txt', status='new')
write(15, '(f20.3,f21.4)') (x(i), y(i), i = 1, 4)
end</
=={{header|FreeBASIC}}==
<
Dim x(0 To 3) As Double = {1, 2, 3, 1e11}
Line 657:
Print #1, Using "#^^^^"; x(3);
Print #1, Spc(2); Using "##.####^^^^"; y(3)
Close #1</
Contents of output.txt :
{{out}}
Line 666:
1E+11 3.1623E+05
</pre>
=={{header|FutureBasic}}==
<syntaxhighlight lang="futurebasic">
local fn DoIt
NSUInteger i
CFStringRef s
CFArrayRef x = @[@1, @2, @3, @1e11]
CFArrayRef y = @[@1, @1.4142135623730951, @1.7320508075688772, @316227.76601683791]
CFMutableStringRef mutStr = fn MutableStringWithCapacity(0)
CFURLRef desktopURL = fn FileManagerURLForDirectory( NSDesktopDirectory, NSUserDomainMask )
CFURLRef url = fn URLByAppendingPathComponent( desktopURL, @"Array_to_file.txt" )
for i = 0 to 3
if ( i < 3 )
s = fn StringWithFormat( @"%ld \t", fn NumberIntegerValue( x[i] ) )
MutableStringAppendString( mutStr, s )
s = fn StringWithFormat( @"%.4f\n", fn NumberFloatValue( y[i] ) )
MutableStringAppendString( mutStr, s )
else
s = fn StringWithFormat( @"%.e\t", fn NumberFloatValue( x[i] ) )
MutableStringAppendString( mutStr, s )
s = fn StringWithFormat( @"%.4e\n", fn NumberFloatValue( y[i] ) )
MutableStringAppendString( mutStr, s )
end if
next
fn StringWriteToURL( mutStr, url, YES, NSUTF8StringEncoding, NULL )
print mutStr
end fn
fn DoIt
HandleEven
</syntaxhighlight>
{{output}}
<pre>
1 1.0000
2 1.4142
3 1.7321
1e+11 3.1623e+05
</pre>
=={{header|Go}}==
<
import (
Line 697 ⟶ 740:
}
f.Close()
}</
File contents:
<pre>
Line 708 ⟶ 751:
=={{header|Haskell}}==
Probably not very idiomatic but oh well
<
import Text.Printf
import Control.Monad
Line 716 ⟶ 759:
-- Haskell's printf doesn't support a precision given as an argument for some reason, so we insert it into the format manually:
let writeLine = hPrintf h $ "%." ++ show xprec ++ "g\t%." ++ show yprec ++ "g\n" in
zipWithM_ writeLine x y</
Example usage
Prelude> let x = [1, 2, 3, 1e11]
Line 730 ⟶ 773:
Alternative solution without Printf
<
import Control.Monad
import Numeric
Line 737 ⟶ 780:
withFile filename WriteMode $ \h ->
let writeLine a b = hPutStrLn h $ showGFloat (Just xprec) a "" ++ "\t" ++ showGFloat (Just yprec) b "" in
zipWithM_ writeLine x y</
=={{header|HicEst}}==
<
CHARACTER :: outP = "Test.txt"
Line 748 ⟶ 791:
DO i = 1, n
WRITE(FIle=outP, Format='F5, F10.3') x(i), y(i)
ENDDO </
Alternative: Display or Edit the formatted arrays in a [http://www.HicEst.com/MatrixExplorer spreadsheet-like dialog] with a common scroll bar.
The menu More - Export - File writes the formatted arrays to a file:
<
=={{header|Icon}} and {{header|Unicon}}==
Line 757 ⟶ 800:
The following works in both languages.
<
procedure main()
Line 763 ⟶ 806:
every put(y := [], sqrt(!x))
every fprintf(open("filename","w"),"%10.2e %10.4e\n", x[i := 1 to *x], y[i])
end</
Contents of <tt>filename</tt> after running:
Line 794 ⟶ 837:
The file <tt>"datafile.txt"</tt> then contains the following:
<
2 1.4142
3 1.7321
1E+011 3.1623E+005</
This is fairly ugly and un-IDLish.
Line 807 ⟶ 850:
=={{header|J}}==
<
x =. 1 2 3 1e11
Line 819 ⟶ 862:
data =. (0 j. xprecision,yprecision) ": x,.y
data fwrites filename</
Or, more concisely:
<
This loses all of the inline comments and names, and instead relies on the reader's understanding of the purpose of each of the names (for example: 3 is the precision of the first column, and 5 is the precision of the second column).
Line 829 ⟶ 872:
Note that J's idea of precision here is "positions after the decimal point":
<
1.000 1.00000
2.000 1.41421
3.000 1.73205
100000000000.000 316227.76602</
=={{header|Java}}==
<
public class FloatArray {
Line 868 ⟶ 911:
} catch (IOException e) { }
}
}</
=={{header|Joy}}==
<syntaxhighlight lang=
DEFINE write-floats ==
['g 0] [formatf] enconcat map rollup
Line 890 ⟶ 933:
=={{header|jq}}==
''' Program''':
<
| $x | map(sqrt) as $y
| range(0; $x|length) as $i
| "\($x[$i]) \($y[$i])"</
''' Execution''':
To write the output to "filename":
<
=={{header|Julia}}==
<
yprecision = 5
x = round.([1, 2, 3, 1e11],xprecision)
y = round.([1, 1.4142135623730951, 1.7320508075688772, 316227.76601683791],yprecision)
writedlm("filename", [x y], '\t')</
=={{header|Kotlin}}==
<
import java.io.File
Line 923 ⟶ 966:
}
}
}</
Contents of 'output.txt':
Line 934 ⟶ 977:
=={{header|Lingo}}==
<
eol = numtochar(10) -- LF
fp = xtra("fileIO").new()
Line 948 ⟶ 991:
end repeat
fp.closeFile()
end</
<
y = [2.0, log(10), sqrt(3)]
saveFloatLists("floats.txt", x, y, 3, 5)</
=={{header|Lua}}==
<
x = { 1, 2, 3, 1e11 }
Line 970 ⟶ 1,013:
end
io.close( fp )</
=={{header|M2000 Interpreter}}==
Precision here is just Round (as school rounding)
Print round(2.5,0)=3
Print round(1.5,0)=2
Print round(-2.5,0)=-3
Print round(-1.5,0)=-2
<syntaxhighlight lang="m2000 interpreter">
Module Test1 (filename$, x, xprecision, y, yprecision) {
locale 1033 // set decimal point symbol to "."
// using: for wide output // for UTF16LE
// here we use ANSI (8bit per character)
open filename$ for output as #f
for i=0 to len(x)-1
print #f, format$("{0} {1}", round(x#val(i),xprecision-1), round(y#val(i), yprecision-1))
next
close #f
win "notepad", dir$+filename$
}
Test1 "OutFloat.num", (1, 2, 3, 1.e11),3, (1, 1.4142135623730951, 1.7320508075688772, 316227.76601683791), 5
</syntaxhighlight>
{{out}}
<pre>1 1
2 1.4142
3 1.7321
100000000000 316227.766</pre>
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<
Export[
path,
Transpose[{Map[ToString[NumberForm[#, prec2]] &, data2], Map[ToString[NumberForm[#, prec1]] &, data1]}],
"Table"
]</
=={{header|MATLAB}} / {{header|Octave}}==
<
y = [1, 1.4142135623730951, 1.7320508075688772, 316227.76601683791];
fid = fopen('filename','w')
fprintf(fid,'%.3g\t%.5g\n',[x;y]);
fclose(fid); </
{{out}}
Line 996 ⟶ 1,070:
=={{header|Mercury}}==
<
:- interface.
Line 1,024 ⟶ 1,098:
write_dat(File, XPrec, YPrec, X, Y, !IO) :-
io.format(File, "%.*g\t%.*g\n", [i(XPrec), f(X), i(YPrec), f(Y)], !IO).</
File contents:
Line 1,036 ⟶ 1,110:
=={{header|NetRexx}}==
<
options replace format comments java crossref savelog symbols nobinary
Line 1,071 ⟶ 1,145:
return
</syntaxhighlight>
{{out}}
<pre>
Line 1,081 ⟶ 1,155:
=={{header|NewLISP}}==
<
; url: http://rosettacode.org/wiki/Write_float_arrays_to_a_text_file
; author: oofoe 2012-01-30
Line 1,106 ⟶ 1,180:
(print (read-file "filename.chan"))
(exit)</
{{out}}
Line 1,117 ⟶ 1,191:
=={{header|Nim}}==
<
const OutFileName = "floatarr2file.txt"
Line 1,134 ⟶ 1,208:
OutFileName.writeFile res
var res2 = OutFileName.readFile()
echo res2</
{{out}}
<pre>1.00 1.0000
Line 1,142 ⟶ 1,216:
=={{header|OCaml}}==
<
let oc = open_out filename in
let write_line a b = Printf.fprintf oc "%.*g\t%.*g\n" xprec a yprec b in
List.iter2 write_line x y;
close_out oc</
Example usage
# let x = [1.0; 2.0; 3.0; 1e11];;
Line 1,170 ⟶ 1,244:
=={{header|PARI/GP}}==
{{works with|PARI/GP|2.5.0 and above}}
<
Strprintf(if(x>=10^pr,
Str("%.",pr-1,"e")
Line 1,181 ⟶ 1,255:
write("filename",f(x[i],xprec),"\t",f(y[i],yprec))
)
};</
=={{header|Pascal}}==
<
const
Line 1,202 ⟶ 1,276:
writeln (filename, x[i]:baseDigits+xprecision, sqrt(x[i]):baseDigits+yprecision);
close (filename);
end.</
File contents
<pre>
Line 1,212 ⟶ 1,286:
=={{header|Perl}}==
<
sub writedat {
Line 1,229 ⟶ 1,303:
my @y = map sqrt, @x;
writedat("sqrt.dat", \@x, \@y);</
File contents
<pre>
Line 1,240 ⟶ 1,314:
Alternatively, with the CPAN List::MoreUtils package:
<
use List::MoreUtils qw(each_array);
Line 1,258 ⟶ 1,332:
my @y = map sqrt, @x;
writedat("sqrt.dat", \@x, \@y);</
=={{header|Phix}}==
Copy of [[Write_float_arrays_to_a_text_file#Euphoria|Euphoria]]
<!--<
<span style="color: #008080;">constant</span> <span style="color: #000000;">x</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">2</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">3</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">1e11</span><span style="color: #0000FF;">},</span>
<span style="color: #000000;">y</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">1.4142135623730951</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">1.7320508075688772</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">316227.76601683791</span><span style="color: #0000FF;">}</span>
Line 1,271 ⟶ 1,345:
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<span style="color: #7060A8;">close</span><span style="color: #0000FF;">(</span><span style="color: #000000;">fn</span><span style="color: #0000FF;">)</span>
<!--</
File contents:
<pre>
Line 1,282 ⟶ 1,356:
=={{header|PicoLisp}}==
An exponential format like "1e11" is not supported
<
(scl 7)
Line 1,292 ⟶ 1,366:
(round Y *Yprecision) ) )
(1.0 2.0 3.0)
(1.0 1.414213562 1.732050807) )</
{{out}}
<pre>1.000 1.00000
Line 1,299 ⟶ 1,373:
=={{header|PL/I}}==
<
aaa: Proc Options(main);
declare X(5) float (9) initial (1, 2, 3, 4, 5),
Line 1,311 ⟶ 1,385:
(skip,e(19,x_precision),
x(2),e(24,y_precision));
end;</
{{out}}
<pre> 1.000000000E+0000 9.0000000000000000E+0000
Line 1,320 ⟶ 1,394:
=={{header|PowerShell}}==
<
$y = @(1, 1.4142135623730951, 1.7320508075688772, 316227.76601683791)
$xprecision = 3
Line 1,328 ⟶ 1,402:
}
($arr | format-table -HideTableHeaders | Out-String).Trim() > filename.txt
</syntaxhighlight>
<b>Output:</b>
<pre>
Line 1,338 ⟶ 1,412:
=={{header|PureBasic}}==
<
DataSection
Line 1,365 ⟶ 1,439:
CloseFile(fileID)
EndIf
EndIf</
{{out}} to text file:
<pre>1.000 1.00000
Line 1,374 ⟶ 1,448:
=={{header|Python}}==
{{works with|Python|2.6}}
<
def writedat(filename, x, y, xprecision=3, yprecision=5):
with open(filename,'w') as f:
for a, b in itertools.izip(x, y):
print >> f, "%.*g\t%.*g" % (xprecision, a, yprecision, b)</
Example usage
<
>>> x = [1, 2, 3, 1e11]
>>> y = map(math.sqrt, x)
Line 1,394 ⟶ 1,468:
2 1.4142
3 1.7321
1e+011 3.1623e+005</
{{works with|Python|3}}
<
with open(filename,'w') as f:
for a, b in zip(x, y):
print("%.*g\t%.*g" % (xprecision, a, yprecision, b), file=f)
#or, using the new-style formatting:
#print("{1:.{0}g}\t{3:.{2}g}".format(xprecision, a, yprecision, b), file=f)</
=={{header|R}}==
<
fx <- formatC(x, digits=xprecision, format="g", flag="-")
fy <- formatC(y, digits=yprecision, format="g", flag="-")
Line 1,414 ⟶ 1,488:
x <- c(1, 2, 3, 1e11)
y <- sqrt(x)
writexy("test.txt", x, y, yp=5)</
=={{header|Racket}}==
<syntaxhighlight lang="racket">
#lang racket
Line 1,441 ⟶ 1,515:
100000000000 316227.76602
|#
</syntaxhighlight>
=={{header|Raku}}==
Line 1,447 ⟶ 1,521:
===Perl 5-ish===
Written in the style of the 2nd Perl 5 example.
<syntaxhighlight lang="raku"
my $fh = open $filename, :w;
for flat @x Z @y -> $x, $y {
Line 1,458 ⟶ 1,532:
my @y = @x.map({.sqrt});
writefloat( 'sqrt.dat', @x, @y );</
{{out}}
<pre>1 1
Line 1,466 ⟶ 1,540:
===Idiomatic===
Written in a more idiomatic style.
<syntaxhighlight lang="raku"
open($filename, :w).print:
join '', flat (@x».fmt("%.{$x-precision}g") X "\t") Z (@y».fmt("%.{$y-precision}g") X "\n");
}
my @x = 1, 2, 3, 1e11;
writefloat('sqrt.dat', @x, @x».sqrt, :y-precision(5));</
{{out}}
<pre>1 1
Line 1,479 ⟶ 1,553:
=={{header|Raven}}==
<
5 as $yprecision
Line 1,498 ⟶ 1,572:
4 each as $i
$f $b $i get $a $i get print2
$results "" join "results.dat" write</
{{out}}
results.dat file contains:
Line 1,507 ⟶ 1,581:
=={{header|REXX}}==
<
numeric digits 1000 /*allow use of a huge number of digits.*/
oFID= 'filename' /*name of the output File IDentifier.*/
Line 1,533 ⟶ 1,607:
z=int || fraction || exponent /*format # (as per rules)*/
if datatype(z,'W') then return format(oz/1,,0) /*is it a whole number ? */
return format(oz/1,,,3,0) /*3 dec. digs in exponent.*/</
'''output''' when using the default (internal) data:
<pre>
Line 1,543 ⟶ 1,617:
=={{header|Ring}}==
<
# Project : Write float arrays to a text file
Line 1,565 ⟶ 1,639:
end
fclose(fp)
</syntaxhighlight>
Output:
<pre>
Line 1,579 ⟶ 1,653:
1. Direct writing of the numerical data to the file of an array using function ''writem''. Here the writing format
is specified using the global property that is accessible through function ''format''.
<syntaxhighlight lang="rlab">
>> x = rand(10,1); y = rand(10,1);
>> writem("mytextfile.txt", [x,y]);
</syntaxhighlight>
2. Converting the numerical data to text, and then writing the text to the file, using the same function ''writem''.
Here, the writing format is specified through ''text'' function, and the result is written as a plain string matrix.
<syntaxhighlight lang="rlab">
>> x = rand(10,1); y = rand(10,1);
>> s = text( [x,y], "%10.8f" );
>> writem("mytextfile.txt", s);
</syntaxhighlight>
Please note, ''writem'' function in RLaB can operate in two-fold fashion. RLaB keeps track of the open files that were created using the built-in function ''open''.
Line 1,599 ⟶ 1,673:
=={{header|Ruby}}==
<
x = [1, 2, 3, 1e11]
y = x.collect { |xx| Math.sqrt xx }
Line 1,611 ⟶ 1,685:
# print the result file
open('sqrt.dat', 'r') { |f| puts f.read }</
Result:
<pre>1 1
Line 1,619 ⟶ 1,693:
=={{header|Run BASIC}}==
<
y$ = "1, 1.4142135623730951, 1.7320508075688772, 316227.76601683791"
Line 1,626 ⟶ 1,700:
print #f, using("##############.###",val(word$(x$,i,",")));"|";using("#######.#####",val(word$(y$,i,",")))
next i
close #f</
{{out}}
<pre> 1.000| 1.00000
Line 1,634 ⟶ 1,708:
=={{header|SAS}}==
<
input x y;
file "output.txt";
Line 1,644 ⟶ 1,718:
1e11 316227.76601683791
;
run;</
=={{header|Scala}}==
{{libheader|Scala}}<
object FloatArray extends App {
Line 1,664 ⟶ 1,738:
case e: IOException => println(s"Running Example failed: ${e.getMessage}")
}
}</
=={{header|Seed7}}==
The library [http://seed7.sourceforge.net/libraries/math.htm math.s7i] defines the function [http://seed7.sourceforge.net/libraries/math.htm#sqrt%28ref_float%29 sqrt]. The operators [http://seed7.sourceforge.net/libraries/float.htm#%28ref_float%29sci%28ref_integer%29 sci] and [http://seed7.sourceforge.net/libraries/float.htm#%28in_string%29exp%28in_integer%29 exp] (defined in [http://seed7.sourceforge.net/libraries/float.htm float.s7i]) support writing floating point numbers in scientific notation.<
include "float.s7i";
include "math.s7i";
Line 1,682 ⟶ 1,756:
end for;
close(aFile);
end func;</
1.000e+00 1.00000e+00
2.000e+00 1.41421e+00
Line 1,690 ⟶ 1,764:
=={{header|Sidef}}==
{{trans|Raku}}
<
var fh = File(filename).open_w
Line 1,703 ⟶ 1,777:
var y = x.map{.sqrt}
writedat('sqrt.dat', x, y)</
{{out}}
<pre>
Line 1,713 ⟶ 1,787:
=={{header|Smalltalk}}==
{{works with | Smalltalk/X}}
<
y := x collect:#sqrt.
xprecision := 3.
Line 1,722 ⟶ 1,796:
'%.*g\t%.*g\n' printf:{ xprecision . xI . yprecision . yI } on:fileStream
]
]</
obviously, with fix precisions, the following printing expression is more readable:
<
=={{header|SPL}}==
<
y = [1, 1.4142135623730951, 1.7320508075688772, 316227.76601683791]
xprecision = 3
Line 1,735 ⟶ 1,809:
s2 = #.str(y[i],"g"+yprecision)
#.writeline("file.txt",s1+#.tab+s2)
<</
=={{header|Standard ML}}==
<
val os = TextIO.openOut filename
fun write_line (a, b) =
Line 1,746 ⟶ 1,820:
ListPair.appEq write_line (x, y);
TextIO.closeOut os
end;</
Example usage
- val x = [1.0, 2.0, 3.0, 1e11];
Line 1,765 ⟶ 1,839:
=={{header|Stata}}==
<
clear
mat x=1\2\3\1e11
Line 1,775 ⟶ 1,849:
* Save as text file
export delim file.txt, delim(" ") novar datafmt replace</
{{out}}
Line 1,785 ⟶ 1,859:
=={{header|Tcl}}==
<
foreach a $x {lappend y [expr {sqrt($a)}]}
set fh [open sqrt.dat w]
Line 1,795 ⟶ 1,869:
set fh [open sqrt.dat]
puts [read $fh [file size sqrt.dat]]
close $fh</
{{out}}
<pre>1 1
Line 1,803 ⟶ 1,877:
=={{header|VBA}}==
<
x = [{1, 2, 3, 1e11}]
y = [{1, 1.4142135623730951, 1.7320508075688772, 316227.76601683791}]
Line 1,813 ⟶ 1,887:
Next i
Close TextFile
End Sub</
<pre>1,000E000 1,00000E000
2,000E000 1,41421E000
Line 1,820 ⟶ 1,894:
</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]
Line 1,843 ⟶ 1,917:
f.write_string('${x[i]:3}, ${y[i]:1G}\n')?
}
}</
{{out}}
<pre> 1, 1
Line 1,856 ⟶ 1,930:
In the final example, we need to force exponential format as numbers of this size would normally be printed in decimal format.
<
import "./fmt" for Fmt
var x = [1, 2, 3, 1e11]
Line 1,869 ⟶ 1,943:
file.writeBytes(s)
}
}</
{{out}}
Line 1,878 ⟶ 1,952:
3 1.7321
1e11 3.1623e05
</pre>
=={{header|XPL0}}==
Output is redirected to the file like this: writefloat > filename
Precision here refers to the size of the numeric field. A precision of 5
means a total of five digits, e.g: 1.2345. XPL0 translates this as one place
before the decimal point and four places after it.
<syntaxhighlight lang "XPL0">include xpllib; \for Print
real X, Y;
int N;
[X:= [1., 2., 3., 1e11];
Y:= [1., 1.4142135623730951, 1.7320508075688772, 316227.76601683791];
for N:= 0 to 3 do
Print("%1.2g\t%1.4g\n", X(N), Y(N));
]</syntaxhighlight>
{{out}}
<pre>
1 1
2 1.4142
3 1.7321
1e11 3.1623e5
</pre>
=={{header|Yabasic}}==
<
pr1 = 3 : pr2 = 5
Line 1,893 ⟶ 1,990:
next i
close #f</
=={{header|zkl}}==
<
f :=File(filename,"w");
fmt:="%%.%dg\t%%.%dg".fmt(xprecision,yprecision).fmt; // "%.3g\t%.5g".fmt
Line 1,905 ⟶ 2,002:
xs,ys := T(1.0, 2.0, 3.0, 1e11), xs.apply("sqrt");
xprecision,yprecision := 3,5;
writeFloatArraysToFile("floatArray.txt", xs,xprecision, ys,yprecision);</
{{out}}
<pre>
Line 1,922 ⟶ 2,019:
Here we write the contents of the array g() to a file:
<
|