ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/Development/ray/src/cal/total.c

Comparing ray/src/cal/total.c (file contents):
Revision 1.6 by greg, Fri Apr 18 16:32:27 2008 UTC vs.
Revision 1.15 by greg, Tue Nov 16 03:30:45 2021 UTC

#	Line 7 | Line 7 | static const char      RCSid[] = "$Id$";
7		*      5/18/88
8		*/
9
10	–	#include  <stdio.h>
10		#include  <stdlib.h>
11		#include  <ctype.h>
12		#include  <math.h>
13		#include  "platform.h"
14	+	#include  "rtio.h"
15
16	<	#define  MAXCOL         2048            /* maximum number of columns */
16	>	#define  MAXCOL         8192            /* maximum number of columns */
17
18		#define  ADD            0               /* add numbers */
19		#define  MULT           1               /* multiply numbers */
#	Line 22 | Line 22 | static const char      RCSid[] = "$Id$";
22
23		double  init_val[] = {0., 1., -1e12, 1e12};     /* initial values */
24
25	+	long  incnt = 0;                        /* limit number of input records? */
26	+	long  outcnt = 0;                       /* limit number of output records? */
27	+
28		int  func = ADD;                        /* default function */
29		double  power = 0.0;                    /* power for sum */
30		int  mean = 0;                          /* compute mean */
#	Line 30 | Line 33 | int  nbicols = 0;                      /* number of binary input columns
33		int  bocols = 0;                        /* produce binary output columns */
34		int  tabc = '\t';                       /* default separator */
35		int  subtotal = 0;                      /* produce subtotals? */
36	+	int  nrecsout = 0;                      /* number of records produced */
37
38		static int execute(char *fname);
39
#	Line 72 | Line 76 | char  *argv[]
76		break;
77		case 'i':
78		switch (argv[a][2]) {
79	+	case 'n':
80	+	incnt = atol(argv[++a]);
81	+	break;
82		case 'a':
83		nbicols = 0;
84		break;
#	Line 105 | Line 112 | char  *argv[]
112		break;
113		case 'o':
114		switch (argv[a][2]) {
115	+	case 'n':
116	+	outcnt = atol(argv[++a]);
117	+	break;
118		case 'a':
119		bocols = 0;
120		break;
#	Line 143 | Line 153 | char  *argv[]
153		if (a >= argc)
154		status = execute(NULL) == -1 ? 1 : status;
155		else
156	<	for ( ; a < argc; a++)
156	>	for ( ; a < argc && (outcnt <= 0 || nrecsout < outcnt); a++)
157		status = execute(argv[a]) == -1 ? 2 : status;
158		exit(status);
159		}
#	Line 160 | Line 170 | getrecord(                     /* read next input record */
170		int   nf;
171		/* reading binary input? */
172		if (nbicols > 0)
173	<	return(fread(field, sizeof(double), nbicols, fp));
173	>	return(getbinary(field, sizeof(double), nbicols, fp));
174		if (nbicols < 0) {
175		float   *fbuf = (float *)buf;
176		int     i;
177	<	nf = fread(fbuf, sizeof(float), -nbicols, fp);
177	>	nf = getbinary(fbuf, sizeof(float), -nbicols, fp);
178		for (i = nf; i-- > 0; )
179		field[i] = fbuf[i];
180		return(nf);
#	Line 201 | Line 211 | putrecord(                     /* write out results record */
211		{
212		/* binary output? */
213		if (bocols > 0) {
214	<	fwrite(field, sizeof(double), n, fp);
214	>	putbinary(field, sizeof(double), n, fp);
215		return;
216		}
217		if (bocols < 0) {
218		float   fv;
219		while (n-- > 0) {
220		fv = *field++;
221	<	fwrite(&fv, sizeof(float), 1, fp);
221	>	putbinary(&fv, sizeof(float), 1, fp);
222		}
223		return;
224		}
225		/* ASCII output */
226	<	while (n-- > 0)
227	<	fprintf(fp, "%.9g%c", *field++, tabc);
226	>	while (n-- > 0) {
227	>	fprintf(fp, "%.9g", *field++);
228	>	if (n) fputc(tabc, fp);
229	>	}
230		fputc('\n', fp);
231	+	if (!subtotal)
232	+	fflush(fp);                     /* flush unless -r */
233		}
234
235
#	Line 226 | Line 240 | char  *fname
240		{
241		double  inpval[MAXCOL];
242		double  tally[MAXCOL];
243	+	short   rsign[MAXCOL];
244		double  result[MAXCOL];
245	<	register int  n;
245	>	int  n;
246		int  nread, ncol;
247		long  nlin, ltotal;
248		FILE  *fp;
#	Line 240 | Line 255 | char  *fname
255		}
256		if (nbicols)
257		SET_FILE_BINARY(fp);
258	+	#ifdef getc_unlocked                            /* avoid lock/unlock overhead */
259	+	flockfile(fp);
260	+	#endif
261	+
262		ltotal = 0;
263		while (!feof(fp)) {
264		if (ltotal == 0) {                      /* initialize */
265		if (func == MULT)       /* special case */
266	<	for (n = 0; n < MAXCOL; n++)
266	>	for (n = 0; n < MAXCOL; n++) {
267		tally[n] = 0.0;
268	+	rsign[n] = 1;
269	+	}
270		else
271		for (n = 0; n < MAXCOL; n++)
272		tally[n] = init_val[func];
273		}
274		ncol = 0;
275		for (nlin = 0; (count <= 0 || nlin < count) &&
276	+	(incnt <= 0 || nlin < incnt) &&
277		(nread = getrecord(inpval, fp)) > 0;
278		nlin++) {
279		/* compute */
#	Line 267 | Line 289 | char  *fname
289		break;
290		case MULT:
291		if (inpval[n] == 0.0)
292	<	break;
293	<	tally[n] += log(fabs(inpval[n]));
292	>	rsign[n] = 0;
293	>	else if (inpval[n] < 0.0) {
294	>	rsign[n] = -rsign[n];
295	>	inpval[n] = -inpval[n];
296	>	}
297	>	if (rsign[n])
298	>	tally[n] += log(inpval[n]);
299		break;
300		case MAX:
301		if (inpval[n] > tally[n])
#	Line 294 | Line 321 | char  *fname
321		result[n] = pow(result[n], 1.0/power);
322		}
323		if (func == MULT)
324	<	result[n] = exp(result[n]);
324	>	result[n] = rsign[n] * exp(result[n]);
325		}
326		putrecord(result, ncol, stdout);
327	+	++nrecsout;
328	+	if (outcnt > 0 && nrecsout >= outcnt)
329	+	break;
330		if (!subtotal)
331		ltotal = 0;
332	+	if (incnt > 0 && nlin >= incnt)
333	+	break;
334		}
335		/* close input */
336	<	return(fclose(fp));
336	>	return(fclose(fp) == EOF ? 1 : 0);
337		}

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines (old)
>	Changed lines (new)