UNIX 7th Ed. - /usr/src/cmd/graph.c

   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: }

Defined functions

Defined variables

Defined struct's

Defined macros