Write float arrays to a text file: Difference between revisions
m (Removed annoying backticks, changed Java highlighting to java5) |
m (split line) |
||
Line 5: | Line 5: | ||
For example, considering: |
For example, considering: |
||
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}; |
||
/* sqrt(x) */ |
|||
xprecision = 3; |
xprecision = 3; |
||
yprecision = 5; |
yprecision = 5; |
Revision as of 00:29, 2 March 2009
You are encouraged to solve this task according to the task description, using any language you may know.
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 is:
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
<lang ada> with Ada.Text_IO; use Ada.Text_IO; with Ada.Float_Text_IO; use Ada.Float_Text_IO; with Ada.Numerics.Elementary_Functions; use Ada.Numerics.Elementary_Functions;
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; </lang>
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:
[]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
C
<lang 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]); if (x[i] > 10000 || x[i] < .00001 || y[i] > 10000 || y[i] < .00001) { /* profoundly arbitrary on my part */ fprintf(filePtr, "%1.3e\t%1.5e\n", x[i], y[i]); } else { fprintf(filePtr, "%1.3f\t%1.5f\n", x[i], y[i]); } }
return 0;
} </lang>
The file "floatArray" then contains the following:
1.000 1.00000 2.000 1.41421 3.000 1.73205 1.000e+11 3.16228e+05
c99 version
<lang c> /** gcc -Wall -std=c99 *.c -o a && a */
- include <limits.h> // LINE_MAX, see http://www.opengroup.org/onlinepubs/009695399/basedefs/limits.h.html
- ifndef LINE_MAX
- define LINE_MAX 2048
- endif
- include <math.h>
- include <stdio.h>
- include <stdlib.h> // exit()
static int writedat(size_t n; const char* filename, double x[n], double y[n], size_t n, int xprecision, int yprecision) {
FILE* f = NULL; if ((f = fopen(filename, "w")) == NULL) goto error;
for (size_t i = 0; i < n; ++i) if (fprintf(f, "%.*g\t%.*g\n", xprecision, x[i], yprecision, y[i]) < 0) goto error;
if (fclose(f) == EOF) goto error;
return 0; // ok
error: //NOTE: caller of this function should deal with `errno` on error return 1; // error
}
int main(int argc, char **argv) {
// prepare test data double x[] = {1,2,3,1e11}; const size_t xsize = sizeof(x) / sizeof(*x); double y[xsize]; for (size_t i = 0; i < xsize; i++) y[i] = sqrt(x[i]);
// write arrays const char* filename = "sqrt.dat"; const int save_errno = errno; errno = 0; if (writedat(filename, x, y, xsize, 3, 5) != 0) { perror("writedat"); exit(1); } errno = save_errno; // print the result file FILE* f = NULL; if ((f = fopen(filename, "r")) == NULL) exit(1); char line[LINE_MAX]; while (fgets(line, LINE_MAX, f) != NULL) fputs(line, stdout);
/* int c = EOF; */ /* while ((c = fgetc(f)) != EOF) */ /* putchar(c); */
return 0;
} </lang> It prints:
1 1 2 1.4142 3 1.7321 1e+011 3.1623e+005
C++
Function writedat(): <lang cpp>
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'; }
</lang> Example: <lang cpp>
#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; }
</lang> Result:
1 1 2 1.4142 3 1.7321 1e+11 3.1623e+05
Fortran
In ANSI FORTRAN 77 or later use OPEN STATEMENT, and formatted WRITE statement with implied DO loop:
real x(4), y(4) data x / 1.0, 2.0, 4.0, 1.0e11 / do 10 i = 1, 4 y = sqrt(x) 10 continue open(unit=15, file='two_cols.txt', status='new') write(15,'(f20.3,f21.4)') (x(I), y(I), I = 1, 4) end
Haskell
Probably not very idiomatic but oh well
import System.IO import Text.Printf import Control.Monad writeDat filename x y xprec yprec = do h <- openFile filename WriteMode -- 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") zipWithM_ writeLine x y hClose h
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
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
Java
<lang java5>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) { } }
}</lang>
OCaml
<lang ocaml>let write_dat filename x y ?(xprec=3) ?(yprec=5) () =
let oc = open_out filename in let write_line a b = Printf.fprintf oc "%.*g\t%.*g\n" xprec a yprec b in List.iter2 write_line x y; close_out oc</lang>
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 = ()
Perl
<lang perl>sub writedat {
my ($filename, $x, $y, $xprecision, $yprecision) = @_; $xprecision ||= 3; $yprecision ||= 5; open FH, ">$filename" or die "Can't open file: $!"; foreach my $i (0 .. $#$x) { printf FH "%.*g\t%.*g\n", $xprecision, $x->[$i], $yprecision, $y->[$i]; } close FH;
}
my @x = (1, 2, 3, 1e11); my @y = map sqrt, @x;
writedat("sqrt.dat", \@x, \@y);</lang> File contents
1 1 2 1.4142 3 1.7321 1e+11 3.1623e+05
Python
<lang python>import itertools def writedat(filename, x, y, xprecision=3, yprecision=5):
with open(filename,'w') as f: for a, b in itertools.izip(x, y): print >> f, "%.*g\t%.*g" % (xprecision, a, yprecision, b)</lang>
Example usage <lang python>
>>> 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
</lang>
<lang python>def writedat(filename, x, y, xprecision=3, yprecision=5):
with open(filename,'w') as f: for a, b in zip(x, y): print("%.*g\t%.*g" % (xprecision, a, yprecision, b), file=f) #or, using the new-style formatting: #print("{1:.{0}g}\t{3:.{2}g}".format(xprecision, a, yprecision, b), file=f)</lang>
Ruby
<lang 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 } </lang> Result: <lang ruby> 1 1 2 1.4142 3 1.7321 1e+11 3.1623e+05 </lang>