![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to graph.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 40BSD / cmd / graph|
Return to graph.c CVS log | Up to [CSRG BSD Unix] / 40BSD / cmd / graph |
1.1 root 1: #include <stdio.h>
2: #include <ctype.h>
3: #include <math.h>
4: #define INF 1.e+37
5: #define F .25
6:
7: struct xy {
8: int xlbf; /*flag:explicit lower bound*/
9: int xubf; /*flag:explicit upper bound*/
10: int xqf; /*flag:explicit quantum*/
11: double (*xf)(); /*transform function, e.g. log*/
12: float xa,xb; /*scaling coefficients*/
13: float xlb,xub; /*lower and upper bound*/
14: float xquant; /*quantum*/
15: float xoff; /*screen offset fraction*/
16: float xsize; /*screen fraction*/
17: int xbot,xtop; /*screen coords of border*/
18: float xmult; /*scaling constant*/
19: } xd,yd;
20: struct val {
21: float xv;
22: float yv;
23: int lblptr;
24: } *xx;
25:
26: char *labs;
27: int labsiz;
28:
29: int tick = 50;
30: int top = 4000;
31: int bot = 200;
32: float absbot;
33: int n;
34: int erasf = 1;
35: int gridf = 2;
36: int symbf = 0;
37: int absf = 0;
38: int transf;
39: int brkf;
40: float dx;
41: char *plotsymb;
42:
43: double atof();
44: #define BSIZ 80
45: char labbuf[BSIZ];
46: char titlebuf[BSIZ];
47:
48: char *modes[] = {
49: "disconnected",
50: "solid",
51: "dotted",
52: "dotdashed",
53: "shortdashed",
54: "longdashed"
55: };
56: int mode = 1;
57: char *realloc();
58: char *malloc();
59:
60: double ident(x)
61: double x;
62: {
63: return(x);
64: }
65:
66: main(argc,argv)
67: char *argv[];
68: {
69:
70: space(0,0,4096,4096);
71: init(&xd);
72: init(&yd);
73: xd.xsize = yd.xsize = 1.;
74: xx = (struct val *)malloc((unsigned)sizeof(struct val));
75: labs = malloc(1);
76: labs[labsiz++] = 0;
77: setopt(argc,argv);
78: if(erasf)
79: erase();
80: readin();
81: transpose();
82: scale(&xd,(struct val *)&xx->xv);
83: scale(&yd,(struct val *)&xx->yv);
84: axes();
85: title();
86: plot();
87: move(1,1);
88: closevt();
89: return(0);
90: }
91:
92: init(p)
93: struct xy *p;
94: {
95: p->xf = ident;
96: p->xmult = 1;
97: }
98:
99: setopt(argc,argv)
100: char *argv[];
101: {
102: char *p1, *p2;
103: float temp;
104:
105: xd.xlb = yd.xlb = INF;
106: xd.xub = yd.xub = -INF;
107: while(--argc > 0) {
108: argv++;
109: again: switch(argv[0][0]) {
110: case '-':
111: argv[0]++;
112: goto again;
113: case 'l': /* label for plot */
114: p1 = titlebuf;
115: if (argc>=2) {
116: argv++;
117: argc--;
118: p2 = argv[0];
119: while (*p1++ = *p2++);
120: }
121: break;
122:
123: case 'd': /*disconnected,obsolete option*/
124: case 'm': /*line mode*/
125: mode = 0;
126: if(!numb(&temp,&argc,&argv))
127: break;
128: if(temp>=sizeof(modes)/sizeof(*modes))
129: mode = 1;
130: else if(temp>=0)
131: mode = temp;
132: break;
133:
134: case 'a': /*automatic abscissas*/
135: absf = 1;
136: dx = 1;
137: if(!numb(&dx,&argc,&argv))
138: break;
139: if(numb(&absbot,&argc,&argv))
140: absf = 2;
141: break;
142:
143: case 's': /*save screen, overlay plot*/
144: erasf = 0;
145: break;
146:
147: case 'g': /*grid style 0 none, 1 ticks, 2 full*/
148: gridf = 0;
149: if(!numb(&temp,&argc,&argv))
150: temp = argv[0][1]-'0'; /*for caompatibility*/
151: if(temp>=0&&temp<=2)
152: gridf = temp;
153: break;
154:
155: case 'c': /*character(s) for plotting*/
156: if(argc >= 2) {
157: symbf = 1;
158: plotsymb = argv[1];
159: argv++;
160: argc--;
161: }
162: break;
163:
164: case 't': /*transpose*/
165: transf = 1;
166: break;
167: case 'b': /*breaks*/
168: brkf = 1;
169: break;
170: case 'x': /*x limits */
171: limread(&xd,&argc,&argv);
172: break;
173: case 'y':
174: limread(&yd,&argc,&argv);
175: break;
176: case 'h': /*set height of plot */
177: if(!numb(&yd.xsize, &argc,&argv))
178: badarg();
179: break;
180: case 'w': /*set width of plot */
181: if(!numb(&xd.xsize, &argc, &argv))
182: badarg();
183: break;
184: case 'r': /* set offset to right */
185: if(!numb(&xd.xoff, &argc, &argv))
186: badarg();
187: break;
188: case 'u': /*set offset up the screen*/
189: if(!numb(&yd.xoff,&argc,&argv))
190: badarg();
191: break;
192: default:
193: badarg();
194: }
195: }
196: }
197:
198: limread(p, argcp, argvp)
199: register struct xy *p;
200: int *argcp;
201: char ***argvp;
202: {
203: if(*argcp>1 && (*argvp)[1][0]=='l') {
204: (*argcp)--;
205: (*argvp)++;
206: p->xf = log10;
207: }
208: if(!numb(&p->xlb,argcp,argvp))
209: return;
210: p->xlbf = 1;
211: if(!numb(&p->xub,argcp,argvp))
212: return;
213: p->xubf = 1;
214: if(!numb(&p->xquant,argcp,argvp))
215: return;
216: p->xqf = 1;
217: }
218:
219: numb(np, argcp, argvp)
220: int *argcp;
221: float *np;
222: register char ***argvp;
223: {
224: register char c;
225:
226: if(*argcp <= 1)
227: return(0);
228: while((c=(*argvp)[1][0]) == '+')
229: (*argvp)[1]++;
230: if(!(isdigit(c) || c=='-'&&(*argvp)[1][1]<'A' || c=='.'))
231: return(0);
232: *np = atof((*argvp)[1]);
233: (*argcp)--;
234: (*argvp)++;
235: return(1);
236: }
237:
238: readin()
239: {
240: register t;
241: struct val *temp;
242:
243: if(absf==1) {
244: if(xd.xlbf)
245: absbot = xd.xlb;
246: else if(xd.xf==log10)
247: absbot = 1;
248: }
249: for(;;) {
250: temp = (struct val *)realloc((char*)xx,
251: (unsigned)(n+1)*sizeof(struct val));
252: if(temp==0)
253: return;
254: xx = temp;
255: if(absf)
256: xx[n].xv = n*dx + absbot;
257: else
258: if(!getfloat(&xx[n].xv))
259: return;
260: if(!getfloat(&xx[n].yv))
261: return;
262: xx[n].lblptr = -1;
263: t = getstring();
264: if(t>0)
265: xx[n].lblptr = copystring(t);
266: n++;
267: if(t<0)
268: return;
269: }
270: }
271:
272: transpose()
273: {
274: register i;
275: float f;
276: struct xy t;
277: if(!transf)
278: return;
279: t = xd; xd = yd; yd = t;
280: for(i= 0;i<n;i++) {
281: f = xx[i].xv; xx[i].xv = xx[i].yv; xx[i].yv = f;
282: }
283: }
284:
285: copystring(k)
286: {
287: register char *temp;
288: register i;
289: int q;
290:
291: temp = realloc(labs,(unsigned)(labsiz+1+k));
292: if(temp==0)
293: return(0);
294: labs = temp;
295: q = labsiz;
296: for(i=0;i<=k;i++)
297: labs[labsiz++] = labbuf[i];
298: return(q);
299: }
300:
301: float
302: modceil(f,t)
303: float f,t;
304: {
305:
306: t = fabs(t);
307: return(ceil(f/t)*t);
308: }
309:
310: float
311: modfloor(f,t)
312: float f,t;
313: {
314: t = fabs(t);
315: return(floor(f/t)*t);
316: }
317:
318: getlim(p,v)
319: register struct xy *p;
320: struct val *v;
321: {
322: register i;
323:
324: i = 0;
325: do {
326: if(!p->xlbf && p->xlb>v[i].xv)
327: p->xlb = v[i].xv;
328: if(!p->xubf && p->xub<v[i].xv)
329: p->xub = v[i].xv;
330: i++;
331: } while(i < n);
332: }
333:
334: struct z {
335: float lb,ub,mult,quant;
336: } setloglim(), setlinlim();
337:
338: setlim(p)
339: register struct xy *p;
340: {
341: float t,delta,sign;
342: struct z z;
343: int mark[50];
344: float lb,ub;
345: int lbf,ubf;
346:
347: lb = p->xlb;
348: ub = p->xub;
349: delta = ub-lb;
350: if(p->xqf) {
351: if(delta*p->xquant <=0 )
352: badarg();
353: return;
354: }
355: sign = 1;
356: lbf = p->xlbf;
357: ubf = p->xubf;
358: if(delta < 0) {
359: sign = -1;
360: t = lb;
361: lb = ub;
362: ub = t;
363: t = lbf;
364: lbf = ubf;
365: ubf = t;
366: }
367: else if(delta == 0) {
368: if(ub > 0) {
369: ub = 2*ub;
370: lb = 0;
371: }
372: else
373: if(lb < 0) {
374: lb = 2*lb;
375: ub = 0;
376: }
377: else {
378: ub = 1;
379: lb = -1;
380: }
381: }
382: if(p->xf==log10 && lb>0 && ub>lb) {
383: z = setloglim(lbf,ubf,lb,ub);
384: p->xlb = z.lb;
385: p->xub = z.ub;
386: p->xmult *= z.mult;
387: p->xquant = z.quant;
388: if(setmark(mark,p)<2) {
389: p->xqf = lbf = ubf = 1;
390: lb = z.lb; ub = z.ub;
391: } else
392: return;
393: }
394: z = setlinlim(lbf,ubf,lb,ub);
395: if(sign > 0) {
396: p->xlb = z.lb;
397: p->xub = z.ub;
398: } else {
399: p->xlb = z.ub;
400: p->xub = z.lb;
401: }
402: p->xmult *= z.mult;
403: p->xquant = sign*z.quant;
404: }
405:
406: struct z
407: setloglim(lbf,ubf,lb,ub)
408: float lb,ub;
409: {
410: float r,s,t;
411: struct z z;
412:
413: for(s=1; lb*s<1; s*=10) ;
414: lb *= s;
415: ub *= s;
416: for(r=1; 10*r<=lb; r*=10) ;
417: for(t=1; t<ub; t*=10) ;
418: z.lb = !lbf ? r : lb;
419: z.ub = !ubf ? t : ub;
420: if(ub/lb<100) {
421: if(!lbf) {
422: if(lb >= 5*z.lb)
423: z.lb *= 5;
424: else if(lb >= 2*z.lb)
425: z.lb *= 2;
426: }
427: if(!ubf) {
428: if(ub*5 <= z.ub)
429: z.ub /= 5;
430: else if(ub*2 <= z.ub)
431: z.ub /= 2;
432: }
433: }
434: z.mult = s;
435: z.quant = r;
436: return(z);
437: }
438:
439: struct z
440: setlinlim(lbf,ubf,xlb,xub)
441: int lbf,ubf;
442: float xlb,xub;
443: {
444: struct z z;
445: float r,s,delta;
446: float ub,lb;
447:
448: loop:
449: ub = xub;
450: lb = xlb;
451: delta = ub - lb;
452: /*scale up by s, a power of 10, so range (delta) exceeds 1*/
453: /*find power of 10 quantum, r, such that delta/10<=r<delta*/
454: r = s = 1;
455: while(delta*s < 10)
456: s *= 10;
457: delta *= s;
458: while(10*r < delta)
459: r *= 10;
460: lb *= s;
461: ub *= s;
462: /*set r=(1,2,5)*10**n so that 3-5 quanta cover range*/
463: if(r>=delta/2)
464: r /= 2;
465: else if(r<delta/5)
466: r *= 2;
467: z.ub = ubf? ub: modceil(ub,r);
468: z.lb = lbf? lb: modfloor(lb,r);
469: if(!lbf && z.lb<=r && z.lb>0) {
470: xlb = 0;
471: goto loop;
472: }
473: else if(!ubf && z.ub>=-r && z.ub<0) {
474: xub = 0;
475: goto loop;
476: }
477: z.quant = r;
478: z.mult = s;
479: return(z);
480: }
481:
482: scale(p,v)
483: register struct xy *p;
484: struct val *v;
485: {
486: float edge;
487:
488: getlim(p,v);
489: setlim(p);
490: edge = top-bot;
491: p->xa = p->xsize*edge/((*p->xf)(p->xub) - (*p->xf)(p->xlb));
492: p->xbot = bot + edge*p->xoff;
493: p->xtop = p->xbot + (top-bot)*p->xsize;
494: p->xb = p->xbot - (*p->xf)(p->xlb)*p->xa + .5;
495: }
496:
497: axes()
498: {
499: register i;
500: int mark[50];
501: int xn, yn;
502: if(gridf==0)
503: return;
504:
505: line(xd.xbot,yd.xbot,xd.xtop,yd.xbot);
506: cont(xd.xtop,yd.xtop);
507: cont(xd.xbot,yd.xtop);
508: cont(xd.xbot,yd.xbot);
509:
510: xn = setmark(mark,&xd);
511: for(i=0; i<xn; i++) {
512: if(gridf==2)
513: line(mark[i],yd.xbot,mark[i],yd.xtop);
514: if(gridf==1) {
515: line(mark[i],yd.xbot,mark[i],yd.xbot+tick);
516: line(mark[i],yd.xtop-tick,mark[i],yd.xtop);
517: }
518: }
519: yn = setmark(mark,&yd);
520: for(i=0; i<yn; i++) {
521: if(gridf==2)
522: line(xd.xbot,mark[i],xd.xtop,mark[i]);
523: if(gridf==1) {
524: line(xd.xbot,mark[i],xd.xbot+tick,mark[i]);
525: line(xd.xtop-tick,mark[i],xd.xtop,mark[i]);
526: }
527: }
528: }
529:
530: setmark(xmark,p)
531: int *xmark;
532: register struct xy *p;
533: {
534: int xn = 0;
535: float x,xl,xu;
536: float q;
537: if(p->xf==log10&&!p->xqf) {
538: for(x=p->xquant; x<p->xub; x*=10) {
539: submark(xmark,&xn,x,p);
540: if(p->xub/p->xlb<=100) {
541: submark(xmark,&xn,2*x,p);
542: submark(xmark,&xn,5*x,p);
543: }
544: }
545: } else {
546: xn = 0;
547: q = p->xquant;
548: if(q>0) {
549: xl = modceil(p->xlb+q/6,q);
550: xu = modfloor(p->xub-q/6,q)+q/2;
551: } else {
552: xl = modceil(p->xub-q/6,q);
553: xu = modfloor(p->xlb+q/6,q)-q/2;
554: }
555: for(x=xl; x<=xu; x+=fabs(p->xquant))
556: xmark[xn++] = (*p->xf)(x)*p->xa + p->xb;
557: }
558: return(xn);
559: }
560: submark(xmark,pxn,x,p)
561: int *xmark;
562: int *pxn;
563: float x;
564: struct xy *p;
565: {
566: if(1.001*p->xlb < x && .999*p->xub > x)
567: xmark[(*pxn)++] = log10(x)*p->xa + p->xb;
568: }
569:
570: plot()
571: {
572: int ix,iy;
573: int i;
574: int conn;
575:
576: conn = 0;
577: if(mode!=0)
578: linemod(modes[mode]);
579: for(i=0; i<n; i++) {
580: if(!conv(xx[i].xv,&xd,&ix) ||
581: !conv(xx[i].yv,&yd,&iy)) {
582: conn = 0;
583: continue;
584: }
585: if(mode!=0) {
586: if(conn != 0)
587: cont(ix,iy);
588: else
589: move(ix,iy);
590: conn = 1;
591: }
592: conn &= symbol(ix,iy,xx[i].lblptr);
593: }
594: linemod(modes[1]);
595: }
596:
597: conv(xv,p,ip)
598: float xv;
599: register struct xy *p;
600: int *ip;
601: {
602: long ix;
603: ix = p->xa*(*p->xf)(xv*p->xmult) + p->xb;
604: if(ix<p->xbot || ix>p->xtop)
605: return(0);
606: *ip = ix;
607: return(1);
608: }
609:
610: getfloat(p)
611: float *p;
612: {
613: register i;
614:
615: i = scanf("%f",p);
616: return(i==1);
617: }
618:
619: getstring()
620: {
621: register i;
622: char junk[20];
623: i = scanf("%1s",labbuf);
624: if(i==-1)
625: return(-1);
626: switch(*labbuf) {
627: default:
628: if(!isdigit(*labbuf)) {
629: ungetc(*labbuf,stdin);
630: i = scanf("%s",labbuf);
631: break;
632: }
633: case '.':
634: case '+':
635: case '-':
636: ungetc(*labbuf,stdin);
637: return(0);
638: case '"':
639: i = scanf("%[^\"\n]",labbuf);
640: scanf("%[\"]",junk);
641: break;
642: }
643: if(i==-1)
644: return(-1);
645: return(strlen(labbuf));
646: }
647:
648:
649: symbol(ix,iy,k)
650: {
651:
652: if(symbf==0&&k<0) {
653: if(mode==0)
654: point(ix,iy);
655: return(1);
656: }
657: else {
658: move(ix,iy);
659: label(k>=0?labs+k:plotsymb);
660: move(ix,iy);
661: return(!brkf|k<0);
662: }
663: }
664:
665: title()
666: {
667: move(xd.xbot,yd.xbot-60);
668: if (titlebuf[0]) {
669: label(titlebuf);
670: label(" ");
671: }
672: if(erasf&&gridf) {
673: axlab('x',&xd);
674: label(" ");
675: axlab('y',&yd);
676: }
677: }
678:
679: axlab(c,p)
680: char c;
681: struct xy *p;
682: {
683: char buf[50];
684: sprintf(buf,"%g -%s%c- %g", p->xlb/p->xmult,
685: p->xf==log10?"log ":"", c, p->xub/p->xmult);
686: label(buf);
687: }
688:
689: badarg()
690: {
691: fprintf(stderr,"graph: error in arguments\n");
692: exit(1);
693: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.