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

Diff for /OpenXM_contrib2/asir2000/builtin/pf.c between version 1.8 and 1.16

version 1.8, 2004/06/27 03:15:57 version 1.16, 2009/07/23 01:04:29
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/builtin/pf.c,v 1.7 2004/06/22 09:17:21 noro Exp $   * $OpenXM: OpenXM_contrib2/asir2000/builtin/pf.c,v 1.15 2008/11/18 20:52:47 ohara Exp $
 */  */
 #include "ca.h"  #include "ca.h"
 #include "math.h"  #include "math.h"
Line 63  void make_tri(void);
Line 63  void make_tri(void);
 void make_exp(void);  void make_exp(void);
 void simplify_pow(PFINS,Obj *);  void simplify_pow(PFINS,Obj *);
   
 void Pfunctor(),Pargs(),Pfunargs(),Pvtype(),Pcall(),Pdeval();  void Pfunctor(),Pargs(),Pfunargs(),Pvtype(),Pcall(),Pdeval(),Pfunargs_ext();
 void Pregister_handler();  void Pregister_handler();
 void Peval_quote();  void Peval_quote();
 void Pmapat();  void Pmapat(), Pmap();
   void Padd_handler();
   void Plist_handler();
   void Pclear_handler();
   
 struct ftab puref_tab[] = {  struct ftab puref_tab[] = {
         {"mapat",Pmapat,-99999999},          {"mapat",Pmapat,-99999999},
           {"map",Pmap,-99999999},
         {"functor",Pfunctor,1},          {"functor",Pfunctor,1},
         {"args",Pargs,1},          {"args",Pargs,1},
         {"funargs",Pfunargs,1},          {"funargs",Pfunargs,1},
           {"funargs_ext",Pfunargs_ext,1},
         {"register_handler",Pregister_handler,1},          {"register_handler",Pregister_handler,1},
           {"add_handler",Padd_handler,2},
           {"list_handler",Plist_handler,1},
           {"clear_handler",Pclear_handler,1},
         {"call",Pcall,2},          {"call",Pcall,2},
         {"vtype",Pvtype,1},          {"vtype",Pvtype,1},
         {"deval",Pdeval,1},          {"deval",Pdeval,1},
         {"eval_quote",Peval_quote,1},          {"eval_quote",Peval_quote,-2},
         {0,0,0},          {0,0,0},
 };  };
   
Line 300  Obj *rp;
Line 308  Obj *rp;
 }  }
   
 #define ISPFINS(p)\  #define ISPFINS(p)\
 (p)&&(ID(p) == O_P)&&((int)VR((P)p)->attr!=V_PF)&&\  ((p)&&(ID(p) == O_P)&&((int)VR((P)p)->attr==V_PF)&&\
 UNIQ(DEG(DC((P)p)))&&UNIQ(COEF(DC((P)p)))  UNIQ(DEG(DC((P)p)))&&UNIQ(COEF(DC((P)p))))
   
 void Pfunctor(arg,rp)  void Pfunctor(arg,rp)
 NODE arg;  NODE arg;
Line 380  LIST *rp;
Line 388  LIST *rp;
         }          }
 }  }
   
   void Pfunargs_ext(arg,rp)
   NODE arg;
   LIST *rp;
   {
           P p;
           P f;
           FUNC t;
           PF pf;
           PFINS ins;
           PFAD ad;
           NODE n,n0,d,d0,a,a0;
           LIST alist,dlist;
           Q q;
           int i;
   
           p = (P)ARG0(arg);
           if ( !ISPFINS(p) )
                   *rp = 0;
           else {
                   ins = (PFINS)VR(p)->priv; ad = ins->ad; pf = ins->pf;
                   t = (FUNC)MALLOC(sizeof(struct oFUNC));
                   t->name = t->fullname = pf->name; t->id = A_PURE; t->argc = pf->argc;
                   t->f.puref = pf;
                   makesrvar(t,&f);
   
                   d0 = a0 = 0;
                   for ( i = 0; i < pf->argc; i++ ) {
                           NEXTNODE(d0,d); STOQ(ad[i].d,q); BDY(d) = (pointer)q;
                           NEXTNODE(a0,a); BDY(a) = (pointer)ad[i].arg;
                   }
                   NEXT(d) = 0; NEXT(a) = 0; MKLIST(alist,a0); MKLIST(dlist,d0);
   
                   n0 = mknode(3,f,dlist,alist);
                   MKLIST(*rp,n0);
           }
   }
   
 void Pvtype(arg,rp)  void Pvtype(arg,rp)
 NODE arg;  NODE arg;
 Q *rp;  Q *rp;
