Data commit
This commit is contained in:
Ingy döt Net
parent
7387c8f97b
commit
cb5bb5e222
199093 changed files with 3378972 additions and 0 deletions
4
Task/Write-float-arrays-to-a-text-file/00-META.yaml
Normal file
4
Task/Write-float-arrays-to-a-text-file/00-META.yaml
Normal file
|
|
@ -0,0 +1,4 @@
|
|||
---
|
||||
category:
|
||||
- File_handling
|
||||
from: http://rosettacode.org/wiki/Write_float_arrays_to_a_text_file
|
||||
23
Task/Write-float-arrays-to-a-text-file/00-TASK.txt
Normal file
23
Task/Write-float-arrays-to-a-text-file/00-TASK.txt
Normal file
|
|
@ -0,0 +1,23 @@
|
|||
;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]].
|
||||
<br><br>
|
||||
|
||||
|
|
@ -0,0 +1,31 @@
|
|||
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
|
||||
)
|
||||
|
|
@ -0,0 +1,7 @@
|
|||
$ 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
|
||||
|
|
@ -0,0 +1,34 @@
|
|||
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;
|
||||
|
|
@ -0,0 +1,13 @@
|
|||
#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
|
||||
|
|
@ -0,0 +1,41 @@
|
|||
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
|
||||
|
|
@ -0,0 +1,10 @@
|
|||
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
|
||||
|
|
@ -0,0 +1,21 @@
|
|||
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%
|
||||
|
|
@ -0,0 +1,13 @@
|
|||
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';
|
||||
}
|
||||
|
|
@ -0,0 +1,31 @@
|
|||
#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;
|
||||
}
|
||||
|
|
@ -0,0 +1,19 @@
|
|||
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]);
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,18 @@
|
|||
#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;
|
||||
}
|
||||
|
|
@ -0,0 +1,4 @@
|
|||
1 1
|
||||
2 1.4142
|
||||
3 1.7321
|
||||
1e+11 3.1623e+05
|
||||
|
|
@ -0,0 +1,42 @@
|
|||
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.
|
||||
|
|
@ -0,0 +1,8 @@
|
|||
(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)))
|
||||
|
|
@ -0,0 +1,16 @@
|
|||
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);
|
||||
}
|
||||
|
|
@ -0,0 +1,35 @@
|
|||
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.
|
||||
|
|
@ -0,0 +1,22 @@
|
|||
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)
|
||||
|
|
@ -0,0 +1,22 @@
|
|||
-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 ).
|
||||
|
|
@ -0,0 +1,10 @@
|
|||
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)
|
||||
|
|
@ -0,0 +1,12 @@
|
|||
[<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
|
||||
|
|
@ -0,0 +1,15 @@
|
|||
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 ;
|
||||
|
|
@ -0,0 +1,26 @@
|
|||
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
|
||||
|
|
@ -0,0 +1,12 @@
|
|||
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
|
||||
|
|
@ -0,0 +1,13 @@
|
|||
' 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
|
||||
|
|
@ -0,0 +1,30 @@
|
|||
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
|
||||
|
|
@ -0,0 +1,30 @@
|
|||
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()
|
||||
}
|
||||
|
|
@ -0,0 +1,9 @@
|
|||
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
|
||||
|
|
@ -0,0 +1,8 @@
|
|||
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
|
||||
|
|
@ -0,0 +1,9 @@
|
|||
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
|
||||
|
|
@ -0,0 +1 @@
|
|||
DLG(Text=x, Format='i12', Edit=y, Format='F10.2', Y=0)
|
||||
|
|
@ -0,0 +1,4 @@
|
|||
1 1
|
||||
2 1.4142
|
||||
3 1.7321
|
||||
1E+011 3.1623E+005
|
||||
|
|
@ -0,0 +1,7 @@
|
|||
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
|
||||
|
|
@ -0,0 +1,13 @@
|
|||
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
|
||||
|
|
@ -0,0 +1 @@
|
|||
((0 j. 3 5) ": (,.%:) 1 2 3 1e11) fwrites 'whatever.txt' [ require 'fwrites'
|
||||
|
|
@ -0,0 +1,5 @@
|
|||
(0 j. 3 5) ": (,.%:) 1 2 3 1e11
|
||||
1.000 1.00000
|
||||
2.000 1.41421
|
||||
3.000 1.73205
|
||||
100000000000.000 316227.76602
|
||||
|
|
@ -0,0 +1,33 @@
|
|||
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) { }
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,6 @@
|
|||
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.
|
||||
|
|
@ -0,0 +1,4 @@
|
|||
[1, 2, 3, 1e11] as $x
|
||||
| $x | map(sqrt) as $y
|
||||
| range(0; $x|length) as $i
|
||||
| "\($x[$i]) \($y[$i])"
|
||||
|
|
@ -0,0 +1 @@
|
|||
$ jq -n -r -f Write_float_arrays_to_a_text_file.jq > filename
|
||||
|
|
@ -0,0 +1,5 @@
|
|||
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')
|
||||
|
|
@ -0,0 +1,18 @@
|
|||
// 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)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,15 @@
|
|||
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
|
||||
|
|
@ -0,0 +1,3 @@
|
|||
x = [1.0, PI, sqrt(2)]
|
||||
y = [2.0, log(10), sqrt(3)]
|
||||
saveFloatLists("floats.txt", x, y, 3, 5)
|
||||
|
|
@ -0,0 +1,16 @@
|
|||
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 )
|
||||
|
|
@ -0,0 +1,12 @@
|
|||
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
|
||||
|
|
@ -0,0 +1,6 @@
|
|||
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);
|
||||
|
|
@ -0,0 +1,6 @@
|
|||
exportPrec[path_, data1_, data2_, prec1_, prec2_] :=
|
||||
Export[
|
||||
path,
|
||||
Transpose[{Map[ToString[NumberForm[#, prec2]] &, data2], Map[ToString[NumberForm[#, prec1]] &, data1]}],
|
||||
"Table"
|
||||
]
|
||||
|
|
@ -0,0 +1,29 @@
|
|||
:- 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).
|
||||
|
|
@ -0,0 +1,35 @@
|
|||
/* 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
|
||||
|
|
@ -0,0 +1,26 @@
|
|||
; 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)
|
||||
|
|
@ -0,0 +1,18 @@
|
|||
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
|
||||
|
|
@ -0,0 +1,5 @@
|
|||
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
|
||||
|
|
@ -0,0 +1,12 @@
|
|||
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))
|
||||
)
|
||||
};
|
||||
|
|
@ -0,0 +1,13 @@
|
|||
*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;
|
||||
|
|
@ -0,0 +1,19 @@
|
|||
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.
|
||||
|
|
@ -0,0 +1,18 @@
|
|||
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);
|
||||
|
|
@ -0,0 +1,19 @@
|
|||
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);
|
||||
|
|
@ -0,0 +1,10 @@
|
|||
-->
|
||||
<span style="color: #008080;">constant</span> <span style="color: #000000;">x</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">2</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">3</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">1e11</span><span style="color: #0000FF;">},</span>
|
||||
<span style="color: #000000;">y</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">1.4142135623730951</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">1.7320508075688772</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">316227.76601683791</span><span style="color: #0000FF;">}</span>
|
||||
|
||||
<span style="color: #004080;">integer</span> <span style="color: #000000;">fn</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">open</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"filename"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"w"</span><span style="color: #0000FF;">)</span>
|
||||
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">x</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span>
|
||||
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">fn</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%.3g\t%.5g\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">x</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">],</span><span style="color: #000000;">y</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]})</span>
|
||||
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
|
||||
<span style="color: #7060A8;">close</span><span style="color: #0000FF;">(</span><span style="color: #000000;">fn</span><span style="color: #0000FF;">)</span>
|
||||
<!--
|
||||
|
|
@ -0,0 +1,11 @@
|
|||
(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) )
|
||||
|
|
@ -0,0 +1,8 @@
|
|||
$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
|
||||
|
|
@ -0,0 +1,28 @@
|
|||
#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
|
||||
|
|
@ -0,0 +1,5 @@
|
|||
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)
|
||||
|
|
@ -0,0 +1,15 @@
|
|||
>>> 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
|
||||
|
|
@ -0,0 +1,6 @@
|
|||
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)
|
||||
|
|
@ -0,0 +1,10 @@
|
|||
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)
|
||||
|
|
@ -0,0 +1,27 @@
|
|||
/*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.*/
|
||||
|
|
@ -0,0 +1,2 @@
|
|||
>> x = rand(10,1); y = rand(10,1);
|
||||
>> writem("mytextfile.txt", [x,y]);
|
||||
|
|
@ -0,0 +1,3 @@
|
|||
>> x = rand(10,1); y = rand(10,1);
|
||||
>> s = text( [x,y], "%10.8f" );
|
||||
>> writem("mytextfile.txt", s);
|
||||
|
|
@ -0,0 +1,23 @@
|
|||
#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
|
||||
|#
|
||||
|
|
@ -0,0 +1,12 @@
|
|||
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 );
|
||||
|
|
@ -0,0 +1,6 @@
|
|||
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));
|
||||
|
|
@ -0,0 +1,20 @@
|
|||
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
|
||||
|
|
@ -0,0 +1,21 @@
|
|||
# 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)
|
||||
|
|
@ -0,0 +1,13 @@
|
|||
# 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 }
|
||||
|
|
@ -0,0 +1,8 @@
|
|||
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
|
||||
|
|
@ -0,0 +1,11 @@
|
|||
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;
|
||||
|
|
@ -0,0 +1,9 @@
|
|||
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)
|
||||
<
|
||||
|
|
@ -0,0 +1,18 @@
|
|||
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}")
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,16 @@
|
|||
$ 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;
|
||||
|
|
@ -0,0 +1,14 @@
|
|||
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)
|
||||
|
|
@ -0,0 +1,10 @@
|
|||
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
|
||||
]
|
||||
]
|
||||
|
|
@ -0,0 +1 @@
|
|||
'%.3g\t%.5g\n' printf:{ xI . yI } on:fileStream
|
||||
|
|
@ -0,0 +1,9 @@
|
|||
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;
|
||||
|
|
@ -0,0 +1,11 @@
|
|||
* 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
|
||||
|
|
@ -0,0 +1,11 @@
|
|||
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
|
||||
|
|
@ -0,0 +1,22 @@
|
|||
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')?
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,11 @@
|
|||
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
|
||||
|
|
@ -0,0 +1,14 @@
|
|||
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)
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,13 @@
|
|||
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
|
||||
|
|
@ -0,0 +1 @@
|
|||
SAVE "myarray" DATA g()
|
||||
|
|
@ -0,0 +1,10 @@
|
|||
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);
|
||||
Loading…
Add table
Add a link
Reference in a new issue