[BACK]Return to calc.c CVS log [TXT][DIR] Up to [local] / OpenXM_contrib2 / asir2000 / plot

Diff for /OpenXM_contrib2/asir2000/plot/calc.c between version 1.9 and 1.15

version 1.9, 2013/12/19 06:04:09 version 1.15, 2020/10/04 03:14:09
Line 45 
Line 45 
  * DEVELOPER SHALL HAVE NO LIABILITY IN CONNECTION WITH THE USE,   * DEVELOPER SHALL HAVE NO LIABILITY IN CONNECTION WITH THE USE,
  * PERFORMANCE OR NON-PERFORMANCE OF THE SOFTWARE.   * PERFORMANCE OR NON-PERFORMANCE OF THE SOFTWARE.
  *   *
  * $OpenXM: OpenXM_contrib2/asir2000/plot/calc.c,v 1.8 2011/08/10 04:51:58 saito Exp $   * $OpenXM: OpenXM_contrib2/asir2000/plot/calc.c,v 1.14 2018/03/29 01:32:55 noro Exp $
 */  */
 #include "ca.h"  #include "ca.h"
 #include "parse.h"  #include "parse.h"
Line 59 
Line 59 
 #define MAXSHORT ((short)0x7fff)  #define MAXSHORT ((short)0x7fff)
 #endif  #endif
   
   void todouble(Obj,Obj *);
   void Psetprec();
   
 void calc(double **tab,struct canvas *can,int nox){  void calc(double **tab,struct canvas *can,int nox){
         //memory_plot,MODE_IFPLOTD,MODE_INEQND,MODE_INEQNANDD,MODE_INEQNORD    //memory_plot,IFPLOTD,INEQND,INEQNANDD,INEQNORD
         //MODE_INEQNXORD,conplotmainD    //INEQNXORD,conplotmainD
         double x,y,xstep,ystep;    double x,y,xstep,ystep;
         int ix,iy;    int ix,iy;
         Real r,rx,ry;    Real r,rx,ry;
         Obj fr,g,t,s;    Obj fr,g,t,s;
   
         if(!nox)initmarker(can,"Evaluating...");    if(!nox)initmarker(can,"Evaluating...");
         MKReal(1.0,r); mulr(CO,(Obj)can->formula,(Obj)r,&fr);    todouble((Obj)can->formula,&fr);
         xstep=(can->xmax-can->xmin)/can->width;    xstep=(can->xmax-can->xmin)/can->width;
         ystep=(can->ymax-can->ymin)/can->height;    ystep=(can->ymax-can->ymin)/can->height;
         MKReal(1.0,rx); MKReal(1.0,ry); // dummy real    MKReal(1.0,rx); MKReal(1.0,ry); // dummy real
         BDY(rx)=can->xmin;    BDY(rx)=can->xmin;
         substr(CO,0,fr,can->vx,can->xmin?(Obj)rx:0,&t); devalr(CO,t,&g);    substr(CO,0,fr,can->vx,can->xmin?(Obj)rx:0,&t); devalr(CO,t,&g);
         BDY(ry)=can->ymin;    BDY(ry)=can->ymin;
         substr(CO,0,g,can->vy,can->ymin?(Obj)ry:0,&t); devalr(CO,t,&s);    substr(CO,0,g,can->vy,can->ymin?(Obj)ry:0,&t); devalr(CO,t,&s);
         can->vmax=can->vmin=ToReal(s);    can->vmax=can->vmin=ToReal(s);
         for(ix=0,x=can->xmin; ix<can->width; ix++,x+=xstep){    for(ix=0,x=can->xmin; ix<can->width; ix++,x+=xstep){
                 BDY(rx)=x; substr(CO,0,fr,can->vx,x?(Obj)rx:0,&t);      BDY(rx)=x; substr(CO,0,fr,can->vx,x?(Obj)rx:0,&t);
                 devalr(CO,t,&g);      devalr(CO,t,&g);
                 if(!nox)marker(can,DIR_X,ix);      if(!nox)marker(can,DIR_X,ix);
                 for(iy=0,y=can->ymin; iy<can->height; iy++,y+=ystep){      for(iy=0,y=can->ymin; iy<can->height; iy++,y+=ystep){
                         BDY(ry)=y;        BDY(ry)=y;
                         substr(CO,0,g,can->vy,y?(Obj)ry:0,&t);        substr(CO,0,g,can->vy,y?(Obj)ry:0,&t);
                         devalr(CO,t,&s);        devalr(CO,t,&s);
                         tab[ix][iy]=ToReal(s);        tab[ix][iy]=ToReal(s);
                         if(can->vmax<tab[ix][iy])can->vmax=tab[ix][iy];        if(can->vmax<tab[ix][iy])can->vmax=tab[ix][iy];
                         if(can->vmin>tab[ix][iy])can->vmin=tab[ix][iy];        if(can->vmin>tab[ix][iy])can->vmin=tab[ix][iy];
                 }      }
         }    }
 }  }
   
 void calcq(double **tab,struct canvas *can,int nox){  void calcq(double **tab,struct canvas *can,int nox){
         //MODE_IFPLOTQ,MODE_INEQNQ,MODE_INEQNANDQ,MODE_INEQNORQ,MODE_INEQNXORQ    //IFPLOTQ,INEQNQ,INEQNANDQ,INEQNORQ,INEQNXORQ
         //plotoverD    //plotoverD
         Q dx,dy,xstep,ystep,q1,w,h,c;    Q dx,dy,xstep,ystep,q1,w,h,c;
         P g,g1,f1,f2,x,y;    P g,g1,f1,f2,x,y;
         int ix,iy;    int ix,iy;
         Obj fr,gm,t,s;    Obj fr,gm,t,s;
         Real r,rx,ry;    Real r,rx,ry;
   
         MKReal(1.0,r); mulr(CO,(Obj)can->formula,(Obj)r,&fr);    todouble((Obj)can->formula,&fr);
         MKReal(1.0,rx); MKReal(1.0,ry); // dummy real    MKReal(1.0,rx); MKReal(1.0,ry); // dummy real
         BDY(rx)=can->xmin;    BDY(rx)=can->xmin;
         substr(CO,0,fr,can->vx,can->xmin?(Obj)rx:0,&t); devalr(CO,t,&gm);    substr(CO,0,fr,can->vx,can->xmin?(Obj)rx:0,&t); devalr(CO,t,&gm);
         BDY(ry)=can->ymin;    BDY(ry)=can->ymin;
         substr(CO,0,gm,can->vy,can->ymin?(Obj)ry:0,&t); devalr(CO,t,&s);    substr(CO,0,gm,can->vy,can->ymin?(Obj)ry:0,&t); devalr(CO,t,&s);
         can->vmax=can->vmin=ToReal(s);    can->vmax=can->vmin=ToReal(s);
   
         subq(can->qxmax,can->qxmin,&dx); STOQ(can->width,w); divq(dx,w,&xstep);    subq(can->qxmax,can->qxmin,&dx); STOQ(can->width,w); divq(dx,w,&xstep);
         subq(can->qymax,can->qymin,&dy); STOQ(can->height,h); divq(dy,h,&ystep);    subq(can->qymax,can->qymin,&dy); STOQ(can->height,h); divq(dy,h,&ystep);
         MKV(can->vx,x); mulp(CO,(P)xstep,x,(P *)&t);    MKV(can->vx,x); mulp(CO,(P)xstep,x,(P *)&t);
         addp(CO,(P)can->qxmin,(P)t,(P *)&s); substp(CO,can->formula,can->vx,(P)s,&f1);    addp(CO,(P)can->qxmin,(P)t,(P *)&s); substp(CO,can->formula,can->vx,(P)s,&f1);
         MKV(can->vy,y); mulp(CO,(P)ystep,y,(P *)&t);    MKV(can->vy,y); mulp(CO,(P)ystep,y,(P *)&t);
         addp(CO,(P)can->qymin,(P)t,(P *)&s); substp(CO,f1,can->vy,(P)s,&f2);    addp(CO,(P)can->qymin,(P)t,(P *)&s); substp(CO,f1,can->vy,(P)s,&f2);
         ptozp(f2,1,&c,&g);    ptozp(f2,1,&c,&g);
         if(!nox) initmarker(can,"Evaluating...");    if(!nox) initmarker(can,"Evaluating...");
         for(iy=0;iy<can->height;iy++){    for(iy=0;iy<can->height;iy++){
                 marker(can,DIR_Y,iy);      marker(can,DIR_Y,iy);
                 STOQ(iy,q1); substp(CO,g,can->vy,(P)q1,(P *)&t); ptozp((P)t,1,&c,&g1);      STOQ(iy,q1); substp(CO,g,can->vy,(P)q1,(P *)&t); ptozp((P)t,1,&c,&g1);
                 for(ix=0;ix<can->width;ix++){      for(ix=0;ix<can->width;ix++){
                         STOQ(ix,q1);substp(CO,g1,can->vx,(P)q1,(P *)&t);        STOQ(ix,q1);substp(CO,g1,can->vx,(P)q1,(P *)&t);
                         devalr(CO,t,&s);        devalr(CO,t,&s);
                         tab[ix][iy]=ToReal(s);        tab[ix][iy]=ToReal(s);
                         if(can->vmax<tab[ix][iy])can->vmax=tab[ix][iy];        if(can->vmax<tab[ix][iy])can->vmax=tab[ix][iy];
                         if(can->vmin>tab[ix][iy])can->vmin=tab[ix][iy];        if(can->vmin>tab[ix][iy])can->vmin=tab[ix][iy];
                 }      }
         }    }
 }  }
   
 void calcb(double **tab,struct canvas *can,int nox){  void calcb(double **tab,struct canvas *can,int nox){
         //MODE_IFPLOTB,MODE_INEQNB,MODE_INEQNANDB,MODE_INEQNORB,MODE_INEQNXORB    //IFPLOTB,INEQNB,INEQNANDB,INEQNORB,INEQNXORB
         Q dx,dy,xstep,ystep,q1,w,h,c;    Q dx,dy,xstep,ystep,q1,w,h,c;
         P g,g1,f1,f2,x,y,t,s;    P g,g1,f1,f2,x,y,t,s;
         int ix,iy,*a,*pa;    int ix,iy,*a,*pa;
         VECT ss;    VECT ss;
         Obj fr,gm,tm,sm;    Obj fr,gm,tm,sm;
         Real r,rx,ry;    Real r,rx,ry;
   
         MKReal(1.0,r); mulr(CO,(Obj)can->formula,(Obj)r,&fr);    todouble((Obj)can->formula,&fr);
         MKReal(1.0,rx); MKReal(1.0,ry); // dummy real    MKReal(1.0,rx); MKReal(1.0,ry); // dummy real
         BDY(rx)=can->xmin;    BDY(rx)=can->xmin;
         substr(CO,0,fr,can->vx,can->xmin?(Obj)rx:0,&tm); devalr(CO,tm,&gm);    substr(CO,0,fr,can->vx,can->xmin?(Obj)rx:0,&tm); devalr(CO,tm,&gm);
         BDY(ry)=can->ymin;    BDY(ry)=can->ymin;
         substr(CO,0,gm,can->vy,can->ymin?(Obj)ry:0,&tm); devalr(CO,tm,&sm);    substr(CO,0,gm,can->vy,can->ymin?(Obj)ry:0,&tm); devalr(CO,tm,&sm);
         can->vmax=can->vmin=ToReal(sm);    can->vmax=can->vmin=ToReal(sm);
   
         for(iy=0;iy<can->height;iy++)for(ix=0;ix<can->width;ix++)tab[ix][iy]=1.0;    for(iy=0;iy<can->height;iy++)for(ix=0;ix<can->width;ix++)tab[ix][iy]=1.0;
         subq(can->qxmax,can->qxmin,&dx); STOQ(can->width,w); divq(dx,w,&xstep);    subq(can->qxmax,can->qxmin,&dx); STOQ(can->width,w); divq(dx,w,&xstep);
         subq(can->qymax,can->qymin,&dy); STOQ(can->height,h); divq(dy,h,&ystep);    subq(can->qymax,can->qymin,&dy); STOQ(can->height,h); divq(dy,h,&ystep);
         MKV(can->vx,x); mulp(CO,(P)xstep,x,&t);    MKV(can->vx,x); mulp(CO,(P)xstep,x,&t);
         addp(CO,(P)can->qxmin,t,&s); substp(CO,can->formula,can->vx,s,&f1);    addp(CO,(P)can->qxmin,t,&s); substp(CO,can->formula,can->vx,s,&f1);
         MKV(can->vy,y); mulp(CO,(P)ystep,y,&t);    MKV(can->vy,y); mulp(CO,(P)ystep,y,&t);
         addp(CO,(P)can->qymin,t,&s); substp(CO,f1,can->vy,s,&f2);    addp(CO,(P)can->qymin,t,&s); substp(CO,f1,can->vy,s,&f2);
         ptozp(f2,1,&c,&g);    ptozp(f2,1,&c,&g);
         a=(int *)ALLOCA((MAX(can->width,can->height)+1)*sizeof(int));    a=(int *)ALLOCA((MAX(can->width,can->height)+1)*sizeof(int));
         for(iy=0;iy<can->height;iy++)for(ix=0;ix<can->width;ix++)tab[ix][iy]=1.0;    for(iy=0;iy<can->height;iy++)for(ix=0;ix<can->width;ix++)tab[ix][iy]=1.0;
         subq(can->qxmax,can->qxmin,&dx); STOQ(can->width,w); divq(dx,w,&xstep);    subq(can->qxmax,can->qxmin,&dx); STOQ(can->width,w); divq(dx,w,&xstep);
         subq(can->qymax,can->qymin,&dy); STOQ(can->height,h); divq(dy,h,&ystep);    subq(can->qymax,can->qymin,&dy); STOQ(can->height,h); divq(dy,h,&ystep);
         MKV(can->vx,x); mulp(CO,(P)xstep,x,&t);    MKV(can->vx,x); mulp(CO,(P)xstep,x,&t);
         addp(CO,(P)can->qxmin,t,&s); substp(CO,can->formula,can->vx,s,&f1);    addp(CO,(P)can->qxmin,t,&s); substp(CO,can->formula,can->vx,s,&f1);
         MKV(can->vy,y); mulp(CO,(P)ystep,y,&t);    MKV(can->vy,y); mulp(CO,(P)ystep,y,&t);
         addp(CO,(P)can->qymin,t,&s); substp(CO,f1,can->vy,s,&f2);    addp(CO,(P)can->qymin,t,&s); substp(CO,f1,can->vy,s,&f2);
         ptozp(f2,1,&c,&g);    ptozp(f2,1,&c,&g);
         a=(int *)ALLOCA((MAX(can->width,can->height)+1)*sizeof(int));    a=(int *)ALLOCA((MAX(can->width,can->height)+1)*sizeof(int));
         for(ix=0;ix<can->width;ix++){    for(ix=0;ix<can->width;ix++){
                 STOQ(ix,q1); substp(CO,g,can->vx,(P)q1,&t); ptozp(t,1,&c,&g1);      STOQ(ix,q1); substp(CO,g,can->vx,(P)q1,&t); ptozp(t,1,&c,&g1);
                 if(!g1)for(iy=0;iy<can->height;iy++)tab[ix][iy]=0.0;      if(!g1)for(iy=0;iy<can->height;iy++)tab[ix][iy]=0.0;
                 else if(!NUM(g1)){      else if(!NUM(g1)){
                         sturmseq(CO,g1,&ss);        sturmseq(CO,g1,&ss);
                         seproot(ss,0,can->width,a);        seproot(ss,0,can->width,a);
                         for(iy=0,pa=a;iy<can->height;iy++,pa++){        for(iy=0,pa=a;iy<can->height;iy++,pa++){
                                 if(*pa<0||(*(pa+1)>=0&&(*pa>*(pa+1))))tab[ix][iy]=0.0;          if(*pa<0||(*(pa+1)>=0&&(*pa>*(pa+1))))tab[ix][iy]=0.0;
                                 else {          else {
                                         STOQ(iy,q1);substp(CO,g1,can->vy,(P)q1,&t);            STOQ(iy,q1);substp(CO,g1,can->vy,(P)q1,&t);
                                         devalr(CO,(Obj)t,(Obj *)&s);            devalr(CO,(Obj)t,(Obj *)&s);
                                         tab[ix][iy]=ToReal(s);            tab[ix][iy]=ToReal(s);
                                         if(can->vmax<tab[ix][iy])can->vmax=tab[ix][iy];            if(can->vmax<tab[ix][iy])can->vmax=tab[ix][iy];
                                         if(can->vmin>tab[ix][iy])can->vmin=tab[ix][iy];            if(can->vmin>tab[ix][iy])can->vmin=tab[ix][iy];
                                 }          }
                         }        }
                 }      }
         }    }
         for(iy=0;iy<can->height;iy++){    for(iy=0;iy<can->height;iy++){
                 STOQ(iy,q1); substp(CO,g,can->vy,(P)q1,&t); ptozp(t,1,&c,&g1);      STOQ(iy,q1); substp(CO,g,can->vy,(P)q1,&t); ptozp(t,1,&c,&g1);
                 if(!g1) for(ix=0;ix<can->width;ix++)tab[ix][iy]=0.0;      if(!g1) for(ix=0;ix<can->width;ix++)tab[ix][iy]=0.0;
                 else if(!NUM(g1)){      else if(!NUM(g1)){
                         sturmseq(CO,g1,&ss);        sturmseq(CO,g1,&ss);
                         seproot(ss,0,can->height,a);        seproot(ss,0,can->height,a);
                         for(ix=0,pa=a;ix<can->width;ix++,pa++){        for(ix=0,pa=a;ix<can->width;ix++,pa++){
                                 if(tab[ix][iy]!=0.0){          if(tab[ix][iy]!=0.0){
                                         if(*pa<0||(*(pa+1)>=0&&(*pa>*(pa+1))))tab[ix][iy]=0.0;            if(*pa<0||(*(pa+1)>=0&&(*pa>*(pa+1))))tab[ix][iy]=0.0;
                                         else {            else {
                                                 STOQ(ix,q1);substp(CO,g1,can->vx,(P)q1,&t);              STOQ(ix,q1);substp(CO,g1,can->vx,(P)q1,&t);
                                                 devalr(CO,(Obj)t,(Obj *)&s);              devalr(CO,(Obj)t,(Obj *)&s);
                                                 tab[ix][iy]=ToReal(s);              tab[ix][iy]=ToReal(s);
                                                 if(can->vmax<tab[ix][iy])can->vmax=tab[ix][iy];              if(can->vmax<tab[ix][iy])can->vmax=tab[ix][iy];
                                                 if(can->vmin>tab[ix][iy])can->vmin=tab[ix][iy];              if(can->vmin>tab[ix][iy])can->vmin=tab[ix][iy];
                                         }            }
                                 }          }
                         }        }
                 }      }
         }    }
 }  }
   
 double usubstrp(P p,double r){  double usubstrp(P p,double r){
         DCP dc;    DCP dc;
         int d;    int d;
         double t,pwrreal0();    double t,pwrreal0();
   
         if(!p) t=0.0;    if(!p) t=0.0;
         else if(NUM(p))t=BDY((Real)p);    else if(NUM(p))t=BDY((Real)p);
         else {    else {
                 dc=DC(p); t=BDY((Real)COEF(dc));      dc=DC(p); t=BDY((Real)COEF(dc));
                 for(d=QTOS(DEG(dc)),dc=NEXT(dc);dc;d=QTOS(DEG(dc)),dc=NEXT(dc)){      for(d=QTOS(DEG(dc)),dc=NEXT(dc);dc;d=QTOS(DEG(dc)),dc=NEXT(dc)){
                         t=t*pwrreal0(r,(d-QTOS(DEG(dc))))+BDY((Real)COEF(dc));        t=t*pwrreal0(r,(d-QTOS(DEG(dc))))+BDY((Real)COEF(dc));
                 }      }
                 if(d)t*=pwrreal0(r,d);      if(d)t*=pwrreal0(r,d);
         }    }
         return t;    return t;
 }  }
   
 void qcalc(char **tab,struct canvas *can){  void qcalc(char **tab,struct canvas *can){
         //qifplotmain(Old type)    //qifplotmain(Old type)
         Q dx,dy,w,h,xstep,ystep,c,q1;    Q dx,dy,w,h,xstep,ystep,c,q1;
         P g,g1,f1,f2,x,y,t,s;    P g,g1,f1,f2,x,y,t,s;
         int ix,iy;    int ix,iy;
         int *a,*pa;    int *a,*pa;
         VECT ss;    VECT ss;
   
         subq(can->qxmax,can->qxmin,&dx); STOQ(can->width,w); divq(dx,w,&xstep);    subq(can->qxmax,can->qxmin,&dx); STOQ(can->width,w); divq(dx,w,&xstep);
         subq(can->qymax,can->qymin,&dy); STOQ(can->height,h); divq(dy,h,&ystep);    subq(can->qymax,can->qymin,&dy); STOQ(can->height,h); divq(dy,h,&ystep);
         MKV(can->vx,x); mulp(CO,(P)xstep,x,&t);    MKV(can->vx,x); mulp(CO,(P)xstep,x,&t);
         addp(CO,(P)can->qxmin,t,&s); substp(CO,can->formula,can->vx,s,&f1);    addp(CO,(P)can->qxmin,t,&s); substp(CO,can->formula,can->vx,s,&f1);
         MKV(can->vy,y); mulp(CO,(P)ystep,y,&t);    MKV(can->vy,y); mulp(CO,(P)ystep,y,&t);
         addp(CO,(P)can->qymin,t,&s); substp(CO,f1,can->vy,s,&f2);    addp(CO,(P)can->qymin,t,&s); substp(CO,f1,can->vy,s,&f2);
         ptozp(f2,1,&c,&g);    ptozp(f2,1,&c,&g);
         a=(int *)ALLOCA((MAX(can->width,can->height)+1)*sizeof(int));    a=(int *)ALLOCA((MAX(can->width,can->height)+1)*sizeof(int));
         initmarker(can,"Horizontal scan...");    initmarker(can,"Horizontal scan...");
         for( ix=0; ix < can->width; ix++ ){    for( ix=0; ix < can->width; ix++ ){
                 marker(can,DIR_X,ix);      marker(can,DIR_X,ix);
                 STOQ(ix,q1); substp(CO,g,can->vx,(P)q1,&t); ptozp(t,1,&c,&g1);      STOQ(ix,q1); substp(CO,g,can->vx,(P)q1,&t); ptozp(t,1,&c,&g1);
                 if( !g1 )      if( !g1 )
                         for(iy=0; iy < can->height; iy++ )        for(iy=0; iy < can->height; iy++ )
                                 tab[ix][iy]=1;          tab[ix][iy]=1;
                 else if( !NUM(g1) ){      else if( !NUM(g1) ){
                         sturmseq(CO,g1,&ss); seproot(ss,0,can->height,a);        sturmseq(CO,g1,&ss); seproot(ss,0,can->height,a);
                         for(iy=0, pa=a; iy < can->height; iy++, pa++ )        for(iy=0, pa=a; iy < can->height; iy++, pa++ )
                                 if( *pa < 0 || (*(pa+1) >= 0 && (*pa > *(pa+1))) )          if( *pa < 0 || (*(pa+1) >= 0 && (*pa > *(pa+1))) )
                                         tab[ix][iy]=1;            tab[ix][iy]=1;
                 }      }
         }    }
         initmarker(can,"Vertical scan...");    initmarker(can,"Vertical scan...");
         for( iy=0; iy < can->height; iy++ ){    for( iy=0; iy < can->height; iy++ ){
                 marker(can,DIR_Y,iy);      marker(can,DIR_Y,iy);
                 STOQ(iy,q1); substp(CO,g,can->vy,(P)q1,&t); ptozp(t,1,&c,&g1);      STOQ(iy,q1); substp(CO,g,can->vy,(P)q1,&t); ptozp(t,1,&c,&g1);
                 if( !g1 )      if( !g1 )
                         for(ix=0; ix < can->width; ix++ )        for(ix=0; ix < can->width; ix++ )
                                 tab[ix][iy]=1;          tab[ix][iy]=1;
                 else if( !NUM(g1) ){      else if( !NUM(g1) ){
                         sturmseq(CO,g1,&ss); seproot(ss,0,can->width,a);        sturmseq(CO,g1,&ss); seproot(ss,0,can->width,a);
                         for(ix=0, pa=a; ix < can->width; ix++, pa++ )        for(ix=0, pa=a; ix < can->width; ix++, pa++ )
                                 if( *pa < 0 || (*(pa+1) >= 0 && (*pa > *(pa+1))) )          if( *pa < 0 || (*(pa+1) >= 0 && (*pa > *(pa+1))) )
                                         tab[ix][iy]=1;            tab[ix][iy]=1;
                 }      }
         }    }
 }  }
   
 void sturmseq(VL vl,P p,VECT *rp){  void sturmseq(VL vl,P p,VECT *rp){
         P g1,g2,q,r,s,*t;    P g1,g2,q,r,s,*t;
         V v;    V v;
         VECT ret;    VECT ret;
         int i,j;    int i,j;
         Q a,b,c,d,h,l,m,x;    Q a,b,c,d,h,l,m,x;
   
         v=VR(p);t=(P *)ALLOCA((deg(v,p)+1)*sizeof(P));    v=VR(p);t=(P *)ALLOCA((deg(v,p)+1)*sizeof(P));
         g1=t[0]=p;diffp(vl,p,v,(P *)&a);ptozp((P)a,1,&c,&g2);t[1]=g2;    g1=t[0]=p;diffp(vl,p,v,(P *)&a);ptozp((P)a,1,&c,&g2);t[1]=g2;
         for(i=1,h=ONE,x=ONE;;){    for(i=1,h=ONE,x=ONE;;){
                 if(NUM(g2)) break;      if(NUM(g2)) break;
                 subq(DEG(DC(g1)),DEG(DC(g2)),&d);      subq(DEG(DC(g1)),DEG(DC(g2)),&d);
                 l=(Q)LC(g2);      l=(Q)LC(g2);
                 if(SGN(l)<0){      if(SGN(l)<0){
                         chsgnq(l,&a);l=a;        chsgnq(l,&a);l=a;
                 }      }
                 addq(d,ONE,&a);pwrq(l,a,&b);mulp(vl,(P)b,g1,(P *)&a);      addq(d,ONE,&a);pwrq(l,a,&b);mulp(vl,(P)b,g1,(P *)&a);
                 divsrp(vl,(P)a,g2,&q,&r);      divsrp(vl,(P)a,g2,&q,&r);
                 if(!r) break;      if(!r) break;
                 chsgnp(r,&s);r=s;i++;      chsgnp(r,&s);r=s;i++;
                 if(NUM(r)){      if(NUM(r)){
                         t[i]=r;break;        t[i]=r;break;
                 }      }
                 pwrq(h,d,&m);g1=g2;      pwrq(h,d,&m);g1=g2;
                 mulq(m,x,&a);divsp(vl,r,(P)a,&g2);t[i]=g2;      mulq(m,x,&a);divsp(vl,r,(P)a,&g2);t[i]=g2;
                 x=(Q)LC(g1);      x=(Q)LC(g1);
                 if(SGN(x)<0){      if(SGN(x)<0){
                         chsgnq(x,&a);x=a;        chsgnq(x,&a);x=a;
                 }      }
                 pwrq(x,d,&a);mulq(a,h,&b);divq(b,m,&h);      pwrq(x,d,&a);mulq(a,h,&b);divq(b,m,&h);
         }    }
         MKVECT(ret,i+1);    MKVECT(ret,i+1);
         for(j=0;j<=i;j++)    for(j=0;j<=i;j++)
                 ret->body[j]=(pointer)t[j];      ret->body[j]=(pointer)t[j];
         *rp=ret;    *rp=ret;
 }  }
   
 void seproot(VECT s,int min,int max,int *ar){  void seproot(VECT s,int min,int max,int *ar){
         P f,*ss;    P f,*ss;
         Q q,t;    Q q,t;
         int i,j,k;    int i,j,k;
   
         ss=(P *)s->body;f=ss[0];    ss=(P *)s->body;f=ss[0];
         for(i=min;i<=max;i++){    for(i=min;i<=max;i++){
                 STOQ(i,q);usubstqp(f,q,&t);      STOQ(i,q);usubstqp(f,q,&t);
                 if(!t)ar[i]=-1;      if(!t)ar[i]=-1;
                 else {      else {
                         ar[i]=numch(s,q,t);break;        ar[i]=numch(s,q,t);break;
                 }      }
         }    }
         if(i>max) return;    if(i>max) return;
         for(j=max;j>= min;j--){    for(j=max;j>= min;j--){
                 STOQ(j,q); usubstqp(f,q,&t);      STOQ(j,q); usubstqp(f,q,&t);
                 if(!t)ar[j]=-1;      if(!t)ar[j]=-1;
                 else {      else {
                         if(i!=j)ar[j]=numch(s,q,t);        if(i!=j)ar[j]=numch(s,q,t);
                         break;        break;
                 }      }
         }    }
         if(j<=i+1) return;    if(j<=i+1) return;
         if(ar[i]==ar[j]){    if(ar[i]==ar[j]){
                 for(k=i+1;k<j;k++)ar[k]=ar[i];      for(k=i+1;k<j;k++)ar[k]=ar[i];
                 return;      return;
         }    }
         k=(i+j)/2;    k=(i+j)/2;
         seproot(s,i,k,ar);    seproot(s,i,k,ar);
         seproot(s,k,j,ar);    seproot(s,k,j,ar);
 }  }
   
 int numch(VECT s,Q n,Q a0){  int numch(VECT s,Q n,Q a0){
         int len,i,c;    int len,i,c;
         Q a;    Q a;
         P *ss;    P *ss;
   
         len=s->len;ss=(P *)s->body;    len=s->len;ss=(P *)s->body;
         for(i=1,c=0;i<len;i++){    for(i=1,c=0;i<len;i++){
                 usubstqp(ss[i],n,&a);      usubstqp(ss[i],n,&a);
                 if(a){      if(a){
                         if((SGN(a)>0 && SGN(a0)<0)||(SGN(a)<0&&SGN(a0)>0))c++;        if((SGN(a)>0 && SGN(a0)<0)||(SGN(a)<0&&SGN(a0)>0))c++;
                         a0=a;        a0=a;
                 }      }
         }    }
         return c;    return c;
 }  }
   
 void usubstqp(P p,Q r,Q *v){  void usubstqp(P p,Q r,Q *v){
         Q d,d1,a,b,t;    Q d,d1,a,b,t;
         DCP dc;    DCP dc;
   
         if(!p)    if(!p)
                 *v=0;      *v=0;
         else if(NUM(p))*v=(Q)p;    else if(NUM(p))*v=(Q)p;
         else {    else {
                 dc=DC(p);t=(Q)COEF(dc);      dc=DC(p);t=(Q)COEF(dc);
                 for(d=DEG(dc),dc=NEXT(dc);dc;d=DEG(dc),dc=NEXT(dc)){      for(d=DEG(dc),dc=NEXT(dc);dc;d=DEG(dc),dc=NEXT(dc)){
                         subq(d,DEG(dc),&d1);pwrq(r,d1,&a);        subq(d,DEG(dc),&d1);pwrq(r,d1,&a);
                         mulq(t,a,&b);addq(b,(Q)COEF(dc),&t);        mulq(t,a,&b);addq(b,(Q)COEF(dc),&t);
                 }      }
                 if(d){      if(d){
                         pwrq(r,d,&a);mulq(t,a,&b);t=b;        pwrq(r,d,&a);mulq(t,a,&b);t=b;
                 }      }
                 *v=t;      *v=t;
         }    }
 }  }
   
   Num tobf(Num,int);
   
   void plotcalcbf(struct canvas *can){
     Obj fr,s,t;
     Num xmin,xmax,ymin,ymax,xstep;
     Num u,v,ha,dx,dy,x;
     Num *tab;
     Real r;
     Q w,h1;
     int ix;
     POINT *pa;
     double rr;
     Q prec;
     NODE arg;
   
     STOQ(can->prec,prec); arg = mknode(1,prec); Psetprec(arg,&t);
     evalr(CO,(Obj)can->formula,can->prec,&fr);
     MKReal(can->xmin,r); xmin = tobf((Num)r,can->prec);
     MKReal(can->xmax,r); xmax = tobf((Num)r,can->prec);
     MKReal(can->ymin,r); ymin = tobf((Num)r,can->prec);
     MKReal(can->ymax,r); ymax = tobf((Num)r,can->prec);
     STOQ(can->width,w);
     subbf(xmax,xmin,&dx); divbf(dx,(Num)w,&xstep);
     tab=(Num *)MALLOC(can->width*sizeof(Num));
     for(ix=0,x=xmin;ix<can->width;ix++){
       substr(CO,0,fr,can->vx,(Obj)x,(Obj *)&s);
       evalr(CO,(Obj)s,can->prec,&t);
       if(t&&(OID(t)!=O_N))
         error("plotcalcbf : invalid evaluation");
       tab[ix]=(Num)t;
       addbf(x,xstep,&u); x = u;
     }
     if(!cmpbf(ymax,ymin)){
       for(ymax=ymin=tab[0],ix=1;ix<can->width;ix++){
         if(cmpbf(tab[ix],ymax)>0)ymax=tab[ix];
         if(cmpbf(tab[ix],ymin)<0)ymin=tab[ix];
       }
       can->ymax=ToReal(ymax);can->ymin=ToReal(ymin);
     }
     subbf(ymax,ymin,&dy);
     can->pa=(struct pa *)MALLOC(sizeof(struct pa));
     can->pa[0].length=can->width;
     can->pa[0].pos=pa=(POINT *)MALLOC(can->width*sizeof(POINT));
     STOQ(can->height-1,h1);
     for(ix=0;ix<can->width;ix++){
       XC(pa[ix])=ix;
       subbf(ymax,tab[ix],&u); divbf(u,dy,&v); mulbf(v,(Num)h1,&u);
       rr = ToReal(u);
       if(rr>MAXSHORT)YC(pa[ix])=MAXSHORT;
       else if(rr<-MAXSHORT)YC(pa[ix])=-MAXSHORT;
       else YC(pa[ix])=(long)rr;
     }
   }
   
 void plotcalc(struct canvas *can){  void plotcalc(struct canvas *can){
         //plot,memory_plot,plotover,plot_resize    //plot,memory_plot,plotover,plot_resize
         double x,xmin,xstep,ymax,ymin,dy,*tab,usubstrp();    double x,xmin,xstep,ymax,ymin,dy,*tab,usubstrp();
         int ix,w,h;    int ix,w,h;
         Real r,rx;    Real r,rx;
         Obj fr,t,s;    Obj fr,t,s;
         POINT *pa;    POINT *pa;
   
         MKReal(1.0,r); mulr(CO,(Obj)can->formula,(Obj)r,&fr);    if ( can->prec ) {
         w=can->width;h=can->height;      plotcalcbf(can);
         xmin=can->xmin;xstep=(can->xmax-can->xmin)/w;      return;
         tab=(double *)ALLOCA(w*sizeof(double));    }
         MKReal(1,rx); // dummy real number    todouble((Obj)can->formula,&fr);
         for(ix=0,x=xmin;ix<w;ix++,x+=xstep){    w=can->width;h=can->height;
                 // full substitution    xmin=can->xmin;xstep=(can->xmax-can->xmin)/w;
                 BDY(rx)=x;    tab=(double *)ALLOCA(w*sizeof(double));
                 substr(CO,0,fr,can->vx,x?(Obj)rx:0,&s);    MKReal(1,rx); // dummy real number
                 devalr(CO,(Obj)s,&t);    for(ix=0,x=xmin;ix<w;ix++,x+=xstep){
                 if(t&&(OID(t)!=O_N||NID((Num)t)!=N_R))      // full substitution
                         error("plotcalc : invalid evaluation");      BDY(rx)=x;
                 tab[ix]=ToReal((Num)t);      substr(CO,0,fr,can->vx,x?(Obj)rx:0,&s);
         }      devalr(CO,(Obj)s,&t);
         if(can->ymax==can->ymin){      if(t&&(OID(t)!=O_N||NID((Num)t)!=N_R))
                 for(ymax=ymin=tab[0],ix=1;ix<w;ix++){        error("plotcalc : invalid evaluation");
                         if(tab[ix]>ymax)ymax=tab[ix];      tab[ix]=ToReal((Num)t);
                         if(tab[ix]<ymin)ymin=tab[ix];    }
                 }    if(can->ymax==can->ymin){
                 can->ymax=ymax;can->ymin=ymin;      for(ymax=ymin=tab[0],ix=1;ix<w;ix++){
         } else {        if(tab[ix]>ymax)ymax=tab[ix];
                 ymax=can->ymax;ymin=can->ymin;        if(tab[ix]<ymin)ymin=tab[ix];
         }      }
         dy=ymax-ymin;      can->ymax=ymax;can->ymin=ymin;
         can->pa=(struct pa *)MALLOC(sizeof(struct pa));    } else {
         can->pa[0].length=w;      ymax=can->ymax;ymin=can->ymin;
         can->pa[0].pos=pa=(POINT *)MALLOC(w*sizeof(POINT));    }
         for(ix=0;ix<w;ix++){    dy=ymax-ymin;
                 double t;    can->pa=(struct pa *)MALLOC(sizeof(struct pa));
                 XC(pa[ix])=ix;    can->pa[0].length=w;
                 t=(h-1)*(ymax-tab[ix])/dy;    can->pa[0].pos=pa=(POINT *)MALLOC(w*sizeof(POINT));
                 if(t>MAXSHORT)YC(pa[ix])=MAXSHORT;    for(ix=0;ix<w;ix++){
                 else if(t<-MAXSHORT)YC(pa[ix])=-MAXSHORT;      double t;
                 else YC(pa[ix])=(long)t;      XC(pa[ix])=ix;
         }      t=(h-1)*(ymax-tab[ix])/dy;
       if(t>MAXSHORT)YC(pa[ix])=MAXSHORT;
       else if(t<-MAXSHORT)YC(pa[ix])=-MAXSHORT;
       else YC(pa[ix])=(long)t;
     }
 }  }
   
 void polarplotcalc(struct canvas *can){  void polarcalc(struct canvas *can){
         //polarplotNG    double xmax,xmin,ymax,ymin,dx,dy,pmin,pstep,tr,p,*tabx,*taby;
         double xmax,xmin,ymax,ymin,dx,dy,pmin,pstep,tr,p, *tabx,*taby;    double usubstrp();
         double usubstrp();    int i,nstep,w,h;
         int i,nstep,w,h;    POINT *pa;
         POINT *pa;    Real r;
         Real r;    Obj fr,t,s;
         Obj fr,t,s;  
   
         MKReal(1.0,r); mulr(CO,(Obj)can->formula,(Obj)r,&fr);    todouble((Obj)can->formula,&fr);
         w=can->width; h=can->height; nstep=can->nzstep;    w=can->width; h=can->height; nstep=can->nzstep;
         pmin=can->zmin; pstep=(can->zmax-can->zmin)/nstep;    pmin=can->zmin; pstep=(can->zmax-can->zmin)/nstep;
         tabx=(double *)ALLOCA(nstep*sizeof(double));    tabx=(double *)ALLOCA(nstep*sizeof(double));
         taby=(double *)ALLOCA(nstep*sizeof(double));    taby=(double *)ALLOCA(nstep*sizeof(double));
         MKReal(1,r); // dummy real number    MKReal(1,r); // dummy real number
         for(i=0,p=pmin;i<nstep;i++,p+= pstep){  
                 // full substitution    for(i=0,p=pmin;i<nstep;i++,p+= pstep){
                 BDY(r)=p;      // full substitution
                 substr(CO,0,fr,can->vx,p?(Obj)r:0,&s);      BDY(r)=p;
                 devalr(CO,(Obj)s,&t);      substr(CO,0,fr,can->vx,p?(Obj)r:0,&s);
                 if(t&&(OID(t)!=O_N||NID((Num)t)!=N_R))      devalr(CO,(Obj)s,&t);
                         error("polarplotcalc : invalid evaluation");      if(t&&(OID(t)!=O_N||NID((Num)t)!=N_R))
                 tr=ToReal((Num)t);        error("polarcalc : invalid evaluation");
                 tabx[i]=tr*cos(p);      tr=ToReal((Num)t);
                 taby[i]=tr*sin(p);      tabx[i]=tr*cos(p);
         }      taby[i]=tr*sin(p);
         xmax=xmin=tabx[0];    }
         ymax=ymin=taby[0];    xmax=xmin=tabx[0];
         for(i=1;i<nstep;i++){    ymax=ymin=taby[0];
                 if(tabx[i]>xmax)xmax=tabx[i];    for(i=1;i<nstep;i++){
                 if(tabx[i]<xmin)xmin=tabx[i];      if(tabx[i]>xmax)xmax=tabx[i];
                 if(taby[i]>ymax)ymax=taby[i];      if(tabx[i]<xmin)xmin=tabx[i];
                 if(taby[i]<ymin)ymin=taby[i];      if(taby[i]>ymax)ymax=taby[i];
         }      if(taby[i]<ymin)ymin=taby[i];
         can->xmax=xmax;can->xmin=xmin;    }
         can->ymax=ymax;can->ymin=ymin;    can->xmax=xmax;can->xmin=xmin;
         dx=xmax-xmin;    can->ymax=ymax;can->ymin=ymin;
         dy=ymax-ymin;    dx=xmax-xmin;
         can->pa=(struct pa *)MALLOC(sizeof(struct pa));    dy=ymax-ymin;
         can->pa[0].length=nstep;    can->pa=(struct pa *)MALLOC(sizeof(struct pa));
         can->pa[0].pos=pa=(POINT *)MALLOC(w*sizeof(POINT));    can->pa[0].length=nstep;
         for(i=0;i<nstep;i++){    can->pa[0].pos=pa=(POINT *)MALLOC(w*sizeof(POINT));
                 XC(pa[i])=(w-1)*(tabx[i]-xmin)/dx;    for(i=0;i<nstep;i++){
                 YC(pa[i])=(h-1)*(ymax-taby[i])/dy;      XC(pa[i])=(w-1)*(tabx[i]-xmin)/dx;
         }      YC(pa[i])=(h-1)*(ymax-taby[i])/dy;
     }
 }  }
   
   void polarcalcNG(struct canvas *can){
     //polarplotNG
     double xmax,xmin,ymax,ymin,dx,dy,pmin,pstep,tr,p, *tabx,*taby;
     double usubstrp();
     int i,ix,iy,nstep,w,h;
     POINT *pa;
     Real r;
     Obj fr,t,s;
   
     todouble((Obj)can->formula,&fr);
     w=can->width; h=can->height; nstep=can->nzstep;
     pmin=can->zmin; pstep=(can->zmax-can->zmin)/nstep;
     tabx=(double *)ALLOCA(nstep*sizeof(double));
     taby=(double *)ALLOCA(nstep*sizeof(double));
     MKReal(1,r); // dummy real number
   
     for(i=0,p=pmin;i<nstep;i++,p+= pstep){
       // full substitution
       BDY(r)=p;
       substr(CO,0,fr,can->vx,p?(Obj)r:0,&s);
       devalr(CO,(Obj)s,&t);
       if(t&&(OID(t)!=O_N||NID((Num)t)!=N_R))
         error("polarcalc : invalid evaluation");
       tr=ToReal((Num)t);
       tabx[i]=tr*cos(p);
       taby[i]=tr*sin(p);
       if(i==0){
         xmax=xmin=tabx[0];
         ymax=ymin=taby[0];
       } else {
         if(tabx[i]>xmax)xmax=tabx[i];
         if(tabx[i]<xmin)xmin=tabx[i];
         if(taby[i]>ymax)ymax=taby[i];
         if(taby[i]<ymin)ymin=taby[i];
       }
     }
     can->xmax=xmax;can->xmin=xmin;
     can->ymax=ymax;can->ymin=ymin;
     dx=xmax-xmin;
     dy=ymax-ymin;
     can->pa=(struct pa *)MALLOC(sizeof(struct pa));
     can->pa[0].length=nstep;
     can->pa[0].pos=pa=(POINT *)MALLOC(w*sizeof(POINT));
     for(i=0;i<nstep;i++){
       XC(pa[i])=(w-1)*(tabx[i]-xmin)/dx;
       YC(pa[i])=(h-1)*(ymax-taby[i])/dy;
     }
   }
   
 /*  /*
 void ineqncalc(double **tab,struct canvas *can,int nox){  void ineqncalc(double **tab,struct canvas *can,int nox){
         double x,y,xmin,ymin,xstep,ystep;    double x,y,xmin,ymin,xstep,ystep;
         int ix,iy,w,h;    int ix,iy,w,h;
         Real r,rx,ry;    Real r,rx,ry;
         Obj fr,g,t,s;    Obj fr,g,t,s;
         V vx,vy;    V vx,vy;
   
         if(!nox) initmarker(can,"Evaluating...");    if(!nox) initmarker(can,"Evaluating...");
         MKReal(1.0,r); mulr(CO,(Obj)can->formula,(Obj)r,&fr);    todouble((Obj)can->formula,&fr);
         vx=can->vx;vy=can->vy;    vx=can->vx;vy=can->vy;
         w=can->width;h=can->height;    w=can->width;h=can->height;
         xmin=can->xmin;xstep=(can->xmax-can->xmin)/w;    xmin=can->xmin;xstep=(can->xmax-can->xmin)/w;
         ymin=can->ymin;ystep=(can->ymin-can->ymin)/h;    ymin=can->ymin;ystep=(can->ymin-can->ymin)/h;
         MKReal(1.0,rx); MKReal(1.0,ry); // dummy real    MKReal(1.0,rx); MKReal(1.0,ry); // dummy real
   
         for(ix=0,x=xmin;ix<=w;ix++,x+=xstep){    for(ix=0,x=xmin;ix<=w;ix++,x+=xstep){
                 BDY(rx)=x; substr(CO,0,fr,vx,x?(Obj)rx:0,&t);      BDY(rx)=x; substr(CO,0,fr,vx,x?(Obj)rx:0,&t);
                 devalr(CO,t,&g);      devalr(CO,t,&g);
                 if(!nox) marker(can,DIR_X,ix);      if(!nox) marker(can,DIR_X,ix);
                 for(iy=0,y=ymin;iy<=h;iy++,y+=ystep){      for(iy=0,y=ymin;iy<=h;iy++,y+=ystep){
                         BDY(ry)=y;        BDY(ry)=y;
                         substr(CO,0,g,vy,y?(Obj)ry:0,&t);        substr(CO,0,g,vy,y?(Obj)ry:0,&t);
                         devalr(CO,t,&s);        devalr(CO,t,&s);
                         tab[ix][iy]=ToReal(s);        tab[ix][iy]=ToReal(s);
                 }      }
         }    }
 }  }
 */  */
   
 #if defined(INTERVAL)  #if defined(INTERVAL)
 void itvcalc(double **mask, struct canvas *can, int nox){  void itvcalc(double **mask, struct canvas *can, int nox){
         //MODE_ITVIFPLOT    //ITVIFPLOT
         double x,y,xstep,ystep,dx,dy,wx,wy;    double x,y,xstep,ystep,dx,dy,wx,wy;
         int idv,ix,iy,idx,idy;    int idv,ix,iy,idx,idy;
         Itv ity,itx,ddx,ddy;    Itv ity,itx,ddx,ddy;
         Real r,rx,ry,rx1,ry1,rdx,rdy,rdx1,rdy1;    Real r,rx,ry,rx1,ry1,rdx,rdy,rdx1,rdy1;
         V vx,vy;    V vx,vy;
         Obj fr,g,t,s;    Obj fr,g,t,s;
   
         idv=can->division;    idv=can->division;
         MKReal(1.0,r); mulr(CO,(Obj)can->formula,(Obj)r,&fr);    todouble((Obj)can->formula,&fr);
         vx=can->vx; vy=can->vy;    vx=can->vx; vy=can->vy;
         xstep=(can->xmax-can->xmin)/can->width;    xstep=(can->xmax-can->xmin)/can->width;
         ystep=(can->ymax-can->ymin)/can->height;    ystep=(can->ymax-can->ymin)/can->height;
         if(idv!=0){    if(idv!=0){
                 wx=xstep/can->division;      wx=xstep/can->division;
                 wy=ystep/can->division;      wy=ystep/can->division;
         }    }
         MKReal(can->ymin,ry1);    MKReal(can->ymin,ry1);
         for(iy=0,y=can->ymin; iy<can->height; iy++,y+=ystep){    for(iy=0,y=can->ymin; iy<can->height; iy++,y+=ystep){
                 ry=ry1;      ry=ry1;
                 MKReal(y+ystep,ry1);      MKReal(y+ystep,ry1);
                 istoitv((Num)(ry1),(Num)ry,&ity);      istoitv((Num)(ry1),(Num)ry,&ity);
                 substr(CO,0,(Obj)fr,vy,(Obj)ity,&t);      substr(CO,0,(Obj)fr,vy,(Obj)ity,&t);
                 MKReal(can->xmin,rx1);      MKReal(can->xmin,rx1);
                 for(ix=0,x=can->xmin; ix<can->width; ix++,x+=xstep){      for(ix=0,x=can->xmin; ix<can->width; ix++,x+=xstep){
                         rx=rx1;        rx=rx1;
                         MKReal(x+xstep,rx1);        MKReal(x+xstep,rx1);
                         istoitv((Num)(rx1),(Num)rx,&itx);        istoitv((Num)(rx1),(Num)rx,&itx);
                         substr(CO,0,(Obj)fr,vx,(Obj)itx,&t);        substr(CO,0,(Obj)fr,vx,(Obj)itx,&t);
                         MKReal(can->ymin,ry1);        MKReal(can->ymin,ry1);
                         for(iy=0,y=can->ymin; iy<can->height; iy++,y+=ystep){        for(iy=0,y=can->ymin; iy<can->height; iy++,y+=ystep){
                                 ry=ry1;          ry=ry1;
                                 MKReal(y+ystep,ry1);          MKReal(y+ystep,ry1);
                                 istoitv((Num)ry,(Num)ry1,&ity);          istoitv((Num)ry,(Num)ry1,&ity);
                                 substr(CO,0,(Obj)t,vy,(Obj)ity,&g);          substr(CO,0,(Obj)t,vy,(Obj)ity,&g);
                                 if(compnum(0,0,(Num)g))mask[ix][iy]=-1;          if(compnum(0,0,(Num)g))mask[ix][iy]=-1;
                                 else {          else {
                                         mask[ix][iy]=0;            mask[ix][iy]=0;
 /*  /*
                                         if(idv==0) mask[ix][iy]=0;            if(idv==0) mask[ix][iy]=0;
                                         else {            else {
                                                 MKReal(y,rdy1);              MKReal(y,rdy1);
                                                 for(idy=0,dy=y;idy<idv;dy+=wy,idy++){              for(idy=0,dy=y;idy<idv;dy+=wy,idy++){
                                                         rdy=rdy1;                rdy=rdy1;
                                                         MKReal(dy+wy,rdy1);                MKReal(dy+wy,rdy1);
                                                         istoitv((Num)rdy,(Num)rdy1,&ddy);                istoitv((Num)rdy,(Num)rdy1,&ddy);
                                                         substr(CO,0,(Obj)fr,vy,(Obj)ddy,&t);                substr(CO,0,(Obj)fr,vy,(Obj)ddy,&t);
                                                         MKReal(x,rdx1);                MKReal(x,rdx1);
                                                         for(idx=0,dx=x;idx<idx;dx+=wx,idx++){                for(idx=0,dx=x;idx<idx;dx+=wx,idx++){
                                                                 rdx=rdx1;                  rdx=rdx1;
                                                                 MKReal(dx+wx,rdx1);                  MKReal(dx+wx,rdx1);
                                                                 istoitv((Num)rdx,(Num)rdx1,&ddx);                  istoitv((Num)rdx,(Num)rdx1,&ddx);
                                                                 substr(CO,0,(Obj)t,vx,(Obj)ddx,&g);                  substr(CO,0,(Obj)t,vx,(Obj)ddx,&g);
                                                                 if(!compnum(0,0,(Num)g)){                  if(!compnum(0,0,(Num)g)){
                                                                         mask[ix][iy]=0;                    mask[ix][iy]=0;
                                                                         break;                    break;
                                                                 }                  }
                                                         }                }
                                                         if(mask[ix][iy]==0)break;                if(mask[ix][iy]==0)break;
                                                 }              }
                                         }            }
 */  */
                                 }          }
                         }        }
                 }      }
         }    }
 }  }
 #endif  #endif
Legend:
Removed from v.1.9  
changed lines
  Added in v.1.15
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>