Line 393  Q *rp;
Line 438  Q *rp;
                 STOQ((int)VR(p)->attr,*rp);                  STOQ((int)VR(p)->attr,*rp);
 }  }
   
 extern FUNC registered_handler;  extern NODE user_int_handler,user_quit_handler;
   
 void Pregister_handler(arg,rp)  void Pregister_handler(arg,rp)
 NODE arg;  NODE arg;
Line 401  Q *rp;
Line 446  Q *rp;
 {  {
         P p;          P p;
         V v;          V v;
           NODE n;
         FUNC func;          FUNC func;
   
         p = (P)ARG0(arg);          p = (P)ARG0(arg);
         if ( !p )          if ( !p ) {
                 registered_handler = 0;                  user_int_handler = 0;
         else if ( OID(p) != 2 )                  *rp = 0;
                   return;
           } else if ( OID(p) != 2 )
                 error("register_hanlder : invalid argument");                  error("register_hanlder : invalid argument");
         v = VR(p);          v = VR(p);
         if ( (int)v->attr != V_SR )          if ( (int)v->attr != V_SR )
Line 416  Q *rp;
Line 464  Q *rp;
                 if ( func->argc )                  if ( func->argc )
                         error("register_hanlder : the function must be with no argument");                          error("register_hanlder : the function must be with no argument");
                 else {                  else {
                         registered_handler = func;                          MKNODE(n,(pointer)func,user_int_handler);
                           user_int_handler = n;
                         *rp = ONE;                          *rp = ONE;
                 }                  }
         }          }
 }  }
   
   void Padd_handler(arg,rp)
   NODE arg;
   Q *rp;
   {
           P p;
           V v;
           NODE n;
           FUNC func;
           char *name;
           NODE *hlistp;
   
           asir_assert(ARG0(arg),O_STR,"add_handler");
           name = BDY((STRING)ARG0(arg));
           p = (P)ARG1(arg);
           if ( !strcmp(name,"intr") )
                   hlistp = &user_int_handler;
           else if ( !strcmp(name,"quit") )
                   hlistp = &user_quit_handler;
           else
                   error("add_handler : invalid keyword (must be \"intr\" or \"quit\")");
           if ( !p ) {
                   *hlistp = 0; *rp = 0;
                   return;
           }
           if ( OID(p) == 2 ) {
                   v = VR(p);
                   if ( (int)v->attr != V_SR )
                           error("add_hanlder : no such function");
                   func = (FUNC)v->priv;
           } else if ( OID(p) == O_STR ) {
                   gen_searchf_searchonly(BDY((STRING)p),&func);
                   if ( !func )
                           error("add_hanlder : no such function");
           }
           if ( func->argc )
                   error("register_hanlder : the function must be with no argument");
           else {
                   MKNODE(n,(pointer)func,*hlistp);
                   *hlistp = n;
                   *rp = ONE;
           }
   }
   
   void Plist_handler(arg,rp)
   NODE arg;
   LIST *rp;
   {
           NODE r0,r,t;
           char *name;
           NODE hlist;
           STRING fname;
   
           asir_assert(ARG0(arg),O_STR,"list_handler");
           name = BDY((STRING)ARG0(arg));
           if ( !strcmp(name,"intr") )
                   hlist = user_int_handler;
           else if ( !strcmp(name,"quit") )
                   hlist = user_quit_handler;
           else
                   error("list_handler : invalid keyword (must be \"intr\" or \"quit\")");
           for ( r0 = 0, t = hlist; t; t = NEXT(t) ) {
                   NEXTNODE(r0,r);
                   MKSTR(fname,((FUNC)BDY(t))->fullname);
                   BDY(r) = (pointer)fname;
           }
           if ( r0 ) NEXT(r) = 0;
           MKLIST(*rp,r0);
   }
   
   void Pclear_handler(arg,rp)
   NODE arg;
   Q *rp;
   {
           NODE r0,r,t;
           char *name;
           NODE hlist;
           STRING fname;
   
           asir_assert(ARG0(arg),O_STR,"clear_handler");
           name = BDY((STRING)ARG0(arg));
           if ( !strcmp(name,"intr") )
                   user_int_handler = 0;
           else if ( !strcmp(name,"quit") )
                   user_quit_handler = 0;
           else
                   error("clear_handler : invalid keyword (must be \"intr\" or \"quit\")");
           *rp = 0;
   }
   
 void Pcall(NODE arg,Obj *rp)  void Pcall(NODE arg,Obj *rp)
 {  {
         P p;          P p;
         V v;          V v;
       NODE n,n1;
       LIST list;
       VECT vect;
       pointer *a;
       int len,i;
   
         p = (P)ARG0(arg);          p = (P)ARG0(arg);
         if ( !p || OID(p) != 2 )          if ( !p || OID(p) != 2 )
Line 433  void Pcall(NODE arg,Obj *rp)
Line 576  void Pcall(NODE arg,Obj *rp)
         v = VR(p);          v = VR(p);
         if ( (int)v->attr != V_SR )          if ( (int)v->attr != V_SR )
                 error("call : no such function");                  error("call : no such function");
           else {
         else          list = (LIST) ARG1(arg);
                 *rp = (Obj)bevalf((FUNC)v->priv,BDY((LIST)ARG1(arg)));          if ( list ) {
               switch (OID(list)) {
               case O_VECT:
                   vect = (VECT)list; len = vect->len; a = BDY(vect);
                   for ( i = len - 1, n = 0; i >= 0; i-- ) {
                       MKNODE(n1,a[i],n); n = n1;
                   }
                   MKLIST(list,n);
                   /* falling next case */
               case O_LIST:
                   *rp = (Obj)bevalf_with_opts((FUNC)v->priv,BDY(list),current_option);
                   return;
               default:
                   break;
               }
           }
           error("call : invalid argument");
           }
 }  }
   
 /* at=position of arg to be used for iteration */  /* at=position of arg to be used for iteration */
