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