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

Diff for /OpenXM_contrib2/asir2000/plot/plotf.c between version 1.23 and 1.34

version 1.23, 2012/10/04 04:56:39 version 1.34, 2018/03/29 01:32:55
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/plotf.c,v 1.22 2011/08/10 04:51:58 saito Exp $   * $OpenXM: OpenXM_contrib2/asir2000/plot/plotf.c,v 1.33 2017/09/04 01:57:53 noro Exp $
 */  */
 #include "ca.h"  #include "ca.h"
 #include "parse.h"  #include "parse.h"
 #include "ox.h"  #include "ox.h"
 #include "ifplot.h"  #include "ifplot.h"
   
 void Pifplot(NODE, Obj *), Pconplot(NODE, Obj *), Pplotover(NODE, Q *);  int validate_ox_plot_stream(int);
 void Pplot(NODE, Obj *), Parrayplot(NODE, Q *), Pdrawcircle(NODE, Q *);  void ListCheck(char *,LIST);
   void Pplot(NODE,Obj *);
   void Ppolarplot(NODE,Obj *);
   void Pobj_cp(NODE,Obj *),Parrayplot(NODE,Obj*),Pdrawcircle(NODE,Obj*);
   void Pifplot(NODE,Obj *),Pconplot(NODE,Obj *),Pplotover(NODE,Obj *);
   void Pmemory_ifplot(NODE,Obj *),Pmemory_conplot(NODE,Obj *);
   void Pmemory_plot(NODE,Obj *);
   void ifplot_main(NODE,int,char *,Obj *);
   void plot_main(NODE,int,char *,Obj *);
   void conplot_main(NODE,int,Obj *);
   
   void Popen_canvas(NODE,Obj *),Pclear_canvas(NODE,Obj *),Pdraw_obj(NODE,Obj *);
   void Pdraw_string(NODE,Obj *);
   void Pox_rpc(NODE,Obj *), Pox_cmo_rpc(NODE,Obj *);
   
   //NG
 #if defined(INTERVAL)  #if defined(INTERVAL)
 void Pitvplot1(NODE, Obj *), itvplot_main1(NODE, Obj *); //NORMAL  void Pitvifplot(NODE, Obj *);
 void Pitvplot2(NODE, Obj *), itvplot_main2(NODE, Obj *); //TRANSFER  
 void Pitvplot3(NODE, Obj *), itvplot_main3(NODE, Obj *); //RECURSION  
 void Pitvplot4(NODE, Obj *), itvplot_main4(NODE, Obj *); //RECURSION+TRANSFER  
 void Pitvplot(NODE, Obj *), itvplot_main(NODE, Obj *); //NEWTYPE  
 void Pobj_cp(NODE, Obj *);  
 void Pineqn(NODE, Obj *), Pineqnor(NODE, Obj *), Pineqnand(NODE, Obj *);  
 void Pineqnxor(NODE, Obj *), Pmemory_ineqn(NODE, Obj *);  
 void ineqn_main(NODE, int, Obj *);  
 void ineqn_main_op(NODE, int, int, Obj *);  
 #endif  #endif
 void Ppolarplot(NODE, Q *);  void PifplotD(NODE,Obj *),PifplotQ(NODE,Obj *),PifplotB(NODE,Obj *);
 void Pmemory_ifplot(NODE, Obj *), Pmemory_conplot(NODE, Obj *);  void PineqnD(NODE,Obj *), PineqnQ(NODE,Obj *), PineqnB(NODE,Obj *);
 void Pmemory_plot(NODE, Obj *);  void PineqnandD(NODE,Obj *), PineqnandQ(NODE,Obj *), PineqnandB(NODE,Obj *);
 void Popen_canvas(NODE, Q *), Pclear_canvas(NODE, Q *), Pdraw_obj(NODE, Q *);  void PineqnorD(NODE,Obj *), PineqnorQ(NODE,Obj *), PineqnorB(NODE,Obj *);
 void Pdraw_string(NODE, Q *);  void PineqnxorD(NODE,Obj *), PineqnxorQ(NODE,Obj *), PineqnxorB(NODE,Obj *);
 void Pox_rpc(), Pox_cmo_rpc();  void PconplotD(NODE,Obj *),PconplotQ(NODE,Obj *),PconplotB(NODE,Obj *);
 void ifplot_main(NODE, int, Obj *);  void PpolarplotD(NODE,Obj *);
 void conplot_main(NODE, int, Obj *);  void PplotoverD(NODE,Obj *),PplotoverQ(NODE,Obj *),PplotoverB(NODE,Obj *);
 void plot_main(NODE, int, Obj *);  void ifplot_mainNG(NODE,char *,Obj *);
   void conplot_mainNG(NODE,char *,Obj *);
 struct ftab plot_tab[] = {  void plotover_mainNG(NODE,char *,Obj *);
         {"ifplot",Pifplot,-7},  
         {"memory_ifplot",Pmemory_ifplot,-6},  struct ftab plot_tab[]={
     {PLOT,Pplot,-7},
 #if defined(INTERVAL)  #if defined(INTERVAL)
         {"itvplot1",Pitvplot1,-7},    {ITVIFPLOT,Pitvifplot,-8},
         {"itvplot2",Pitvplot2,-7},  
         {"itvplot3",Pitvplot3,-7},  
         {"itvplot4",Pitvplot4,-7},  
         {"itvplot",Pitvplot,-7},  
         {"ineqn",Pineqn,-8},  
         {"ineqnor",Pineqnor,-7},  
         {"ineqnand",Pineqnand,-7},  
         {"ineqnxor",Pineqnxor,-7},  
         {"memory_ineqn",Pmemory_ineqn,-6},  
         {"obj_cp",Pobj_cp,4},  
 #endif  #endif
         {"conplot",Pconplot,-8},    {OBJ_CP,Pobj_cp,4},
         {"memory_conplot",Pmemory_conplot,-7},    {POLARPLOT,Ppolarplot,-6},
         {"plot",Pplot,-6},    {POLARPLOTD,PpolarplotD,-7},
         {"memory_plot",Pmemory_plot,-5},    {IFPLOT,Pifplot,-7},
         {"polarplot",Ppolarplot,-6},    {IFPLOTD,PifplotD,-8},
         {"plotover",Pplotover,-4},    {IFPLOTQ,PifplotQ,-8},
         {"drawcircle",Pdrawcircle,6},    {IFPLOTB,PifplotB,-8},
         {"open_canvas",Popen_canvas,-3},    {INEQN,PineqnD,-8},
         {"clear_canvas",Pclear_canvas,2},    {INEQND,PineqnD,-8},
         {"draw_obj",Pdraw_obj,-4},    {INEQNQ,PineqnQ,-8},
         {"draw_string",Pdraw_string,-5},    {INEQNB,PineqnB,-8},
         {0,0,0},    {INEQNAND,PineqnandD,-4},
     {INEQNDAND,PineqnandD,-4},
     {INEQNQAND,PineqnandQ,-4},
     {INEQNBAND,PineqnandB,-4},
     {INEQNOR,PineqnorD,-4},
     {INEQNDOR,PineqnorD,-4},
     {INEQNQOR,PineqnorQ,-4},
     {INEQNBOR,PineqnorB,-4},
     {INEQNXOR,PineqnxorD,-4},
     {INEQNDXOR,PineqnxorD,-4},
     {INEQNQXOR,PineqnxorQ,-4},
     {INEQNBXOR,PineqnxorB,-4},
     {CONPLOT,Pconplot,-7},
     {CONPLOTD,PconplotD,-8},
     {CONPLOTB,PconplotB,-8},
     {CONPLOTQ,PconplotQ,-8},
     {PLOTOVER,Pplotover,-4},
     {PLOTOVERD,PplotoverD,-4},
     {PLOTOVERQ,PplotoverQ,-4},
     {PLOTOVERB,PplotoverB,-4},
     {MEMORY_IFPLOT,Pmemory_ifplot,-7},
     {MEMORY_CONPLOT,Pmemory_conplot,-7},
     {MEMORY_PLOT,Pmemory_plot,-7},
     {DRAWCIRCLE,Pdrawcircle,6},
     {OPEN_CANVAS,Popen_canvas,-3},
     {CLEAR_CANVAS,Pclear_canvas,2},
     {DRAW_OBJ,Pdraw_obj,-4},
     {DRAW_STRING,Pdraw_string,-5},
     {0,0,0},
 };  };
   char *pfn[]={
 void Popen_canvas(NODE arg,Q *rp)    IFPLOT,CONPLOT,PLOT,INTERACTIVE,POLARPLOT,PLOTOVER,
 {    IFPLOTD,IFPLOTQ,IFPLOTB,INEQND,INEQNQ,INEQNB,
         Q w300,s_id;    INEQNDAND,INEQNQAND,INEQNBAND,
         LIST geom;    INEQNDOR,INEQNQOR,INEQNBOR,
         int stream;    INEQNDXOR,INEQNQXOR,INEQNBXOR,
         NODE n,n0;    CONPLOTD,CONPLOTQ,CONPLOTB,ITVIFPLOT,
         STRING fname,wname;    PLOTOVERD,PLOTOVERQ,PLOTOVERB,
     MEMORY_IFPLOT,MEMORY_CONPLOT,MEMORY_PLOT,ARRAYPLOT,OPEN_CANVAS,
         geom = 0; wname = 0; stream = -1;    DRAWCIRCLE,DRAW_OBJ,DRAW_STRING,OBJ_CP,CLEAR_CANVAS,POLARPLOTD};
         for ( ; arg; arg = NEXT(arg) )  /*
                 if ( !BDY(arg) )    IFPLOT:0,CONPLOT:1,PLOT:2,INTERACTIVE:3,POLARPLOT:4,PLOTOVER:5,
                         stream = 0;    IFPLOTD:6,IFPLOTQ:7,IFPLOTB:8,INEQND:9,INEQNQ:10,INEQNB:11,
                 else    INEQNDAND:12,INEQNQAND:13,INEQNBAND:14,
                 switch ( OID(BDY(arg)) ) {    INEQNDOR:15,INEQNQOR:16,INEQNBOR:17,
                 case O_LIST:    INEQNDXOR:18,INEQNQXOR:19,INEQNBXOR:20,
                         geom = (LIST)BDY(arg);    CONPLOTD:21,CONPLOTQ:22,CONPLOTB:23,ITVIFPLOT:24,
                         break;    PLOTOVERD:25,PLOTOVERQ:26,PLOTOVERB:27,
                 case O_N:    MEMORY_IFPLOT:28,MEMORY_CONPLOT:29,MEMORY_PLOT:30,ARRAYPLOT:31,
                         stream = QTOS((Q)BDY(arg)); break;    OPEN_CANVAS:32,DRAWCIRCLE:33,DRAW_OBJ:34,DRAW_STRING:35,OBJ_CP:36,
                 case O_STR:    CLEAR_CANVAS:37,POLARPLOTD:38
                         wname = (STRING)BDY(arg); break;  */
                 default:  int modeNO(char *fn){
                         error("open_canvas : invalid argument"); break;    int i;
                 }    char **z;
         stream = validate_ox_plot_stream(stream);    for(i=0,z=pfn;*z!=NULL;z++,i++)if(!strcmp(fn,*z))return i;
         STOQ(stream,s_id);    return -1;
         if ( !geom ) {  
                 STOQ(300,w300);  
                 MKNODE(n0,w300,0); MKNODE(n,w300,n0); MKLIST(geom,n);  
         }  
         MKSTR(fname,"open_canvas");  
         arg = mknode(4,s_id,fname,geom,wname);  
         Pox_cmo_rpc(arg,rp);  
         *rp = s_id;  
 }  }
   
 void Pifplot(NODE arg,Obj *rp)  void Popen_canvas(NODE arg,Obj *rp){
 {    Q w300,s_id;
         ifplot_main(arg,0,rp);    LIST geom;
 }    int stream;
     NODE n,n0;
     STRING fname,wname;
   
 void Pmemory_ifplot(NODE arg,Obj *rp)    geom=0;wname=0;stream=-1;
 {    for(;arg;arg=NEXT(arg))
         ifplot_main(arg,1,rp);      if(!BDY(arg)) stream=0;
       else switch (OID(BDY(arg))){
         case O_LIST:
           geom=(LIST)BDY(arg);
           break;
         case O_N:
           stream=QTOS((Q)BDY(arg));
           break;
         case O_STR:
           wname=(STRING)BDY(arg);
           break;
         default:
           error("open_canvas : invalid argument");
           break;
       }
     stream=validate_ox_plot_stream(stream);
     STOQ(stream,s_id);
     if(!geom){
       STOQ(300,w300);
       MKNODE(n0,w300,0);
       MKNODE(n,w300,n0);
       MKLIST(geom,n);
     }
     MKSTR(fname,OPEN_CANVAS);
     arg=mknode(4,s_id,fname,geom,wname);
     Pox_cmo_rpc(arg,rp);
     *rp=(Obj)s_id;
 }  }
   
 void ifplot_main(NODE arg,int is_memory, Obj *rp)  void Pifplot(NODE arg,Obj *rp){ifplot_main(arg,0,IFPLOT,rp);}
 {  void Pmemory_ifplot(NODE arg,Obj *rp){ifplot_main(arg,1,IFPLOT,rp);}
         Q m2,p2,w300,s_id;  
         NODE defrange;  
         LIST xrange,yrange,range[2],list,geom;  
         VL vl,vl0;  
         V v[2],av[2];  
         int stream,ri,i,sign;  
         P poly;  
         P var;  
         NODE n,n0;  
         STRING fname,wname;  
         Obj t;  
   
         STOQ(-2,m2); STOQ(2,p2);  void ifplot_main(NODE arg,int is_memory,char *fn,Obj *rp){
         MKNODE(n,p2,0); MKNODE(defrange,m2,n);    Q m2,p2,w300,s_id;
         poly = 0; vl = 0; geom = 0; wname = 0; stream = -1; ri = 0;    NODE defrange;
         v[0] = v[1] = 0;    LIST xrange,yrange,zrange,range[2],list,geom;
         for ( ; arg; arg = NEXT(arg) )    VL vl,vl0;
                 if ( !BDY(arg) ) stream = 0;    V v[2],av[2];
                 else    int stream,ri,i,sign;
                 switch ( OID(BDY(arg)) ) {    Obj poly;
                 case O_P:    P var;
                         poly = (P)BDY(arg);    NODE n,n0;
                         get_vars_recursive((Obj)poly,&vl);    STRING fname,wname;
                         for ( vl0 = vl, i = 0; vl0; vl0 = NEXT(vl0) )    Obj t;
                                 if ( vl0->v->attr == (pointer)V_IND )    int found_f;
                                         if ( i >= 2 ) error("ifplot : invalid argument");  
                                         else v[i++] = vl0->v;  
                         break;  
                 case O_LIST:  
                         list = (LIST)BDY(arg);  
                         if ( OID(BDY(BDY(list))) == O_P )  
                                 if ( ri > 1 ) error("ifplot : invalid argument");  
                                 else range[ri++] = list;  
                         else geom = list;  
                         break;  
                 case O_N:  
                         stream = QTOS((Q)BDY(arg)); break;  
                 case O_STR:  
                         wname = (STRING)BDY(arg); break;  
                 default:  
                         error("ifplot : invalid argument"); break;  
                 }  
         if ( !poly ) error("ifplot : invalid argument");  
         switch ( ri ) {  
         case 0:  
                 if ( !v[1] ) error("ifplot : please specify all variables");  
                 MKV(v[0],var); MKNODE(n,var,defrange); MKLIST(xrange,n);  
                 MKV(v[1],var); MKNODE(n,var,defrange); MKLIST(yrange,n);  
                 break;  
         case 1:  
                 if ( !v[1] ) error("ifplot : please specify all variables");  
                 av[0] = VR((P)BDY(BDY(range[0])));  
                 if ( v[0] == av[0] ) {  
                         xrange = range[0];  
                         MKV(v[1],var); MKNODE(n,var,defrange); MKLIST(yrange,n);  
                 } else if ( v[1] == av[0] ) {  
                         MKV(v[0],var); MKNODE(n,var,defrange); MKLIST(xrange,n);  
                         yrange = range[0];  
                 } else error("ifplot : invalid argument");  
                 break;  
         case 2:  
                 av[0] = VR((P)BDY(BDY(range[0])));  
                 av[1] = VR((P)BDY(BDY(range[1])));  
                 if ( ((v[0] == av[0]) && (!v[1] || v[1] == av[1])) ||  
                         ((v[0] == av[1]) && (!v[1] || v[1] == av[0])) ) {  
                         xrange = range[0]; yrange = range[1];  
                 } else error("ifplot : invalid argument");  
                 break;  
         default:  
                 error("ifplot : cannot happen"); break;  
         }  
         /* ifplot in ox_plot requires  
                 [s_id (Q),  
                 formula (Obj),  
                 xrange=[x,xmin,xmax] (LIST),  
                 yrange=[y,ymin,ymax] (LIST),  
                 zrange=0,  
                 geom=[xsize,ysize] (LIST),  
                 wname=name (STRING)]  
         */  
   
         stream = validate_ox_plot_stream(stream);    STOQ(-2,m2);STOQ(2,p2);MKNODE(n,p2,0);MKNODE(defrange,m2,n);
         STOQ(stream,s_id);    poly=0;vl=0;geom=0;wname=0;stream=-1;ri=0;xrange=0;yrange=0;zrange=0;
         if ( !geom ) {    v[0]=v[1]=0;
                 STOQ(300,w300);    found_f = 0;
                 MKNODE(n0,w300,0); MKNODE(n,w300,n0); MKLIST(geom,n);    for(;arg;arg=NEXT(arg))
         }      if(!BDY(arg)){
         if ( is_memory ) {        if ( !found_f ) {
                 MKSTR(fname,"memory_plot");          poly = 0;
                 arg = mknode(8,s_id,fname,poly,xrange,yrange,0,geom);          found_f = 1;
                 Pox_rpc(arg,&t);        } else stream=0;
                 arg = mknode(1,s_id);      } else
                 Pox_pop_cmo(arg,rp);      switch(OID(BDY(arg))){
         } else {      case O_P:
                 MKSTR(fname,"plot");        poly=(Obj)BDY(arg);
                 arg = mknode(8,s_id,fname,poly,xrange,yrange,0,geom,wname);        get_vars_recursive((Obj)poly,&vl);
                 Pox_rpc(arg,&t);        for(vl0=vl,i=0;vl0;vl0=NEXT(vl0)){
                 *rp = (Obj)s_id;          if(vl0->v->attr==(pointer)V_IND){
         }            if(i>=2)error("ifplot : invalid argument");
             else v[i++]=vl0->v;
           }
         }
         found_f = 1;
         break;
       case O_LIST:
         list=(LIST)BDY(arg);
         if(OID(BDY(BDY(list)))==O_P)
           if(ri>1) error("ifplot : invalid argument");
           else range[ri++]=list;
         else geom=list;
         break;
       case O_N:
         if ( !found_f ) {
           poly = (Obj)BDY(arg);
           found_f = 1;
         } else stream=QTOS((Q)BDY(arg));
         break;
       case O_STR:
         wname=(STRING)BDY(arg);break;
       default:
         error("ifplot : invalid argument");break;
       }
     if(!found_f) error("ifplot : invalid argument");
     switch(ri){
     case 0:
       if(!v[1]) error("ifplot : please specify all variables");
       MKV(v[0],var);MKNODE(n,var,defrange);MKLIST(xrange,n);
       MKV(v[1],var);MKNODE(n,var,defrange);MKLIST(yrange,n);
       break;
     case 1:
       if(!v[1]) error("ifplot : please specify all variables");
       av[0]=VR((P)BDY(BDY(range[0])));
       if(!poly || NUM(poly) || v[0]==av[0]){
         xrange=range[0];
         MKV(v[1],var);MKNODE(n,var,defrange);MKLIST(yrange,n);
       } else if(v[1]==av[0]){
         MKV(v[0],var);MKNODE(n,var,defrange);MKLIST(xrange,n);
         yrange=range[0];
       } else error("ifplot : invalid argument");
       break;
     case 2:
       av[0]=VR((P)BDY(BDY(range[0])));
       av[1]=VR((P)BDY(BDY(range[1])));
       if(!poly || NUM(poly) || (((v[0]==av[0])&&(!v[1]||v[1]==av[1]))||
         ((v[0]==av[1])&&(!v[1]||v[1]==av[0])))){
         xrange=range[0];yrange=range[1];
       } else error("ifplot : invalid argument");
       break;
     default:
       error("ifplot : cannot happen");break;
     }
     /* ifplot in ox_plot requires
       [s_id (Q),
       formula (Obj),
       xrange=[x,xmin,xmax] (LIST),
       yrange=[y,ymin,ymax] (LIST),
       zrange=0,
       geom=[xsize,ysize] (LIST),
       wname=name (STRING)]
     */
     stream=validate_ox_plot_stream(stream);
     STOQ(stream,s_id);
     if(!geom){
       STOQ(300,w300);MKNODE(n0,w300,0);MKNODE(n,w300,n0);MKLIST(geom,n);
     }
     if(is_memory){
       MKSTR(fname,MEMORY_PLOT);
       arg=mknode(8,s_id,fname,poly,xrange,yrange,zrange,geom);
       Pox_rpc(arg,&t);
       arg=mknode(1,s_id);
       Pox_pop_cmo(arg,rp);
     } else {
       MKSTR(fname,fn);
       arg=mknode(8,s_id,fname,poly,xrange,yrange,zrange,geom,wname);
       Pox_rpc(arg,&t);
       *rp=(Obj)s_id;
     }
 }  }
   
 #if defined(INTERVAL)  void Pconplot(NODE arg,Obj *rp){conplot_main(arg, 0, rp);}
 void Pitvplot(NODE arg, Obj *rp)  void Pmemory_conplot(NODE arg,Obj *rp){conplot_main(arg,1,rp);}
 {  
         itvplot_main(arg, rp);  
 }  
   
 void itvplot_main(NODE arg, Obj *rp)  void conplot_main(NODE arg,int is_memory,Obj *rp){
 {    Q m2,p2,w300,s_id;
         Q m2,p2,w300,s_id, itvsize;    NODE defrange;
         NODE defrange;    LIST xrange,yrange,zrange,range[3],list,geom;
         LIST xrange,yrange,range[2],list,geom;    VL vl,vl0;
         VL vl,vl0;    V v[2],av[2];
         V v[2],av[2];    int stream,ri,i;
         int stream,ri,i,sign;    P poly;
         P poly;    P var;
         P var;    NODE n,n0;
         NODE n,n0;    STRING fname,wname;
         STRING fname,wname;    Obj t;
         Obj t;  
   
         STOQ(-2,m2); STOQ(2,p2);    STOQ(-2,m2); STOQ(2,p2);
         MKNODE(n,p2,0); MKNODE(defrange,m2,n);    MKNODE(n,p2,0); MKNODE(defrange,m2,n);
         poly = 0; vl = 0; geom = 0; wname = 0; stream = -1; ri = 0;    poly = 0; vl = 0; geom = 0; wname = 0; stream = -1; ri = 0;
         v[0] = v[1] = 0;    v[0] = v[1] = 0;
         for ( ; arg; arg = NEXT(arg) )    for ( ; arg; arg = NEXT(arg) )
                 if ( !BDY(arg) ) stream = 0;      if ( !BDY(arg) )
                 else        stream = 0;
                 switch ( OID(BDY(arg)) ) {      else
                 case O_P:      switch ( OID(BDY(arg)) ) {
                         poly = (P)BDY(arg);        case O_P:
                         get_vars_recursive((Obj)poly,&vl);          poly = (P)BDY(arg);
                         for ( vl0 = vl, i = 0; vl0; vl0 = NEXT(vl0) )          get_vars_recursive((Obj)poly,&vl);
                                 if ( vl0->v->attr == (pointer)V_IND )          for ( vl0 = vl, i = 0; vl0; vl0 = NEXT(vl0) )
                                         if ( i >= 2 ) error("itvplot : invalid argument");            if ( vl0->v->attr == (pointer)V_IND )
                                         else v[i++] = vl0->v;              if ( i >= 2 )
                         break;                error("ifplot : invalid argument");
                 case O_LIST:              else
                         list = (LIST)BDY(arg);                v[i++] = vl0->v;
                         if ( OID(BDY(BDY(list))) == O_P )          break;
                                 if ( ri > 1 ) error("itvplot : invalid argument");        case O_LIST:
                                 else range[ri++] = list;          list = (LIST)BDY(arg);
                         else geom = list;          if ( OID(BDY(BDY(list))) == O_P )
                         break;            if ( ri > 2 )
                 case O_N:              error("ifplot : invalid argument");
                         stream = QTOS((Q)BDY(arg)); break;            else
                 case O_STR:              range[ri++] = list;
                         wname = (STRING)BDY(arg); break;          else
                 default:            geom = list;
                         error("itvplot : invalid argument"); break;          break;
         }        case O_N:
         if ( !poly ) error("itvplot : invalid argument");          stream = QTOS((Q)BDY(arg)); break;
         switch ( ri ) {        case O_STR:
         case 0:          wname = (STRING)BDY(arg); break;
                 if ( !v[1] ) error("itvplot : please specify all variables");        default:
                 MKV(v[0],var); MKNODE(n,var,defrange); MKLIST(xrange,n);          error("ifplot : invalid argument"); break;
                 MKV(v[1],var); MKNODE(n,var,defrange); MKLIST(yrange,n);      }
                 break;    if ( !poly )
         case 1:      error("ifplot : invalid argument");
                 if ( !v[1] ) error("itvplot : please specify all variables");    switch ( ri ) {
                 av[0] = VR((P)BDY(BDY(range[0])));      case 0:
                 if ( v[0] == av[0] ) {        if ( !v[1] )
                         xrange = range[0];          error("ifplot : please specify all variables");
                         MKV(v[1],var); MKNODE(n,var,defrange); MKLIST(yrange,n);        MKV(v[0],var); MKNODE(n,var,defrange); MKLIST(xrange,n);
                 } else if ( v[1] == av[0] ) {        MKV(v[1],var); MKNODE(n,var,defrange); MKLIST(yrange,n);
                         MKV(v[0],var); MKNODE(n,var,defrange); MKLIST(xrange,n);        MKNODE(n,0,defrange); MKLIST(zrange,n);
                         yrange = range[0];        break;
                 } else error("itvplot : invalid argument");      case 1:
                 break;        if ( !v[1] )
         case 2:          error("ifplot : please specify all variables");
                 av[0] = VR((P)BDY(BDY(range[0])));        av[0] = VR((P)BDY(BDY(range[0])));
                 av[1] = VR((P)BDY(BDY(range[1])));        if ( v[0] == av[0] ) {
                 if ( ((v[0] == av[0]) && (!v[1] || v[1] == av[1])) ||          xrange = range[0];
                         ((v[0] == av[1]) && (!v[1] || v[1] == av[0])) ) {          MKV(v[1],var); MKNODE(n,var,defrange); MKLIST(yrange,n);
                         xrange = range[0]; yrange = range[1];          MKNODE(n,0,defrange); MKLIST(zrange,n);
                 } else error("itvplot : invalid argument");        } else if ( v[1] == av[0] ) {
                 break;          MKV(v[0],var); MKNODE(n,var,defrange); MKLIST(xrange,n);
         default:          yrange = range[0];
                 error("itvplot : cannot happen"); break;          MKNODE(n,0,defrange); MKLIST(zrange,n);
         }        } else {
         /* itvplot in ox_plot requires          MKV(v[0],var); MKNODE(n,var,defrange); MKLIST(xrange,n);
            [s_id (Q),          MKV(v[1],var); MKNODE(n,var,defrange); MKLIST(yrange,n);
                 formula (Obj),          zrange = range[0];
                 xrange=[x,xmin,xmax] (LIST),        }
                 yrange=[y,ymin,ymax] (LIST),        break;
                 zrange=0,      case 2: case 3:
                 geom=[xsize,ysize] (LIST),        av[0] = VR((P)BDY(BDY(range[0])));
                 wname=name (STRING)]        av[1] = VR((P)BDY(BDY(range[1])));
         */        if ( ((v[0] == av[0]) && (!v[1] || v[1] == av[1])) ||
         stream = validate_ox_plot_stream(stream);           ((v[0] == av[1]) && (!v[1] || v[1] == av[0])) ) {
         STOQ(stream,s_id);          xrange = range[0]; yrange = range[1];
         if ( !geom ) {          if ( ri == 3 )
                 STOQ(300,w300);            zrange = range[2];
                 MKNODE(n0,w300,0); MKNODE(n,w300,n0); MKLIST(geom,n);          else {
         }            MKNODE(n,0,defrange); MKLIST(zrange,n);
         MKSTR(fname,"itvifplot");          }
         STOQ(Itvplot, itvsize);        } else
         arg = mknode(9,s_id,fname,poly,xrange,yrange,0,geom,wname,itvsize);          error("ifplot : invalid argument");
         Pox_rpc(arg,&t);        break;
         *rp = (Obj)s_id;      default:
 }        error("ifplot : cannot happen"); break;
     }
     /* conplot in ox_plot requires
        [s_id (Q),
          formula (Obj),
          xrange=[x,xmin,xmax] (LIST),
          yrange=[y,ymin,ymax] (LIST),
          zrange=[z,zmin,zmax] (LIST),
          geom=[xsize,ysize] (LIST),
          wname=name (STRING)]
     */
   
 void Pitvplot1(NODE arg, Obj *rp)    stream = validate_ox_plot_stream(stream);
 {    STOQ(stream,s_id);
         itvplot_main1(arg, rp);    if ( !geom ) {
       STOQ(300,w300);
       MKNODE(n0,w300,0); MKNODE(n,w300,n0); MKLIST(geom,n);
     }
     if ( is_memory ) {
       MKSTR(fname,"memory_plot");
       arg = mknode(7,s_id,fname,poly,xrange,yrange,zrange,geom);
       Pox_rpc(arg,&t);
       arg = mknode(1,s_id);
       Pox_pop_cmo(arg,rp);
     } else {
       MKSTR(fname,CONPLOT);
       arg = mknode(8,s_id,fname,poly,xrange,yrange,zrange,geom,wname);
       Pox_rpc(arg,&t);
       *rp = (Obj)s_id;
     }
 }  }
   
 void Pitvplot2(NODE arg, Obj *rp)  void Pplot(NODE arg,Obj *rp){plot_main(arg,0,PLOT,rp);}
 {  void Pmemory_plot(NODE arg,Obj *rp){plot_main(arg,1,PLOT,rp);}
         itvplot_main2(arg, rp);  
 }  
   
 void Pitvplot3(NODE arg, Obj *rp)  int plot_by_bigfloat;
 {  
         itvplot_main3(arg, rp);  
 }  
   
 void Pitvplot4(NODE arg, Obj *rp)  void plot_main(NODE arg,int is_memory,char *fn,Obj *rp){
 {    Q m2,p2,w300,s_id;
         itvplot_main4(arg, rp);    NODE defrange;
 }    LIST xrange,range[1],list,geom;
     VL vl,vl0;
     V v[1],av[1];
     int stream,ri,i,found_f;
     Obj func;
     P var;
     NODE n,n0;
     STRING fname,wname;
     Obj t;
     Q prec;
   
 // NORMAL type    STOQ(-2,m2);STOQ(2,p2);
 void itvplot_main1(NODE arg, Obj *rp)    MKNODE(n,p2,0);MKNODE(defrange,m2,n);
 {    func=0;vl=0;geom=0;wname=0;stream=-1;ri=0;
         Q m2,p2,w300,s_id;    v[0]=0;
         NODE defrange;    found_f = 0;
         LIST xrange,yrange,range[2],list,geom;    for(;arg;arg=NEXT(arg) ) {
         VL vl,vl0;      if(!BDY(arg) )
         V v[2],av[2];        if ( !found_f ) {
         int stream,ri,i,sign;          makevar("x",&var);
         P poly;          v[0] = VR(var);
         P var;          found_f = 1;
         NODE n,n0;        } else
         STRING fname,wname;          stream=0;
         Obj t;      else
       switch ( OID(BDY(arg)) ){
         STOQ(-2,m2); STOQ(2,p2);        case O_P: case O_R:
         MKNODE(n,p2,0); MKNODE(defrange,m2,n);          func = (Obj)BDY(arg);
         poly = 0; vl = 0; geom = 0; wname = 0; stream = -1; ri = 0;          get_vars_recursive(func,&vl);
         v[0] = v[1] = 0;          for(vl0=vl, i=0;vl0;vl0=NEXT(vl0) ){
         for ( ; arg; arg = NEXT(arg) )            if(vl0->v->attr==(pointer)V_IND ){
                 if ( !BDY(arg) ) stream = 0;              if(i >= 1 ) error("plot : function must be univariate");
                 else              else v[i++]=vl0->v;
                 switch ( OID(BDY(arg)) ) {            }
                 case O_P:          }
                         poly = (P)BDY(arg);          found_f = 1;
                         get_vars_recursive((Obj)poly,&vl);          break;
                         for ( vl0 = vl, i = 0; vl0; vl0 = NEXT(vl0) )        case O_LIST:
                                 if ( vl0->v->attr == (pointer)V_IND )          list=(LIST)BDY(arg);
                                         if ( i >= 2 ) error("itvplot : invalid argument");          if(OID(BDY(BDY(list)))==O_P ){
                                         else v[i++] = vl0->v;            if(ri > 0 ) error("plot : too many intervals");
                         break;            else range[ri++]=list;
                 case O_LIST:          } else geom=list;
                         list = (LIST)BDY(arg);          break;
                         if ( OID(BDY(BDY(list))) == O_P )        case O_N:
                                 if ( ri > 1 ) error("itvplot : invalid argument");          if ( !found_f ) {
                                 else range[ri++] = list;            func = (Obj)BDY(arg);
                         else geom = list;            makevar("x",&var);
                         break;            v[0] = VR(var);
                 case O_N:            found_f = 1;
                         stream = QTOS((Q)BDY(arg)); break;          } else
                 case O_STR:            stream=QTOS((Q)BDY(arg));
                         wname = (STRING)BDY(arg); break;          break;
                 default:        case O_STR:
                         error("itvplot : invalid argument"); break;          wname=(STRING)BDY(arg);break;
                 }        default:
         if ( !poly ) error("itvplot : invalid argument");          error("plot : invalid argument");break;
         switch ( ri ) {      }
         case 0:    }
                 if ( !v[1] ) error("itvplot : please specify all variables");    if(!found_f )
                 MKV(v[0],var); MKNODE(n,var,defrange); MKLIST(xrange,n);      error("plot : invalid argument");
                 MKV(v[1],var); MKNODE(n,var,defrange); MKLIST(yrange,n);    switch ( ri ){
                 break;      case 0:
         case 1:        MKV(v[0],var);MKNODE(n,var,defrange);MKLIST(xrange,n);
                 if ( !v[1] ) error("itvplot : please specify all variables");        break;
                 av[0] = VR((P)BDY(BDY(range[0])));      case 1:
                 if ( v[0] == av[0] ) {        av[0]=VR((P)BDY(BDY(range[0])));
                         xrange = range[0];        if(!func || NUM(func) || v[0]==av[0] )
                         MKV(v[1],var); MKNODE(n,var,defrange); MKLIST(yrange,n);          xrange=range[0];
                 } else if ( v[1] == av[0] ) {        else
                         MKV(v[0],var); MKNODE(n,var,defrange); MKLIST(xrange,n);          error("plot : invalid argument");
                         yrange = range[0];        break;
                 } else error("itvplot : invalid argument");      default:
                 break;        error("plot : cannot happen");break;
         case 2:    }
                 av[0] = VR((P)BDY(BDY(range[0])));    /* conplot in ox_plot requires
                 av[1] = VR((P)BDY(BDY(range[1])));       [s_id (Q),
                 if ( ((v[0] == av[0]) && (!v[1] || v[1] == av[1])) ||         formula (Obj),
                         ((v[0] == av[1]) && (!v[1] || v[1] == av[0])) ) {         xrange=[x,xmin,xmax] (LIST),
                         xrange = range[0]; yrange = range[1];         yrange=0,
                 } else error("itvplot : invalid argument");         zrange=0,
                 break;         geom=[xsize,ysize] (LIST),
         default:         wname=name (STRING)]
                 error("itvplot : cannot happen"); break;    */
         }    stream=validate_ox_plot_stream(stream);
         stream = validate_ox_plot_stream(stream);    STOQ(stream,s_id);
         STOQ(stream,s_id);    if(!geom ){
         if ( !geom ) {      STOQ(300,w300);
                 STOQ(300,w300);      MKNODE(n0,w300,0);MKNODE(n,w300,n0);MKLIST(geom,n);
                 MKNODE(n0,w300,0); MKNODE(n,w300,n0); MKLIST(geom,n);    }
         }    if(plot_by_bigfloat)
         MKSTR(fname,"itvplot1");      STOQ(plot_by_bigfloat,prec);
         arg = mknode(8,s_id,fname,poly,xrange,yrange,0,geom,wname);    else
         Pox_rpc(arg,&t);      prec = 0;
         *rp = (Obj)s_id;    if(is_memory ){
       MKSTR(fname,MEMORY_PLOT);
       arg=mknode(8,s_id,fname,func,xrange,NULLP,NULLP,geom,prec);
       Pox_rpc(arg,&t);
       arg=mknode(1,s_id);
       Pox_pop_cmo(arg,rp);
     } else {
       MKSTR(fname,fn);
       arg=mknode(9,s_id,fname,func,xrange,NULLP,NULLP,geom,wname,prec);
       Pox_rpc(arg,&t);
       *rp=(Obj)s_id;
     }
 }  }
   
 // TRANSFER TYPE  #define Pi 3.14159265358979323846264
 void itvplot_main2(NODE arg, Obj *rp)  
 {  
         Q m2,p2,w300,s_id;  
         NODE defrange;  
         LIST xrange,yrange,range[2],list,geom;  
         VL vl,vl0;  
         V v[2],av[2];  
         int stream,ri,i,sign;  
         P poly;  
         P var;  
         NODE n,n0;  
         STRING fname,wname;  
         Obj t;  
   
         STOQ(-2,m2); STOQ(2,p2);  void Ppolarplot(NODE arg,Obj *rp){
         MKNODE(n,p2,0); MKNODE(defrange,m2,n);    Q m2,p2,w300,s_id;
         poly = 0; vl = 0; geom = 0; wname = 0; stream = -1; ri = 0;    NODE defrange,n,n0;
         v[0] = v[1] = 0;    LIST zrange,range[1],geom,list;
         for ( ; arg; arg = NEXT(arg) )    VL vl,vl0;
                 if ( !BDY(arg) )    V v[1],av[1];
                         stream = 0;    int stream,ri,i;
                 else    P poly,var;
                 switch ( OID(BDY(arg)) ) {    STRING fname,wname;
                         case O_P:    Real pi2;
                                 poly = (P)BDY(arg);    Obj t;
                                 get_vars_recursive((Obj)poly,&vl);  
                                 for ( vl0 = vl, i = 0; vl0; vl0 = NEXT(vl0) )  
                                         if ( vl0->v->attr == (pointer)V_IND )  
                                                 if ( i >= 2 )  
                                                         error("itvplot : invalid argument");  
                                                 else  
                                                         v[i++] = vl0->v;  
                                 break;  
                         case O_LIST:  
                                 list = (LIST)BDY(arg);  
                                 if ( OID(BDY(BDY(list))) == O_P )  
                                         if ( ri > 1 )  
                                                 error("itvplot : invalid argument");  
                                         else  
                                                 range[ri++] = list;  
                                 else  
                                         geom = list;  
                                 break;  
                         case O_N:  
                                 stream = QTOS((Q)BDY(arg)); break;  
                         case O_STR:  
                                 wname = (STRING)BDY(arg); break;  
                         default:  
                                 error("itvplot : invalid argument"); break;  
                 }  
         if ( !poly )  
                 error("itvplot : invalid argument");  
         switch ( ri ) {  
                 case 0:  
                         if ( !v[1] )  
                                 error("itvplot : please specify all variables");  
                         MKV(v[0],var); MKNODE(n,var,defrange); MKLIST(xrange,n);  
                         MKV(v[1],var); MKNODE(n,var,defrange); MKLIST(yrange,n);  
                         break;  
                 case 1:  
                         if ( !v[1] )  
                                 error("itvplot : please specify all variables");  
                         av[0] = VR((P)BDY(BDY(range[0])));  
                         if ( v[0] == av[0] ) {  
                                 xrange = range[0];  
                                 MKV(v[1],var); MKNODE(n,var,defrange); MKLIST(yrange,n);  
                         } else if ( v[1] == av[0] ) {  
                                 MKV(v[0],var); MKNODE(n,var,defrange); MKLIST(xrange,n);  
                                 yrange = range[0];  
                         } else  
                                 error("itvplot : invalid argument");  
                         break;  
                 case 2:  
                         av[0] = VR((P)BDY(BDY(range[0])));  
                         av[1] = VR((P)BDY(BDY(range[1])));  
                         if ( ((v[0] == av[0]) && (!v[1] || v[1] == av[1])) ||  
                                  ((v[0] == av[1]) && (!v[1] || v[1] == av[0])) ) {  
                                         xrange = range[0]; yrange = range[1];  
                         } else  
                                         error("itvplot : invalid argument");  
                         break;  
                 default:  
                         error("itvplot : cannot happen"); break;  
         }  
         stream = validate_ox_plot_stream(stream);  
         STOQ(stream,s_id);  
         if ( !geom ) {  
                 STOQ(300,w300);  
                 MKNODE(n0,w300,0); MKNODE(n,w300,n0); MKLIST(geom,n);  
         }  
         MKSTR(fname,"itvplot2");  
         arg = mknode(8,s_id,fname,poly,xrange,yrange,0,geom,wname);  
         Pox_rpc(arg,&t);  
         *rp = (Obj)s_id;  
 }  
 // RECURSION TYPE  
 void itvplot_main3(NODE arg, Obj *rp)  
 {  
         Q m2,p2,w300,s_id, itvsize;  
         NODE defrange;  
         LIST xrange,yrange,range[2],list,geom;  
         VL vl,vl0;  
         V v[2],av[2];  
         int stream,ri,i,sign;  
         P poly;  
         P var;  
         NODE n,n0;  
         STRING fname,wname;  
         Obj t;  
   
         STOQ(-2,m2); STOQ(2,p2);    MKReal(2*Pi,pi2);MKNODE(n,pi2,0); MKNODE(defrange,0,n);
         MKNODE(n,p2,0); MKNODE(defrange,m2,n);    poly=0;vl=0;geom=0;wname=0;stream=-1;ri=0;v[0]=0;
         poly = 0; vl = 0; geom = 0; wname = 0; stream = -1; ri = 0;    for(;arg;arg=NEXT(arg)){
         v[0] = v[1] = 0;      if(!BDY(arg)) stream=0;
         for ( ; arg; arg = NEXT(arg) )      else switch(OID(BDY(arg))){
                 if ( !BDY(arg) )      case O_P: case O_R://formula
                         stream = 0;        poly=(P)BDY(arg);
                 else        get_vars_recursive((Obj)poly,&vl);
                 switch ( OID(BDY(arg)) ) {        for(vl0=vl,i=0;vl0;vl0=NEXT(vl0))
                         case O_P:          if(vl0->v->attr==(pointer)V_IND)
                                 poly = (P)BDY(arg);            if(i>=1)error("polarplot : invalid argument");
                                 get_vars_recursive((Obj)poly,&vl);          else v[i++]=vl0->v;
                                 for ( vl0 = vl, i = 0; vl0; vl0 = NEXT(vl0) )        if(i!=1)error("polarplot : invalid argument");
                                         if ( vl0->v->attr == (pointer)V_IND )        break;
                                                 if ( i >= 2 )      case O_LIST://range,geomerty
                                                         error("itvplot : invalid argument");        list=(LIST)BDY(arg);
                                                 else        if(OID(BDY(BDY(list)))==O_P)
                                                         v[i++] = vl0->v;          if(ri>0)error("polarplot : invalid argument");
                                 break;          else range[ri++]=list;
                         case O_LIST:        else geom=list;
                                 list = (LIST)BDY(arg);        break;
                                 if ( OID(BDY(BDY(list))) == O_P )      case O_N:
                                         if ( ri > 1 )        stream=QTOS((Q)BDY(arg));
                                                 error("itvplot : invalid argument");        break;
                                         else      case O_STR://wname
                                                 range[ri++] = list;        wname=(STRING)BDY(arg);
                                 else        break;
                                         geom = list;      default:
                                 break;        error("polarplot : invalid argument");
                         case O_N:        break;
                                 stream = QTOS((Q)BDY(arg)); break;      }
                         case O_STR:    }
                                 wname = (STRING)BDY(arg); break;    //formular check
                         default:    if(!poly)error("polarplot : invalid argument");
                                 error("itvplot : invalid argument"); break;    switch (ri){
                 }    case 0:
         if ( !poly )      MKV(v[0],var); MKNODE(n,var,defrange); MKLIST(zrange,n);
                 error("itvplot : invalid argument");      break;
         switch ( ri ) {    case 1:
                 case 0:      av[0]=VR((P)BDY(BDY(range[0])));
                         if ( !v[1] )      if(v[0]==av[0]) zrange = range[0];
                                 error("itvplot : please specify all variables");      else error("polarplot : invalid argument");
                         MKV(v[0],var); MKNODE(n,var,defrange); MKLIST(xrange,n);      break;
                         MKV(v[1],var); MKNODE(n,var,defrange); MKLIST(yrange,n);    default:
                         break;      error("polarplot : cannot happen");
                 case 1:      break;
                         if ( !v[1] )    }
                                 error("itvplot : please specify all variables");    stream=validate_ox_plot_stream(stream);
                         av[0] = VR((P)BDY(BDY(range[0])));    STOQ(stream,s_id);
                         if ( v[0] == av[0] ) {    if(!geom){
                                 xrange = range[0];      STOQ(300,w300);
                                 MKV(v[1],var); MKNODE(n,var,defrange); MKLIST(yrange,n);      MKNODE(n0,w300,0); MKNODE(n,w300,n0); MKLIST(geom,n);
                         } else if ( v[1] == av[0] ) {    }
                                 MKV(v[0],var); MKNODE(n,var,defrange); MKLIST(xrange,n);    MKSTR(fname,POLARPLOT);
                                 yrange = range[0];    arg=mknode(8,s_id,fname,poly,NULLP,NULLP,zrange,geom,wname);
                         } else    Pox_rpc(arg,&t);
                                 error("itvplot : invalid argument");    *rp=s_id;
                         break;  
                 case 2:  
                         av[0] = VR((P)BDY(BDY(range[0])));  
                         av[1] = VR((P)BDY(BDY(range[1])));  
                         if ( ((v[0] == av[0]) && (!v[1] || v[1] == av[1])) ||  
                                  ((v[0] == av[1]) && (!v[1] || v[1] == av[0])) ) {  
                                         xrange = range[0]; yrange = range[1];  
                         } else  
                                         error("itvplot : invalid argument");  
                         break;  
                 default:  
                         error("itvplot : cannot happen"); break;  
         }  
         stream = validate_ox_plot_stream(stream);  
         STOQ(stream,s_id);  
         if ( !geom ) {  
                 STOQ(300,w300);  
                 MKNODE(n0,w300,0); MKNODE(n,w300,n0); MKLIST(geom,n);  
         }  
         MKSTR(fname,"itvplot3");  
         STOQ(Itvplot, itvsize);  
         arg = mknode(9,s_id,fname,poly,xrange,yrange,0,geom,wname,itvsize);  
         Pox_rpc(arg,&t);  
         *rp = (Obj)s_id;  
 }  }
 // RECURSION and TRANSFER TYPE  
 void itvplot_main4(NODE arg, Obj *rp)  
 {  
         Q m2,p2,w300,s_id,itvsize;  
         NODE defrange;  
         LIST xrange,yrange,range[2],list,geom;  
         VL vl,vl0;  
         V v[2],av[2];  
         int stream,ri,i,sign;  
         P poly;  
         P var;  
         NODE n,n0;  
         STRING fname,wname;  
         Obj t;  
   
         STOQ(-2,m2); STOQ(2,p2);  void Pplotover(NODE arg,Obj *rp){
         MKNODE(n,p2,0); MKNODE(defrange,m2,n);    Q s_id,w_id,color;
         poly = 0; vl = 0; geom = 0; wname = 0; stream = -1; ri = 0;    P poly;
         v[0] = v[1] = 0;    STRING fname;
         for ( ; arg; arg = NEXT(arg) )    Obj t;
                 if ( !BDY(arg) )    poly=(P)ARG0(arg);
                         stream = 0;    s_id=(Q)ARG1(arg);
                 else    w_id=(Q)ARG2(arg);
                 switch ( OID(BDY(arg)) ) {    if(argc(arg)==4)color=(Q)ARG3(arg);
                         case O_P:    else color=0;
                                 poly = (P)BDY(arg);    MKSTR(fname,PLOTOVER);
                                 get_vars_recursive((Obj)poly,&vl);    arg=mknode(5,s_id,fname,w_id,poly,color);
                                 for ( vl0 = vl, i = 0; vl0; vl0 = NEXT(vl0) )    Pox_rpc(arg,&t);
                                         if ( vl0->v->attr == (pointer)V_IND )    *rp=(Obj)s_id;
                                                 if ( i >= 2 )  
                                                         error("itvplot : invalid argument");  
                                                 else  
                                                         v[i++] = vl0->v;  
                                 break;  
                         case O_LIST:  
                                 list = (LIST)BDY(arg);  
                                 if ( OID(BDY(BDY(list))) == O_P )  
                                         if ( ri > 1 )  
                                                 error("itvplot : invalid argument");  
                                         else  
                                                 range[ri++] = list;  
                                 else  
                                         geom = list;  
                                 break;  
                         case O_N:  
                                 stream = QTOS((Q)BDY(arg)); break;  
                         case O_STR:  
                                 wname = (STRING)BDY(arg); break;  
                         default:  
                                 error("itvplot : invalid argument"); break;  
                 }  
         if ( !poly )  
                 error("itvplot : invalid argument");  
         switch ( ri ) {  
                 case 0:  
                         if ( !v[1] )  
                                 error("itvplot : please specify all variables");  
                         MKV(v[0],var); MKNODE(n,var,defrange); MKLIST(xrange,n);  
                         MKV(v[1],var); MKNODE(n,var,defrange); MKLIST(yrange,n);  
                         break;  
                 case 1:  
                         if ( !v[1] )  
                                 error("itvplot : please specify all variables");  
                         av[0] = VR((P)BDY(BDY(range[0])));  
                         if ( v[0] == av[0] ) {  
                                 xrange = range[0];  
                                 MKV(v[1],var); MKNODE(n,var,defrange); MKLIST(yrange,n);  
                         } else if ( v[1] == av[0] ) {  
                                 MKV(v[0],var); MKNODE(n,var,defrange); MKLIST(xrange,n);  
                                 yrange = range[0];  
                         } else  
                                 error("itvplot : invalid argument");  
                         break;  
                 case 2:  
                         av[0] = VR((P)BDY(BDY(range[0])));  
                         av[1] = VR((P)BDY(BDY(range[1])));  
                         if ( ((v[0] == av[0]) && (!v[1] || v[1] == av[1])) ||  
                                  ((v[0] == av[1]) && (!v[1] || v[1] == av[0])) ) {  
                                         xrange = range[0]; yrange = range[1];  
                         } else  
                                         error("itvplot : invalid argument");  
                         break;  
                 default:  
                         error("itvplot : cannot happen"); break;  
         }  
         /* itvplot in ox_plot requires  
            [s_id (Q),  
                 formula (Obj),  
                 xrange=[x,xmin,xmax] (LIST),  
                 yrange=[y,ymin,ymax] (LIST),  
                 zrange=0,  
                 geom=[xsize,ysize] (LIST),  
                 wname=name (STRING)]  
         */  
   
         stream = validate_ox_plot_stream(stream);  
         STOQ(stream,s_id);  
         if ( !geom ) {  
                 STOQ(300,w300);  
                 MKNODE(n0,w300,0); MKNODE(n,w300,n0); MKLIST(geom,n);  
         }  
         MKSTR(fname,"itvplot4");  
         STOQ(Itvplot, itvsize);  
         arg = mknode(9,s_id,fname,poly,xrange,yrange,0,geom,wname,itvsize);  
         Pox_rpc(arg,&t);  
         *rp = (Obj)s_id;  
 }  }
   
 void Pineqn(NODE arg, Obj *rp)  void Pdrawcircle(NODE arg,Obj *rp){
 {    Q s_id,index;
         ineqn_main(arg, 1, rp);    Obj x,y,r,c,t;
 }    STRING fname;
     NODE n;
     LIST pos;
   
 void ineqn_main(NODE arg,int is_memory, Obj *rp)    x=(Obj)ARG0(arg);
 {    y=(Obj)ARG1(arg);
         Q s_id, m2, p2, w300, color;    r=(Obj)ARG2(arg);
         NODE defrange, n, n0;    c=(Obj)ARG3(arg);
         P poly, var;    s_id=(Q)ARG4(arg);
         VL vl, vl0;    index=(Q)ARG5(arg);
         V v[2], av[2];    MKSTR(fname,DRAWCIRCLE);
         LIST xrange, yrange, range[2], list, geom;    n=mknode(3,x,y,r,c);
         int stream, ri, i,sign;    MKLIST(pos,n);
         STRING fname,wname;    arg=mknode(5,s_id,fname,index,pos,c);
     Pox_rpc(arg,&t);
         STOQ(-2,m2); STOQ(2,p2);    *rp=(Obj)s_id;
         MKNODE(n,p2,0); MKNODE(defrange,m2,n);  
         poly = 0; vl = 0; geom = 0; wname = 0; stream = -1; ri = 0;  
         v[0] = v[1] = 0;  
         /* get polynomial */  
         if ( !(OID(BDY(arg)) == O_P || (OID(BDY(arg)) ==O_R)) )  
                 error("ineqn : first argument must be a polynormial");  
         else {  
                 poly = (P)BDY(arg);  
                 /* get vars */  
                 get_vars_recursive((Obj)poly,&vl);  
                 for ( vl0 = vl, i = 0; vl0; vl0 = NEXT(vl0) )  
                 if ( vl0->v->attr == (pointer)V_IND )  
                 if ( i >= 2 )  
                         error(  
                                 "ineqn : first argument must be a univariate or bivariate polynormial");  
                 else  
                         v[i++] = vl0->v;  
         }  
         /* get color */  
         arg = NEXT(arg);  
         if ( OID(BDY(arg)) != O_N )  
                 error("ineqn : second argument must be color code");  
         else  
                 color = (Q)BDY(arg);  
         /* other argument is optional */  
         arg = NEXT(arg);  
         for ( ; arg; arg = NEXT(arg) )  
                 if ( !BDY(arg) )  
                         stream = 0;  
                 else  
                 switch ( OID(BDY(arg)) ) {  
                 case O_LIST:  
                         list = (LIST)BDY(arg);  
                         if ( OID(BDY(BDY(list))) == O_P )  
                                 if ( ri > 1 )  
                                         error("ineqn : invalid list argument");  
                                 else  
                                         range[ri++] = list;  
                         else  
                         geom = list;  
                         break;  
                 case O_N:  
                         stream = QTOS((Q)BDY(arg)); break;  
                 case O_STR:  
                         wname = (STRING)BDY(arg); break;  
                 default:  
                         error("ineqn : invalid argument"); break;  
         }  
         switch ( ri ) {  
         case 0:  
                 if ( !v[1] ) error("ineqn : please specify all variables");  
                 MKV(v[0],var); MKNODE(n,var,defrange); MKLIST(xrange,n);  
                 MKV(v[1],var); MKNODE(n,var,defrange); MKLIST(yrange,n);  
                 break;  
         case 1:  
                 if ( !v[1] ) error("ineqn : please specify all variables");  
                 av[0] = VR((P)BDY(BDY(range[0])));  
                 if ( v[0] == av[0] ) {  
                         xrange = range[0];  
                         MKV(v[1],var); MKNODE(n,var,defrange); MKLIST(yrange,n);  
                 } else if ( v[1] == av[0] ) {  
                         MKV(v[0],var); MKNODE(n,var,defrange); MKLIST(xrange,n);  
                         yrange = range[0];  
                 } else error("ineqn : invalid argument");  
                 break;  
         case 2:  
                 av[0] = VR((P)BDY(BDY(range[0])));  
                 av[1] = VR((P)BDY(BDY(range[1])));  
                 if ( ((v[0] == av[0]) && (!v[1] || v[1] == av[1])) ||  
                                 ((v[0] == av[1]) && (!v[1] || v[1] == av[0])) ) {  
                         xrange = range[0]; yrange = range[1];  
                 } else error("ineqn : invalid argument");  
                 break;  
         default:  
                 error("ineqn : cannot happen"); break;  
         }  
   
         stream = validate_ox_plot_stream(stream);  
         STOQ(stream,s_id);  
         if ( !geom ) {  
                 STOQ(300,w300);  
                 MKNODE(n0,w300,0); MKNODE(n,w300,n0); MKLIST(geom,n);  
         }  
         MKSTR(fname, "ineqn");  
         arg = mknode(8, s_id, fname, poly, color, xrange, yrange, geom, wname);  
         Pox_cmo_rpc(arg,rp);  
         *rp = (Obj)s_id;  
 }  }
   
 void Pineqnor(NODE arg, Obj *rp)  void Pdraw_obj(NODE arg,Obj *rp){
 {    static STRING fname;
         ineqn_main_op(arg, 7, 0, rp);    Q s_id,index;
 }    LIST obj;
     Obj t;
   
 void Pineqnand(NODE arg, Obj *rp)    if(!fname)MKSTR(fname,DRAW_OBJ);
 {    s_id=(Q)ARG0(arg);
         ineqn_main_op(arg, 1, 0, rp);    index=(Q)ARG1(arg);
     obj=(LIST)ARG2(arg);
     // ARG3(arg)=color
     if(argc(arg)==4) arg=mknode(5,s_id,fname,index,obj,ARG3(arg));
     else arg=mknode(4,s_id,fname,index,obj);
     Pox_cmo_rpc(arg,&t);
     *rp=(Obj)s_id;
 }  }
   
 void Pineqnxor(NODE arg, Obj *rp)  void Pdraw_string(NODE arg,Obj *rp){
 {    static STRING fname;
         ineqn_main_op(arg, 6, 0, rp);    STRING str;
 }    Q s_id,index;
     LIST pos;
     Obj t;
   
 void Pmemory_ineqn(NODE arg, Obj *rp)    if(!fname)MKSTR(fname,DRAW_STRING);
 {    s_id=(Q)ARG0(arg);
         ineqn_main(arg, 1, rp);    index=(Q)ARG1(arg);
     pos=(LIST)ARG2(arg);
     str=(STRING)ARG3(arg);
     // ARG4(arg)=color
     if(argc(arg)==5) arg=mknode(6,s_id,fname,index,pos,str,ARG4(arg));
     else arg=mknode(5,s_id,fname,index,pos,str);
     Pox_cmo_rpc(arg,&t);
     *rp=(Obj)s_id;
 }  }
   
 void ineqn_main_op(NODE arg, int op, int is_memory, Obj *rp)  void Pclear_canvas(NODE arg,Obj *rp){
 {    static STRING fname;
         Q s_id, index, color, op_code;    Q s_id,index;
         P poly;    Obj t;
         STRING fname;  
         Obj t;  
   
         poly  = (P)ARG0(arg);    if(!fname) MKSTR(fname,CLEAR_CANVAS);
         color = (Q)ARG1(arg);    s_id=(Q)ARG0(arg);
         s_id  = (Q)ARG2(arg);    index=(Q)ARG1(arg);
         index = (Q)ARG3(arg);    arg=mknode(3,s_id,fname,index);
         STOQ( op, op_code);    Pox_cmo_rpc(arg,&t);
         MKSTR(fname, "ineqnover");    *rp=(Obj)s_id;
         arg = mknode(6, s_id, fname, index, poly, color, op_code);  
         Pox_rpc(arg, &t);  
         *rp = (Obj)s_id;  
 }  }
   //****************************ifplotNG
 void Pobj_cp(NODE arg, Obj *rp)  /*
 {   * name ifplot,ineqn,ineqnor,ineqnand,ineqnxor,conplot
         Q sysid, index_A, index_B, op_code;   * type
         STRING fname;   *  D:sign character using double
         Obj t;   *  Q:sign character use rational
    *  B:Boundary character use sturm theorem
         sysid = (Q)ARG0(arg);   */
         index_A = (Q)ARG1(arg);  void ListCheck(char * head,LIST list){
         index_B = (Q)ARG2(arg);    int i;
         op_code = (Q)ARG3(arg);    NODE n;
         MKSTR(fname, "objcp");    if(!list){
         arg = mknode(5, sysid, fname, index_A, index_B, op_code);      printf("%s zero \n",head);
         Pox_rpc(arg, &t);      return;
         *rp = (Obj)sysid;    }
     for(i=0,n=(NODE)BDY(list);n;i++,n=NEXT(n));
     printf("%s length %d\n",head,i);
     for(i=0,n=(NODE)BDY(list);n;i++,n=NEXT(n)){
       if(!BDY(n))printf("%d 0\n",i);
       else if(OID(BDY(n))==O_P) printf("%d poly\n",i);
       else if(OID(BDY(n))==O_R) printf("%d real\n",i);
       else if(OID(BDY(n))==O_N) printf("%d %d\n",i,QTOS((Q)BDY(n)));
     }
 }  }
 #endif  
   
 void Pconplot(NODE arg,Obj *rp)  void PifplotD(NODE arg,Obj *rp){ifplot_mainNG(arg,IFPLOTD,rp);}
 {  void PifplotQ(NODE arg,Obj *rp){ifplot_mainNG(arg,IFPLOTQ,rp);}
         conplot_main(arg, 0, rp);  void PifplotB(NODE arg,Obj *rp){ifplot_mainNG(arg,IFPLOTB,rp);}
 }  
   
 void Pmemory_conplot(NODE arg,Obj *rp)  void PconplotD(NODE arg,Obj *rp){ifplot_mainNG(arg,CONPLOTD,rp);}
 {  void PconplotQ(NODE arg,Obj *rp){ifplot_mainNG(arg,CONPLOTQ,rp);}
         conplot_main(arg,1,rp);  void PconplotB(NODE arg,Obj *rp){ifplot_mainNG(arg,CONPLOTB,rp);}
 }  
   
 void conplot_main(NODE arg,int is_memory,Obj *rp)  void PineqnD(NODE arg,Obj *rp){ifplot_mainNG(arg,INEQND,rp);}
 {  void PineqnQ(NODE arg,Obj *rp){ifplot_mainNG(arg,INEQNQ,rp);}
         Q m2,p2,w300,s_id;  void PineqnB(NODE arg,Obj *rp){ifplot_mainNG(arg,INEQNB,rp);}
         NODE defrange;  
         LIST xrange,yrange,zrange,range[3],list,geom;  
         VL vl,vl0;  
         V v[2],av[2];  
         int stream,ri,i;  
         P poly;  
         P var;  
         NODE n,n0;  
         STRING fname,wname;  
         Obj t;  
   
         STOQ(-2,m2); STOQ(2,p2);  #if defined(INTERVAL)
         MKNODE(n,p2,0); MKNODE(defrange,m2,n);  void Pitvifplot(NODE arg,Obj *rp){ifplot_mainNG(arg,ITVIFPLOT,rp);}
         poly = 0; vl = 0; geom = 0; wname = 0; stream = -1; ri = 0;  #endif
         v[0] = v[1] = 0;  
         for ( ; arg; arg = NEXT(arg) )  
                 if ( !BDY(arg) )  
                         stream = 0;  
                 else  
                 switch ( OID(BDY(arg)) ) {  
                         case O_P:  
                                 poly = (P)BDY(arg);  
                                 get_vars_recursive((Obj)poly,&vl);  
                                 for ( vl0 = vl, i = 0; vl0; vl0 = NEXT(vl0) )  
                                         if ( vl0->v->attr == (pointer)V_IND )  
                                                 if ( i >= 2 )  
                                                         error("ifplot : invalid argument");  
                                                 else  
                                                         v[i++] = vl0->v;  
                                 break;  
                         case O_LIST:  
                                 list = (LIST)BDY(arg);  
                                 if ( OID(BDY(BDY(list))) == O_P )  
                                         if ( ri > 2 )  
                                                 error("ifplot : invalid argument");  
                                         else  
                                                 range[ri++] = list;  
                                 else  
                                         geom = list;  
                                 break;  
                         case O_N:  
                                 stream = QTOS((Q)BDY(arg)); break;  
                         case O_STR:  
                                 wname = (STRING)BDY(arg); break;  
                         default:  
                                 error("ifplot : invalid argument"); break;  
                 }  
         if ( !poly )  
                 error("ifplot : invalid argument");  
         switch ( ri ) {  
                 case 0:  
                         if ( !v[1] )  
                                 error("ifplot : please specify all variables");  
                         MKV(v[0],var); MKNODE(n,var,defrange); MKLIST(xrange,n);  
                         MKV(v[1],var); MKNODE(n,var,defrange); MKLIST(yrange,n);  
                         MKNODE(n,0,defrange); MKLIST(zrange,n);  
                         break;  
                 case 1:  
                         if ( !v[1] )  
                                 error("ifplot : please specify all variables");  
                         av[0] = VR((P)BDY(BDY(range[0])));  
                         if ( v[0] == av[0] ) {  
                                 xrange = range[0];  
                                 MKV(v[1],var); MKNODE(n,var,defrange); MKLIST(yrange,n);  
                                 MKNODE(n,0,defrange); MKLIST(zrange,n);  
                         } else if ( v[1] == av[0] ) {  
                                 MKV(v[0],var); MKNODE(n,var,defrange); MKLIST(xrange,n);  
                                 yrange = range[0];  
                                 MKNODE(n,0,defrange); MKLIST(zrange,n);  
                         } else {  
                                 MKV(v[0],var); MKNODE(n,var,defrange); MKLIST(xrange,n);  
                                 MKV(v[1],var); MKNODE(n,var,defrange); MKLIST(yrange,n);  
                                 zrange = range[0];  
                         }  
                         break;  
                 case 2: case 3:  
                         av[0] = VR((P)BDY(BDY(range[0])));  
                         av[1] = VR((P)BDY(BDY(range[1])));  
                         if ( ((v[0] == av[0]) && (!v[1] || v[1] == av[1])) ||  
                                  ((v[0] == av[1]) && (!v[1] || v[1] == av[0])) ) {  
                                 xrange = range[0]; yrange = range[1];  
                                 if ( ri == 3 )  
                                         zrange = range[2];  
                                 else {  
                                         MKNODE(n,0,defrange); MKLIST(zrange,n);  
                                 }  
                         } else  
                                 error("ifplot : invalid argument");  
                         break;  
                 default:  
                         error("ifplot : cannot happen"); break;  
         }  
         /* conplot in ox_plot requires  
            [s_id (Q),  
                 formula (Obj),  
                 xrange=[x,xmin,xmax] (LIST),  
                 yrange=[y,ymin,ymax] (LIST),  
                 zrange=[z,zmin,zmax] (LIST),  
                 geom=[xsize,ysize] (LIST),  
                 wname=name (STRING)]  
         */  
   
         stream = validate_ox_plot_stream(stream);  void PineqnorD(NODE arg,Obj *rp){plotover_mainNG(arg,INEQNDOR,rp);}
         STOQ(stream,s_id);  void PineqnorQ(NODE arg,Obj *rp){plotover_mainNG(arg,INEQNQOR,rp);}
         if ( !geom ) {  void PineqnorB(NODE arg,Obj *rp){plotover_mainNG(arg,INEQNBOR,rp);}
                 STOQ(300,w300);  
                 MKNODE(n0,w300,0); MKNODE(n,w300,n0); MKLIST(geom,n);  
         }  
         if ( is_memory ) {  
                 MKSTR(fname,"memory_plot");  
                 arg = mknode(7,s_id,fname,poly,xrange,yrange,zrange,geom);  
                 Pox_rpc(arg,&t);  
                 arg = mknode(1,s_id);  
                 Pox_pop_cmo(arg,rp);  
         } else {  
                 MKSTR(fname,"plot");  
                 arg = mknode(8,s_id,fname,poly,xrange,yrange,zrange,geom,wname);  
                 Pox_rpc(arg,&t);  
                 *rp = (Obj)s_id;  
         }  
 }  
   
 void Pplot(NODE arg,Obj *rp)  void PineqnandD(NODE arg,Obj *rp){plotover_mainNG(arg,INEQNDAND,rp);}
 {  void PineqnandQ(NODE arg,Obj *rp){plotover_mainNG(arg,INEQNQAND,rp);}
         plot_main(arg,0,rp);  void PineqnandB(NODE arg,Obj *rp){plotover_mainNG(arg,INEQNBAND,rp);}
 }  
   
 void Pmemory_plot(NODE arg,Obj *rp)  void PineqnxorD(NODE arg,Obj *rp){plotover_mainNG(arg,INEQNDXOR,rp);}
 {  void PineqnxorQ(NODE arg,Obj *rp){plotover_mainNG(arg,INEQNQXOR,rp);}
         plot_main(arg,1,rp);  void PineqnxorB(NODE arg,Obj *rp){plotover_mainNG(arg,INEQNBXOR,rp);}
 }  
   
 void plot_main(NODE arg,int is_memory,Obj *rp)  void PplotoverD(NODE arg,Obj *rp){plotover_mainNG(arg,PLOTOVERD,rp);}
 {  void PplotoverQ(NODE arg,Obj *rp){plotover_mainNG(arg,PLOTOVERQ,rp);}
         Q m2,p2,w300,s_id;  void PplotoverB(NODE arg,Obj *rp){plotover_mainNG(arg,PLOTOVERB,rp);}
         NODE defrange;  
         LIST xrange,range[1],list,geom;  
         VL vl,vl0;  
         V v[1],av[1];  
         int stream,ri,i;  
         P poly;  
         P var;  
         NODE n,n0;  
         STRING fname,wname;  
         Obj t;  
   
         STOQ(-2,m2); STOQ(2,p2);  void Pobj_cp(NODE arg,Obj *rp){
         MKNODE(n,p2,0); MKNODE(defrange,m2,n);    //copy canvas
         poly = 0; vl = 0; geom = 0; wname = 0; stream = -1; ri = 0;    //1:and,3:copy,6:xor,7:or
         v[0] = 0;    Q sysid,index_A,index_B,op_code;
         for ( ; arg; arg = NEXT(arg) )    STRING fname;
                 if ( !BDY(arg) )    Obj t;
                         stream = 0;    sysid=(Q)ARG0(arg);
                 else    index_A=(Q)ARG1(arg);
                 switch ( OID(BDY(arg)) ) {    index_B=(Q)ARG2(arg);
                         case O_P: case O_R:    op_code=(Q)ARG3(arg);
                                 poly = (P)BDY(arg);    MKSTR(fname,OBJ_CP);
                                 get_vars_recursive((Obj)poly,&vl);    arg=mknode(5,sysid,fname,index_A,index_B,op_code);
                                 for ( vl0 = vl, i = 0; vl0; vl0 = NEXT(vl0) )    Pox_rpc(arg,&t);
                                         if ( vl0->v->attr == (pointer)V_IND )    *rp=(Obj)sysid;
                                                 if ( i >= 1 )  
                                                         error("ifplot : invalid argument");  
                                                 else  
                                                         v[i++] = vl0->v;  
                                 if ( i != 1 )  
                                         error("ifplot : invalid argument");  
                                 break;  
                         case O_LIST:  
                                 list = (LIST)BDY(arg);  
                                 if ( OID(BDY(BDY(list))) == O_P )  
                                         if ( ri > 0 )  
                                                 error("plot : invalid argument");  
                                         else  
                                                 range[ri++] = list;  
                                 else  
                                         geom = list;  
                                 break;  
                         case O_N:  
                                 stream = QTOS((Q)BDY(arg)); break;  
                         case O_STR:  
                                 wname = (STRING)BDY(arg); break;  
                         default:  
                                 error("plot : invalid argument"); break;  
                 }  
         if ( !poly )  
                 error("plot : invalid argument");  
         switch ( ri ) {  
                 case 0:  
                         MKV(v[0],var); MKNODE(n,var,defrange); MKLIST(xrange,n);  
                         break;  
                 case 1:  
                         av[0] = VR((P)BDY(BDY(range[0])));  
                         if ( v[0] == av[0] )  
                                 xrange = range[0];  
                         else  
                                 error("plot : invalid argument");  
                         break;  
                 default:  
                         error("plot : cannot happen"); break;  
         }  
         /* conplot in ox_plot requires  
            [s_id (Q),  
                 formula (Obj),  
                 xrange=[x,xmin,xmax] (LIST),  
                 yrange=0,  
                 zrange=0,  
                 geom=[xsize,ysize] (LIST),  
                 wname=name (STRING)]  
         */  
         stream = validate_ox_plot_stream(stream);  
         STOQ(stream,s_id);  
         if ( !geom ) {  
                 STOQ(300,w300);  
                 MKNODE(n0,w300,0); MKNODE(n,w300,n0); MKLIST(geom,n);  
         }  
         if ( is_memory ) {  
                 MKSTR(fname,"memory_plot");  
                 arg = mknode(7,s_id,fname,poly,xrange,NULLP,NULLP,geom);  
                 Pox_rpc(arg,&t);  
                 arg = mknode(1,s_id);  
                 Pox_pop_cmo(arg,rp);  
         } else {  
                 MKSTR(fname,"plot");  
                 arg = mknode(8,s_id,fname,poly,xrange,NULLP,NULLP,geom,wname);  
                 Pox_rpc(arg,&t);  
                 *rp = (Obj)s_id;  
         }  
 }  }
   
 #define Pi 3.14159265358979323846264  void PpolarplotD(NODE arg,Obj *rp){
     Q m2,p2,w300,defstep,s_id,color;
     NODE defrange,n,n0,n1,n2;
     LIST range,geom,list[2];
     VL vl,vl0;
     V v[1],av;
     int stream,ri,i,len,iNo,lNo,vNo,sNo,pfine,findG;
     P poly,var;
     STRING fname,wname;
     Real pi2;
     Obj t,frst,sec,thr;
     char ebuf[BUFSIZ];
   
 void Ppolarplot(NODE arg,Q *rp)    iNo=lNo=sNo=findG=0;pfine=TRUE;
 {    poly=0;vl=0;geom=0;wname=0;color=0;stream=-1;ri=0;v[0]=0;
         Q m2,p2,w300,s_id;    for(;arg;arg=NEXT(arg)){
         NODE defrange;      if(!BDY(arg)) iNo++;
         LIST zrange,range[1],list,geom;      else switch(OID(BDY(arg))){
         VL vl,vl0;      case O_P: case O_R://formular
         V v[1],av[1];        poly=(P)BDY(arg);
         int stream,ri,i;        get_vars_recursive((Obj)poly,&vl);
         P poly;        for(vl0=vl,vNo=0;vl0;vl0=NEXT(vl0)){
         P var;          if(vl0->v->attr==(pointer)V_IND){
         NODE n,n0;            if(vNo>=1){
         STRING fname,wname;              sprintf(ebuf,"%s : invalaid argument",POLARPLOT);
         Real pi2;              error(ebuf);
         Obj t;            } else v[vNo++]=vl0->v;
           }
         MKReal(2*Pi,pi2);        }
         MKNODE(n,pi2,0); MKNODE(defrange,0,n);        if(vNo!=1){
         poly = 0; vl = 0; geom = 0; wname = 0; stream = -1; ri = 0;          sprintf(ebuf,"%s : only uni-variate formular",POLARPLOT);
         v[0] = 0;          error(ebuf);
         for ( ; arg; arg = NEXT(arg) )        }
                 if ( !BDY(arg) )        break;
                         stream = 0;      case O_N://color,id,idx,division
                 else        switch (iNo){
                 switch ( OID(BDY(arg)) ) {        case 0://color arg
                         case O_P: case O_R:          color=(Q)BDY(arg);
                                 poly = (P)BDY(arg);          iNo++;
                                 get_vars_recursive((Obj)poly,&vl);          break;
                                 for ( vl0 = vl, i = 0; vl0; vl0 = NEXT(vl0) )        case 1://stream arg
                                         if ( vl0->v->attr == (pointer)V_IND )          stream=QTOS((Q)BDY(arg));
                                                 if ( i >= 1 )          iNo++;
                                                         error("polarplot : invalid argument");          break;
                                                 else        default://error
                                                         v[i++] = vl0->v;          sprintf(ebuf,"%s : invalid number arguments",POLARPLOT);
                                 if ( i != 1 )          error(ebuf);
                                         error("polarplot : invalid argument");          break;
                                 break;        }
                         case O_LIST:        break;
                                 list = (LIST)BDY(arg);      case O_LIST://range,geomerty
                                 if ( OID(BDY(BDY(list))) == O_P )        if(lNo<2)list[lNo++]=(LIST)BDY(arg);
                                         if ( ri > 0 )        else {
                                                 error("polarplot : invalid argument");          sprintf(ebuf,"%s : invalid list argument",POLARPLOT);
                                         else          error(ebuf);
                                                 range[ri++] = list;        }
                                 else        break;
                                         geom = list;      case O_STR://wname
                                 break;        wname=(STRING)BDY(arg);
                         case O_N:        sNo++;
                                 stream = QTOS((Q)BDY(arg)); break;        break;
                         case O_STR:      default:
                                 wname = (STRING)BDY(arg); break;        break;
                         default:      }
                                 error("polarplot : invalid argument"); break;    }
                 }    //formular check
         if ( !poly )    if(!poly){
                 error("polarplot : invalid argument");      sprintf(ebuf,"%s : invalid plot argument",POLARPLOT);
         switch ( ri ) {      error(ebuf);
                 case 0:    }
                         MKV(v[0],var); MKNODE(n,var,defrange); MKLIST(zrange,n);    //vars check
                         break;    get_vars_recursive((Obj)poly,&vl);
                 case 1:    for(vl0=vl,vNo=0;vl0;vNo++,vl0=NEXT(vl0)){
                         av[0] = VR((P)BDY(BDY(range[0])));      if(vl0->v->attr==(pointer)V_IND){
                         if ( v[0] == av[0] )        if(vNo>=2){
                                 zrange = range[0];          sprintf(ebuf,"%s : invalid plot argument",POLARPLOT);
                         else          error(ebuf);
                                 error("polarplot : invalid argument");        } else v[vNo]=vl0->v;
                         break;      }
                 default:    }
                         error("polarplot : cannot happen"); break;    //list check
         }    for(i=0;i<lNo;i++){
         stream = validate_ox_plot_stream(stream);      if(OID(BDY(BDY(list[i])))!=O_P){
         STOQ(stream,s_id);        // list first value is number (geometry)
         if ( !geom ) {        for(len=0,n=(NODE)BDY(list[i]);n;len++,n=NEXT(n)){
                 STOQ(300,w300);          if(len==0) frst=BDY(n);
                 MKNODE(n0,w300,0); MKNODE(n,w300,n0); MKLIST(geom,n);          else if(len==1) sec=BDY(n);
         }          else {
         MKSTR(fname,"plot");            sprintf(ebuf,"%s : geometry list too long",POLARPLOT);
         arg = mknode(8,s_id,fname,poly,NULLP,NULLP,zrange,geom,wname);            error(ebuf);
         Pox_rpc(arg,&t);          }
         *rp = s_id;        }
         if(len!=2){
           sprintf(ebuf,"%s : geometry requierd 2 numbers", POLARPLOT);
           error(ebuf);
         } else geom=list[i];
       } else {
         //list first value is var (range)
         av=VR((P)BDY(BDY(list[i])));
         if(v[0]==av)range=list[i];
         else {
           sprintf(ebuf,"%s : invalid list length",POLARPLOT);
           error(ebuf);
         }
       }
     }
     // set default
     if(!range){
       STOQ(DEFAULTPOLARSTEP,defstep);MKReal(2*Pi,pi2);MKV(v[0],var);
       MKNODE(n,defstep,0);MKNODE(n1,pi2,n);MKNODE(n2,0,n1);
       MKNODE(defrange,var,n2);MKLIST(range,defrange);
     }
     if(!geom){
       STOQ(300,w300);MKNODE(n0,w300,0);MKNODE(n,w300,n0);MKLIST(geom,n);
     }
     stream=validate_ox_plot_stream(stream);
     STOQ(stream,s_id);
     MKSTR(fname,POLARPLOTD);
     arg=mknode(7,s_id,fname,poly,color,range,geom,wname);
     Pox_rpc(arg,&t);
     *rp=(Obj)s_id;
 }  }
   
 void Pplotover(NODE arg,Q *rp)  void ifplot_mainNG(NODE arg,char *fn,Obj *rp){
 {    Q m2,p2,w300,mxgc,s_id,color;
         Q s_id,index;    NODE defrange,n,n0,n1,n2;
         P poly;    P poly,var;
         STRING fname;    VL vl,vl0;
         Obj t;    V v[2],av;
     LIST xrange,yrange,zrange,geom,range[2],list[4];
     int stream,ri,i,j,sign,llen,len,iNo,lNo,vNo,sNo,pfine,findG;
     STRING fname,wname;
     Obj t,frst,sec,thr;
     char ebuf[BUFSIZ];
   
         poly = (P)ARG0(arg);    iNo=lNo=sNo=findG=0;pfine=TRUE;
         s_id = (Q)ARG1(arg);    poly=0;stream=-1;wname=0;color=0;stream=0;
         index = (Q)ARG2(arg);    STOQ(-2,m2);STOQ(2,p2);MKNODE(n,p2,0);MKNODE(defrange,m2,n);
         MKSTR(fname,"plotover");    STOQ(MAXGC,mxgc);
         if ( argc(arg) == 4 )    for(;arg;arg=NEXT(arg)){
                 arg = mknode(5,s_id,fname,index,poly,(Q)ARG3(arg));      if(!BDY(arg)) iNo++;
         else      else switch(OID(BDY(arg))){
                 arg = mknode(4,s_id,fname,index,poly);      case O_P://formular
         Pox_rpc(arg,&t);        if(pfine){
         *rp = s_id;          poly=(P)BDY(arg);
           pfine=FALSE;
         } else {
           sprintf(ebuf,"%s : to many plot arguments",fn);
           error(ebuf);
         }
         break;
       case O_N://color,id,idx,division
         switch (iNo){
         case 0: //color arg
           color=(Q)BDY(arg);
           iNo++;
           break;
         case 1: //stream arg
           stream=QTOS((Q)BDY(arg));
           iNo++;
           break;
         default:
           sprintf(ebuf,"%s : invalid number arguments",fn);
           error(ebuf);
           break;
         }
         break;
       case O_LIST://xrange,yrange,zrange,geometry
         if(lNo<4) list[lNo++]=(LIST)BDY(arg);
         else {
           sprintf(ebuf,"%s : invalid list argument",fn);
           error(ebuf);
         }
         break;
       case O_STR://wname
         wname=(STRING)BDY(arg);
         sNo++;
         break;
       default:
         break;
       }
     }
     // formular check
     if(!poly){
       sprintf(ebuf,"%s : invalid plot argument",fn);
       error(ebuf);
     }
     // vars check
     get_vars_recursive((Obj)poly,&vl);
     for(vl0=vl,vNo=0;vl0;vl0=NEXT(vl0)){
       if(vl0->v->attr==(pointer)V_IND){
         if(vNo>=2){
           sprintf(ebuf,"%s : invalid plot argument",fn);
           error(ebuf);
         } else v[vNo++]=vl0->v;
       }
     }
     //list check
     xrange=yrange=zrange=geom=0;frst=sec=thr=0;
     for(i=0;i<lNo;i++){
       for(llen=0,n=(NODE)BDY(list[i]);n;llen++,n=NEXT(n));
       if(llen>4){
         sprintf(ebuf,"%s : invalid list length",fn);
         error(ebuf);
       }
       if(OID(BDY(BDY(list[i])))!=O_P){
         // First list value is number
         for(len=0,n=(NODE)BDY(list[i]);n;len++,n=NEXT(n)){
           if(len==0)frst=BDY(n);
           else if(len==1)sec=BDY(n);
           else thr=BDY(n);
         }
         switch(len){
         case 2:
           if(!strcmp(fn,CONPLOT)){
             if(thr==0)thr=(Obj)mxgc;
             MKNODE(n,thr,0);MKNODE(n1,sec,n);MKNODE(n2,frst,n1);MKLIST(zrange,n2);
           } else geom=list[i];
           break;
         case 3:
           zrange=list[i];
           break;
         case 0:
         case 1:
         default:
           sprintf(ebuf,"%s : invalid list length",fn);
           error(ebuf);
           break;
         }
       } else {
         //xrange,yrange
         av=VR((P)BDY(BDY(list[i])));
         if(v[0]==av)xrange=list[i];
         else if(v[1]==av)yrange=list[i];
         else {
           MKLIST(zrange,NEXT(BDY(list[i])));
         }
       }
     }
     //set default
     if(!xrange){
       MKV(v[0],var);MKNODE(n,var,defrange);MKLIST(xrange,n);
     }
     if(!yrange){
       MKV(v[1],var);MKNODE(n,var,defrange);MKLIST(yrange,n);
     }
     if(!geom){
       STOQ(300,w300);MKNODE(n0,w300,0);MKNODE(n,w300,n0);MKLIST(geom,n);
     }
     if(!(strcmp(fn,CONPLOTD)&strcmp(fn,CONPLOTQ)&strcmp(fn,CONPLOTB))&!zrange){
       MKNODE(n,mxgc,0);MKNODE(n1,m2,n);MKNODE(n2,m2,n1);MKLIST(zrange,n2);
     }
     /*new ifplot in ox_plot requires
       [s_id (Q),
       formula (Obj),
       color (Q),
       geom=[xsize,ysize] (LIST optional),
       xrange=[x,xmin,xmax] (LIST optional),
       yrange=[y,ymin,ymax] (LIST optional),
       zrange=[zmin,zmax,zstep] (LIST optional),
       wname=name (STRING optional)],
       itvstep (Q) if ITVIFPLOT */
     stream=validate_ox_plot_stream(stream);
     STOQ(stream,s_id);
     MKSTR(fname,fn);
     arg=mknode(9,s_id,fname,poly,color,xrange,yrange,zrange,geom,wname);
     Pox_rpc(arg,&t);
     *rp=(Obj)s_id;
 }  }
   
 /* arg = [x,y,r,s_id,index] */  void plotover_mainNG(NODE arg,char *fn,Obj *rp){
     Q s_id,w_id,color;
     P poly;
     STRING fname;
     Obj t;
     int iNo,pfine,sfine;
     char ebuf[BUFSIZ];
   
 void Pdrawcircle(NODE arg,Q *rp)    pfine=sfine=TRUE;
 {    iNo=0;poly=0;color=s_id=w_id=0;
         Q s_id,index;    for(;arg;arg=NEXT(arg)){
         Obj x,y,r,c;      if(!BDY(arg)) iNo++;
         STRING fname;      else switch(OID(BDY(arg))){
         NODE n;      case O_P://formular
         LIST pos;        if(pfine){
         Obj t;          poly=(P)BDY(arg);
           pfine=FALSE;
         x = (Obj)ARG0(arg);        } else {
         y = (Obj)ARG1(arg);          sprintf(ebuf,"%s : to many plot arguments",fn);
         r = (Obj)ARG2(arg);          error(ebuf);
         c = (Obj)ARG3(arg);        }
         s_id = (Q)ARG4(arg);        break;
         index = (Q)ARG5(arg);      case O_N://color,s_id,w_id
         MKSTR(fname,"drawcircle");        switch(iNo){
         n = mknode(3,x,y,r,c); MKLIST(pos,n);        case 0://color arg
         arg = mknode(5,s_id,fname,index,pos,c);          color=(Q)BDY(arg);
         Pox_rpc(arg,&t);          iNo++;
         *rp = s_id;          break;
         case 1://stream arg
           s_id=(Q)BDY(arg);
           iNo++;
           break;
         case 2://window arg
           w_id=(Q)BDY(arg);
           iNo++;
           break;
         default://error
           sprintf(ebuf,"%s : to many numbers",fn);
           error(ebuf);
           break;
         }
         break;
       default:
         sprintf(ebuf,"%s : arguments type miss match",fn);
         error(ebuf);
       }
     }
     MKSTR(fname,fn);
     //[s_id (Q), w_id (Q), formula (Obj), color (Q)]
     arg=mknode(5,s_id,fname,w_id,poly,color);
     Pox_rpc(arg,&t);
     *rp=(Obj)s_id;
 }  }
   
 /* draw_obj(s_id,cindex,point|line); point = [x,y], line = [xa,ya,xb,yb] */  
 void Pdraw_obj(NODE arg,Q *rp)  
 {  
         static STRING fname;  
         Q s_id,index;  
         LIST obj;  
         Obj t;  
   
         if ( !fname ) {  
                 MKSTR(fname,"draw_obj");  
         }  
         s_id = (Q)ARG0(arg);  
         index = (Q)ARG1(arg);  
         obj = (LIST)ARG2(arg);  
         /* ARG3(arg) = color */  
         if ( argc(arg) == 4 )  
                 arg = mknode(5,s_id,fname,index,obj,ARG3(arg));  
         else  
                 arg = mknode(4,s_id,fname,index,obj);  
         Pox_cmo_rpc(arg,&t);  
         *rp = s_id;  
 }  
   
 /* draw_string(s_id,cindex,pos,string,[,color]); pos=[x,y] */  
 void Pdraw_string(NODE arg,Q *rp)  
 {  
         static STRING fname;  
         STRING str;  
         Q s_id,index;  
         LIST pos;  
         Obj t;  
   
         if ( !fname ) {  
                 MKSTR(fname,"draw_string");  
         }  
         s_id = (Q)ARG0(arg);  
         index = (Q)ARG1(arg);  
         pos = (LIST)ARG2(arg);  
         str = (STRING)ARG3(arg);  
         /* ARG4(arg) = color */  
         if ( argc(arg) == 5 )  
                 arg = mknode(6,s_id,fname,index,pos,str,ARG4(arg));  
         else  
                 arg = mknode(5,s_id,fname,index,pos,str);  
         Pox_cmo_rpc(arg,&t);  
         *rp = s_id;  
 }  
   
 void Pclear_canvas(NODE arg,Q *rp)  
 {  
         static STRING fname;  
         Q s_id,index;  
         Obj t;  
   
         if ( !fname ) {  
                 MKSTR(fname,"clear_canvas");  
         }  
         s_id = (Q)ARG0(arg);  
         index = (Q)ARG1(arg);  
         arg = mknode(3,s_id,fname,index);  
         Pox_cmo_rpc(arg,&t);  
         *rp = s_id;  
 }  
   
 #if 0  
 void Parrayplot(NODE arg,Obj *rp)  
 {  
         int s;  
         int id;  
   
         if ( ID((Obj)ARG0(arg)) == O_VECT && ID((Obj)ARG1(arg)) == O_LIST ) {  
                 s = current_s;  
                 gensend(s,C_APLOT,0);  
                 gensend(s,C_OBJ,ARG0(arg)); gensend(s,C_OBJ,ARG1(arg)); genflush(s);  
         }  
         genrecv(s,&id,rp);  
 }  
 #endif  
Legend:
Removed from v.1.23  
changed lines
  Added in v.1.34
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>