high_res_cube/utils/average_fields.cpp

/*
 *  Average fields:
 *
 *  This program averages n input files and outputs the result.  It
 *  assumes that the inputs are all in single-precision IEEE-BE ("big
 *  endian") format.  Internally, the averaging is done in IEEE double
 *  precision and the final result is converted back into IEEE-BE
 *  immediately before being written.
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <sys/types.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <unistd.h>

#include <iostream>
#include <fstream>
#include <string>

#define uint32  unsigned int

#define BUF_SIZE 65536
#define htonl(A)  ((((uint32)(A) & 0xff000000) >> 24) | \
                   (((uint32)(A) & 0x00ff0000) >> 8)  | \
                   (((uint32)(A) & 0x0000ff00) << 8)  | \
                   (((uint32)(A) & 0x000000ff) << 24))
#define bswap32(A)  ( ((uint32)(A) >> 24) | \
                      (((uint32)(A) & 0x00ff0000) >> 8) | \
                      (((uint32)(A) & 0x0000ff00) << 8) | \
                      ((uint32)(A) << 24) )

int
main( int argc, char** argv )
{
    char buff[BUF_SIZE];
    int i;
    int nbytes;
    using namespace std;
    struct stat st;
    void * vptr;
    double * dptr;
    float * fptr;
    uint32 u32;

    if (argc < 4) {
        cerr << "\nError: at least three file names must be supplied." << endl;
        exit(1);
    }

    string fname(argv[1]);
    stat(fname.c_str(), &st);
    nbytes = st.st_size;
    cout << "The file \"" << fname 
         << "\" has size: " << nbytes << " bytes" << endl;
    int ndouble = nbytes/4;

    dptr = new double[ndouble];
    if (dptr == NULL) {
        cerr << "\nError: unable to allocate sufficient memory." << endl;
        exit(1);
    }
    for (int j=0; j<ndouble; j++) {
        dptr[j] = 0.0;
    }

    for (i=1; i<(argc-1); i++) {
        cout << "  arg " << i << " is " << argv[i] << endl;

        stat(argv[i], &st);
        if (st.st_size != nbytes) {
            cerr << "\nError: files size does not agree for file \"" 
                 << argv[i] << "\"." << endl;
            exit(1);
        }
        int fd;
        if ((fd = open(argv[i], O_RDONLY)) == -1) {
            cerr << "\nError: can't open() file \"" << argv[i] << "\"." << endl;
            exit(1);
        }
        vptr = mmap( (void *)0, (size_t)(nbytes), 
                     PROT_READ, MAP_PRIVATE, fd, 0 );
        if (vptr == NULL) {
            cerr << "\nError: can't mmap() the file \"" << argv[i] << "\"." << endl;
            exit(1);
        }

        //  Average the fields
        unsigned int * uip = (unsigned int *)(vptr);
        for (int j=0; j<ndouble; j++) {
            u32 = *uip;
            unsigned int i32s = bswap32(u32);
            float flt = *((float *)(&i32s));
            //  cout << "   flt = " << flt << endl;
            dptr[j] += double(flt);
            uip++;
        }

        munmap(vptr, (size_t)(nbytes));
    }

    double denom = 1.0/double(argc - 2);
    fptr = new float[ndouble];
    for (int j=0; j<ndouble; j++) {
        float flt = (float(denom * dptr[j]));
        unsigned int i32s = bswap32(*((unsigned int *)(&flt)));
        fptr[j] = *((float *)(&i32s));
    }
    i = argc - 1;
    int fdo;
    if ((fdo = open(argv[i], (O_CREAT | O_WRONLY), 
                    (S_IRUSR | S_IWUSR))) == -1) {
        cerr << "\nError: can't open() file \"" << argv[i] << "\"." << endl;
            exit(1);
    }
    char * aptr = (char *)(fptr);
    size_t inc_bytes_out;
    size_t tot_bytes_out = 0;
    bool write_needed = true;
    while (write_needed) {
        inc_bytes_out = write(fdo, (void *)(aptr + tot_bytes_out), 
                               (size_t)(nbytes - tot_bytes_out));
        tot_bytes_out += inc_bytes_out;
        if ((inc_bytes_out == 0) && (fdo != -1))
            write_needed = false;
    }

    delete[] dptr;
    delete[] fptr;
    return 0;
}
1	edhill	1.1	/*
2			* Average fields:
3			*
4			* This program averages n input files and outputs the result. It
5			* assumes that the inputs are all in single-precision IEEE-BE ("big
6			* endian") format. Internally, the averaging is done in IEEE double
7			* precision and the final result is converted back into IEEE-BE
8			* immediately before being written.
9			*/
10
11			#include <stdio.h>
12			#include <stdlib.h>
13			#include <string.h>
14
15			#include <sys/types.h>
16			#include <sys/stat.h>
17			#include <sys/mman.h>
18			#include <fcntl.h>
19			#include <unistd.h>
20
21			#include <iostream>
22			#include <fstream>
23			#include <string>
24
25			#define uint32 unsigned int
26
27			#define BUF_SIZE 65536
28			#define htonl(A) ((((uint32)(A) & 0xff000000) >> 24) \| \
29			(((uint32)(A) & 0x00ff0000) >> 8) \| \
30			(((uint32)(A) & 0x0000ff00) << 8) \| \
31			(((uint32)(A) & 0x000000ff) << 24))
32			#define bswap32(A) ( ((uint32)(A) >> 24) \| \
33			(((uint32)(A) & 0x00ff0000) >> 8) \| \
34			(((uint32)(A) & 0x0000ff00) << 8) \| \
35			((uint32)(A) << 24) )
36
37			int
38			main( int argc, char** argv )
39			{
40			char buff[BUF_SIZE];
41			int i;
42			int nbytes;
43			using namespace std;
44			struct stat st;
45			void * vptr;
46			double * dptr;
47			float * fptr;
48			uint32 u32;
49
50			if (argc < 4) {
51			cerr << "\nError: at least three file names must be supplied." << endl;
52			exit(1);
53			}
54
55			string fname(argv[1]);
56			stat(fname.c_str(), &st);
57			nbytes = st.st_size;
58			cout << "The file \"" << fname
59			<< "\" has size: " << nbytes << " bytes" << endl;
60			int ndouble = nbytes/4;
61
62			dptr = new double[ndouble];
63			if (dptr == NULL) {
64			cerr << "\nError: unable to allocate sufficient memory." << endl;
65			exit(1);
66			}
67			for (int j=0; j<ndouble; j++) {
68			dptr[j] = 0.0;
69			}
70
71			for (i=1; i<(argc-1); i++) {
72			cout << " arg " << i << " is " << argv[i] << endl;
73
74			stat(argv[i], &st);
75			if (st.st_size != nbytes) {
76			cerr << "\nError: files size does not agree for file \""
77			<< argv[i] << "\"." << endl;
78			exit(1);
79			}
80			int fd;
81			if ((fd = open(argv[i], O_RDONLY)) == -1) {
82			cerr << "\nError: can't open() file \"" << argv[i] << "\"." << endl;
83			exit(1);
84			}
85			vptr = mmap( (void *)0, (size_t)(nbytes),
86			PROT_READ, MAP_PRIVATE, fd, 0 );
87			if (vptr == NULL) {
88			cerr << "\nError: can't mmap() the file \"" << argv[i] << "\"." << endl;
89			exit(1);
90			}
91
92			// Average the fields
93			unsigned int * uip = (unsigned int *)(vptr);
94			for (int j=0; j<ndouble; j++) {
95			u32 = *uip;
96			unsigned int i32s = bswap32(u32);
97			float flt = ((float )(&i32s));
98			// cout << " flt = " << flt << endl;
99			dptr[j] += double(flt);
100			uip++;
101			}
102
103			munmap(vptr, (size_t)(nbytes));
104			}
105
106			double denom = 1.0/double(argc - 2);
107			fptr = new float[ndouble];
108			for (int j=0; j<ndouble; j++) {
109			float flt = (float(denom * dptr[j]));
110			unsigned int i32s = bswap32(((unsigned int )(&flt)));
111			fptr[j] = ((float )(&i32s));
112			}
113			i = argc - 1;
114			int fdo;
115			if ((fdo = open(argv[i], (O_CREAT \| O_WRONLY),
116			(S_IRUSR \| S_IWUSR))) == -1) {
117			cerr << "\nError: can't open() file \"" << argv[i] << "\"." << endl;
118			exit(1);
119			}
120			char * aptr = (char *)(fptr);
121			size_t inc_bytes_out;
122			size_t tot_bytes_out = 0;
123			bool write_needed = true;
124			while (write_needed) {
125			inc_bytes_out = write(fdo, (void *)(aptr + tot_bytes_out),
126			(size_t)(nbytes - tot_bytes_out));
127			tot_bytes_out += inc_bytes_out;
128			if ((inc_bytes_out == 0) && (fdo != -1))
129			write_needed = false;
130			}
131
132			delete[] dptr;
133			delete[] fptr;
134			return 0;
135			}