Line 453  void Pmapat(NODE arg,Obj *rp)
Line 613  void Pmapat(NODE arg,Obj *rp)
         int len,row,col,i,j,pos;          int len,row,col,i,j,pos;
         Obj iter;          Obj iter;
         pointer val;          pointer val;
           NODE option;
   
           option = current_option;
   
         if ( argc(arg) < 3 )          if ( argc(arg) < 3 )
                 error("mapat : too few arguments");                  error("mapat : too few arguments");
   
Line 478  void Pmapat(NODE arg,Obj *rp)
Line 641  void Pmapat(NODE arg,Obj *rp)
         NEXTNODE(r0,r);          NEXTNODE(r0,r);
         iter = BDY(t); rest = NEXT(t);          iter = BDY(t); rest = NEXT(t);
         if ( !iter ) {          if ( !iter ) {
                 *rp = bevalf(f,node);                  *rp = bevalf_with_opts(f,node,option);
                 return;                  return;
         }          }
         switch ( OID(iter) ) {          switch ( OID(iter) ) {
Line 486  void Pmapat(NODE arg,Obj *rp)
Line 649  void Pmapat(NODE arg,Obj *rp)
                         v = (VECT)iter; len = v->len; MKVECT(rv,len);                          v = (VECT)iter; len = v->len; MKVECT(rv,len);
                         for ( i = 0; i < len; i++ ) {                          for ( i = 0; i < len; i++ ) {
                                 BDY(r) = BDY(v)[i]; NEXT(r) = rest;                                  BDY(r) = BDY(v)[i]; NEXT(r) = rest;
                                 BDY(rv)[i] = bevalf(f,r0);                                  BDY(rv)[i] = bevalf_with_opts(f,r0,option);
                         }                          }
                         *rp = (Obj)rv;                          *rp = (Obj)rv;
                         break;                          break;
Line 495  void Pmapat(NODE arg,Obj *rp)
Line 658  void Pmapat(NODE arg,Obj *rp)
                         for ( i = 0; i < row; i++ )                          for ( i = 0; i < row; i++ )
                                 for ( j = 0; j < col; j++ ) {                                  for ( j = 0; j < col; j++ ) {
                                         BDY(r) = BDY(m)[i][j]; NEXT(r) = rest;                                          BDY(r) = BDY(m)[i][j]; NEXT(r) = rest;
                                         BDY(rm)[i][j] = bevalf(f,r0);                                          BDY(rm)[i][j] = bevalf_with_opts(f,r0,option);
                                 }                                  }
                         *rp = (Obj)rm;                          *rp = (Obj)rm;
                         break;                          break;
Line 503  void Pmapat(NODE arg,Obj *rp)
Line 666  void Pmapat(NODE arg,Obj *rp)
                         n = BDY((LIST)iter);                          n = BDY((LIST)iter);
                         for ( t0 = t = 0; n; n = NEXT(n) ) {                          for ( t0 = t = 0; n; n = NEXT(n) ) {
                                 BDY(r) = BDY(n); NEXT(r) = rest;                                  BDY(r) = BDY(n); NEXT(r) = rest;
                                 NEXTNODE(t0,t); BDY(t) = bevalf(f,r0);                                  NEXTNODE(t0,t); BDY(t) = bevalf_with_opts(f,r0,option);
                         }                          }
                         if ( t0 )                          if ( t0 )
                                 NEXT(t) = 0;                                  NEXT(t) = 0;
Line 511  void Pmapat(NODE arg,Obj *rp)
Line 674  void Pmapat(NODE arg,Obj *rp)
                         *rp = (Obj)rl;                          *rp = (Obj)rl;
                         break;                          break;
                 default:                  default:
                         *rp = bevalf(f,node);                          *rp = bevalf_with_opts(f,node,option);
                         break;                          break;
         }          }
 }  }
   
   /* An implementation of 'map' as builtin function. */
   void Pmap(NODE arg,Obj *rp)
   {
           LIST args;
           NODE node,rest,t0,t,n,r,r0;
           P fpoly;
           V fvar;
           FUNC f;
           VECT v,rv;
           MAT m,rm;
           LIST rl;
           int len,row,col,i,j;
           Obj iter;
           pointer val;
           NODE option;
   
           option = current_option;
   
           if ( argc(arg) < 2 )
                   error("mapat : too few arguments");
   
           fpoly = (P)ARG0(arg);
           if ( !fpoly || OID(fpoly) != O_P )
                   error("map : invalid function specification");
           fvar = VR(fpoly);
           if ( fvar->attr != (pointer)V_SR || !(f=(FUNC)fvar->priv) )
                   error("map : invalid function specification");
   
           node = NEXT(arg);
           len = length(node);
           if ( 0 >= len )
                   error("evalmapf : invalid position");
           r0 = 0;
           NEXTNODE(r0,r);
           iter = BDY(t); rest = NEXT(t);
           if ( !iter ) {
                   *rp = bevalf_with_opts(f,node,option);
                   return;
           }
           switch ( OID(iter) ) {
                   case O_VECT:
                           v = (VECT)iter; len = v->len; MKVECT(rv,len);
                           for ( i = 0; i < len; i++ ) {
                                   BDY(r) = BDY(v)[i]; NEXT(r) = rest;
                                   BDY(rv)[i] = bevalf_with_opts(f,r0,option);
                           }
                           *rp = (Obj)rv;
                           break;
                   case O_MAT:
                           m = (MAT)iter; row = m->row; col = m->col; MKMAT(rm,row,col);
                           for ( i = 0; i < row; i++ )
                                   for ( j = 0; j < col; j++ ) {
                                           BDY(r) = BDY(m)[i][j]; NEXT(r) = rest;
                                           BDY(rm)[i][j] = bevalf_with_opts(f,r0,option);
                                   }
                           *rp = (Obj)rm;
                           break;
                   case O_LIST:
                           n = BDY((LIST)iter);
                           for ( t0 = t = 0; n; n = NEXT(n) ) {
                                   BDY(r) = BDY(n); NEXT(r) = rest;
                                   NEXTNODE(t0,t); BDY(t) = bevalf_with_opts(f,r0,option);
                           }
                           if ( t0 )
                                   NEXT(t) = 0;
                           MKLIST(rl,t0);
                           *rp = (Obj)rl;
                           break;
                   default:
                           *rp = bevalf_with_opts(f,node,option);
                           break;
           }
   }
   
 void Pdeval(arg,rp)  void Pdeval(arg,rp)
 NODE arg;  NODE arg;
 Obj *rp;  Obj *rp;
Line 528  void Peval_quote(arg,rp)
Line 765  void Peval_quote(arg,rp)
 NODE arg;  NODE arg;
 Obj *rp;  Obj *rp;
 {  {
         asir_assert(ARG0(arg),O_QUOTE,"eval_quote");          FNODE a;
         *rp = eval((FNODE)BDY((QUOTE)ARG0(arg)));          QUOTE q;
           Obj f;
   
           f = (Obj)ARG0(arg);
           if ( !f || OID(f) != O_QUOTE ) {
                   *rp = f;
                   return;
           }
           if ( argc(arg) == 2 && ARG1(arg) ) {
                   a = partial_eval((FNODE)BDY((QUOTE)ARG0(arg)));
                   MKQUOTE(q,a);
                   *rp = (Obj)q;
           } else
                   *rp = eval((FNODE)BDY((QUOTE)ARG0(arg)));
 }  }
Legend:
Removed from v.1.8  
changed lines
  Added in v.1.16
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>