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

Diff for /OpenXM_contrib2/asir2000/builtin/strobj.c between version 1.95 and 1.104

version 1.95, 2005/11/03 07:41:22 version 1.104, 2005/11/30 05:08:00
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/strobj.c,v 1.94 2005/11/02 10:02:32 noro Exp $   * $OpenXM: OpenXM_contrib2/asir2000/builtin/strobj.c,v 1.103 2005/11/30 04:51:46 noro Exp $
 */  */
 #include "ca.h"  #include "ca.h"
 #include "parse.h"  #include "parse.h"
Line 98  void Pquote_normalize();
Line 98  void Pquote_normalize();
 void Pnquote_comp();  void Pnquote_comp();
 void Pnquote_match();  void Pnquote_match();
   
   void Pquote_to_nbp();
   void Pshuffle_mul(), Pharmonic_mul();
   void Pnbp_hm(), Pnbp_ht(), Pnbp_hc(), Pnbp_rest();
   void Pnbm_deg();
   void Pnbm_hp_rest();
   void Pnbm_hxky(), Pnbm_xky_rest();
   void Pnbm_hv(), Pnbm_rest();
   
 void Pquote_to_funargs(),Pfunargs_to_quote(),Pget_function_name();  void Pquote_to_funargs(),Pfunargs_to_quote(),Pget_function_name();
 void Pquote_match(),Pget_quote_id(),Pquote_match_rewrite();  void Pquote_match(),Pget_quote_id(),Pquote_match_rewrite();
 void Pquote_to_nary(),Pquote_to_bin();  void Pquote_to_nary(),Pquote_to_bin();
Line 139  struct ftab str_tab[] = {
Line 147  struct ftab str_tab[] = {
         {"quote_normalize",Pquote_normalize,-2},          {"quote_normalize",Pquote_normalize,-2},
         {"quote_match",Pquote_match,2},          {"quote_match",Pquote_match,2},
         {"quote_match_rewrite",Pquote_match_rewrite,-4},          {"quote_match_rewrite",Pquote_match_rewrite,-4},
   
         {"nquote_comp",Pnquote_comp,2},          {"nquote_comp",Pnquote_comp,2},
         {"nquote_match",Pnquote_match,2},          {"nquote_match",Pnquote_match,-3},
           {"quote_to_nbp",Pquote_to_nbp,1},
           {"shuffle_mul",Pshuffle_mul,2},
           {"harmonic_mul",Pharmonic_mul,2},
   
           {"nbp_hm", Pnbp_hm,1},
           {"nbp_ht", Pnbp_ht,1},
           {"nbp_hc", Pnbp_hc,1},
           {"nbp_rest", Pnbp_rest,1},
           {"nbm_deg", Pnbm_deg,1},
           {"nbm_hxky", Pnbm_hxky,1},
           {"nbm_xky_rest", Pnbm_xky_rest,1},
           {"nbm_hp_rest", Pnbm_hp_rest,1},
           {"nbm_hv", Pnbm_hv,1},
           {"nbm_rest", Pnbm_rest,1},
   
         {"quote_to_nary",Pquote_to_nary,1},          {"quote_to_nary",Pquote_to_nary,1},
         {"quote_to_bin",Pquote_to_bin,2},          {"quote_to_bin",Pquote_to_bin,2},
   
Line 663  void Pnquote_match(NODE arg,Q *rp)
Line 686  void Pnquote_match(NODE arg,Q *rp)
         QUOTE fq,pq;          QUOTE fq,pq;
         FNODE f,p;          FNODE f,p;
         int ret;          int ret;
           Q mode;
         NODE r;          NODE r;
   
         fq = (QUOTE)ARG0(arg); Pquote_normalize(mknode(2,fq,0),&fq); f = (FNODE)BDY(fq);          mode = argc(arg)==3 ? (Q)ARG2(arg) : 0;
         pq = (QUOTE)ARG1(arg); Pquote_normalize(mknode(2,pq,0),&pq); p = (FNODE)BDY(pq);          fq = (QUOTE)ARG0(arg); Pquote_normalize(mknode(2,fq,mode),&fq); f = (FNODE)BDY(fq);
           pq = (QUOTE)ARG1(arg); Pquote_normalize(mknode(2,pq,mode),&pq); p = (FNODE)BDY(pq);
         ret = nfnode_match(f,p,&r);          ret = nfnode_match(f,p,&r);
         if ( ret ) {          if ( ret ) {
                 fnode_do_assign(r);                  fnode_do_assign(r);
Line 675  void Pnquote_match(NODE arg,Q *rp)
Line 700  void Pnquote_match(NODE arg,Q *rp)
                 *rp = 0;                  *rp = 0;
 }  }
   
   
 FNODE rewrite_fnode(FNODE,NODE);  FNODE rewrite_fnode(FNODE,NODE);
   
 extern Obj VOIDobj;  extern Obj VOIDobj;
Line 747  void fnode_do_assign(NODE arg)
Line 773  void fnode_do_assign(NODE arg)
                 pair = (NODE)BDY(t);                  pair = (NODE)BDY(t);
                 pv = (int)BDY(pair);                  pv = (int)BDY(pair);
                 f = (FNODE)(BDY(NEXT(pair)));                  f = (FNODE)(BDY(NEXT(pair)));
                 if ( f->id == I_FUNC ) {                  if ( f->id == I_FUNC_HEAD ) {
                         /* XXX : used for wrapping A_func */                          /* XXX : I_FUNC_HEAD is a dummy id to pass FUNC */
                         MKQUOTEARG(qa,A_func,FA0(f));                          MKQUOTEARG(qa,A_func,FA0(f));
                         value = (QUOTE)qa;                          value = (QUOTE)qa;
                 } else                  } else
Line 2034  void Pquote_normalize(NODE arg,QUOTE *rp)
Line 2060  void Pquote_normalize(NODE arg,QUOTE *rp)
         ac = argc(arg);          ac = argc(arg);
         if ( !ac ) error("quote_normalize : invalid argument");          if ( !ac ) error("quote_normalize : invalid argument");
         q = (QUOTE)ARG0(arg);          q = (QUOTE)ARG0(arg);
         expand = ac==2 && ARG1(arg);          if ( ac == 2 )
         if ( !q || OID(q) != O_QUOTE ) {                  expand = QTOS((Q)ARG1(arg));
           if ( !q || OID(q) != O_QUOTE )
                 *rp = q;                  *rp = q;
                 return;  
         } else if ( q->normalized && (q->expanded || !expand) )  
                 *rp = q;  
         else {          else {
                 f = fnode_normalize(BDY(q),expand);                  f = fnode_normalize(BDY(q),expand);
                 MKQUOTE(r,f);                  MKQUOTE(r,f);
                 r->normalized = 1;  
                 if ( expand ) r->expanded = 1;  
                 *rp = r;                  *rp = r;
         }          }
 }  }
   
   NBP fnode_to_nbp(FNODE f);
   
   void Pquote_to_nbp(NODE arg,NBP *rp)
   {
           QUOTE q;
           FNODE f;
   
           q = (QUOTE)ARG0(arg); f = (FNODE)BDY(q);
           f = fnode_normalize(f,0);
           *rp = fnode_to_nbp(f);
   }
   
   void Pshuffle_mul(NODE arg,NBP *rp)
   {
           NBP p1,p2;
   
           p1 = (NBP)ARG0(arg);
           p2 = (NBP)ARG1(arg);
           shuffle_mulnbp(CO,p1,p2,rp);
   }
   
   void Pharmonic_mul(NODE arg,NBP *rp)
   {
           NBP p1,p2;
   
           p1 = (NBP)ARG0(arg);
           p2 = (NBP)ARG1(arg);
           harmonic_mulnbp(CO,p1,p2,rp);
   }
   
   void Pnbp_hm(NODE arg, NBP *rp)
   {
           NBP p;
           NODE n;
           NBM m;
   
           p = (NBP)ARG0(arg);
           if ( !p ) *rp = 0;
           else {
                   m = (NBM)BDY(BDY(p));
                   MKNODE(n,m,0);
                   MKNBP(*rp,n);
           }
   }
   
   void Pnbp_ht(NODE arg, NBP *rp)
   {
           NBP p;
           NODE n;
           NBM m,m1;
   
           p = (NBP)ARG0(arg);
           if ( !p ) *rp = 0;
           else {
                   m = (NBM)BDY(BDY(p));
                   NEWNBM(m1);
                   m1->d = m->d; m1->c = ONE; m1->b = m->b;
                   MKNODE(n,m1,0);
                   MKNBP(*rp,n);
           }
   }
   
   void Pnbp_hc(NODE arg, Q *rp)
   {
           NBP p;
           NBM m;
   
           p = (NBP)ARG0(arg);
           if ( !p ) *rp = 0;
           else {
                   m = (NBM)BDY(BDY(p));
                   *rp = m->c;
           }
   }
   
   void Pnbp_rest(NODE arg, NBP *rp)
   {
           NBP p;
           NODE n;
   
           p = (NBP)ARG0(arg);
           if ( !p ) *rp = 0;
           else {
                   n = BDY(p);
                   if ( !NEXT(n) ) *rp = 0;
                   else
                           MKNBP(*rp,NEXT(n));
           }
   }
   
   void Pnbm_deg(NODE arg, Q *rp)
   {
           NBP p;
           NBM m;
   
           p = (NBP)ARG0(arg);
           if ( !p )
                   STOQ(-1,*rp);
           else {
                   m = (NBM)BDY(BDY(p));
                   STOQ(m->d,*rp);
           }
   }
   
   void Pnbm_hp_rest(NODE arg, LIST *rp)
   {
           NBP p,h,r;
           NBM m,m1;
           NODE n;
           int *b,*b1;
           int d,d1,v,i,j,k;
   
           p = (NBP)ARG0(arg);
           if ( !p )
                   MKLIST(*rp,0);
           else {
                   m = (NBM)BDY(BDY(p));
                   b = m->b; d = m->d;
                   if ( !d )
                           MKLIST(*rp,0);
                   else {
                           v = NBM_GET(b,0);
                           for ( i = 1; i < d; i++ )
                                   if ( NBM_GET(b,i) != v ) break;
                           NEWNBM(m1); NEWNBMBDY(m1,i);
                           b1 = m1->b; m1->d = i; m1->c = ONE;
                           if ( v ) for ( j = 0; j < i; j++ ) NBM_SET(b1,j);
                           else for ( j = 0; j < i; j++ ) NBM_CLR(b1,j);
                           MKNODE(n,m1,0); MKNBP(h,n);
   
                           d1 = d-i;
                           NEWNBM(m1); NEWNBMBDY(m1,d1);
                           b1 = m1->b; m1->d = d1; m1->c = ONE;
                           for ( j = 0, k = i; j < d1; j++, k++ )
                                   if ( NBM_GET(b,k) ) NBM_SET(b1,j);
                                   else NBM_CLR(b1,j);
                           MKNODE(n,m1,0); MKNBP(r,n);
                           n = mknode(2,h,r);
                           MKLIST(*rp,n);
                   }
           }
   }
   
   void Pnbm_hxky(NODE arg, LIST *rp)
   {
           NBP p;
   
           p = (NBP)ARG0(arg);
           if ( !p )
                   *rp = 0;
           else
                   separate_xky_nbm((NBM)BDY(BDY(p)),0,rp,0);
   }
   
   void Pnbm_xky_rest(NODE arg,NBP *rp)
   {
           NBP p;
   
           p = (NBP)ARG0(arg);
           if ( !p )
                   *rp = 0;
           else
                   separate_xky_nbm((NBM)BDY(BDY(p)),0,0,rp);
   }
   
   void Pnbm_hv(NODE arg, NBP *rp)
   {
           NBP p;
   
           p = (NBP)ARG0(arg);
           if ( !p )
                   *rp = 0;
           else
                   separate_nbm((NBM)BDY(BDY(p)),0,rp,0);
   }
   
   void Pnbm_rest(NODE arg, NBP *rp)
   {
           NBP p;
   
           p = (NBP)ARG0(arg);
           if ( !p )
                   *rp = 0;
           else
                   separate_nbm((NBM)BDY(BDY(p)),0,0,rp);
   }
   
   NBP fnode_to_nbp(FNODE f)
   {
           Q r;
           int n,i;
           NBM m;
           V v;
           NBP u,u1,u2;
           NODE t,b;
   
           if ( f->id == I_FORMULA ) {
                   r = eval(f);
                   NEWNBM(m);
                   if ( OID(r) == O_N ) {
                           m->d = 0; m->c = (Q)r; m->b = 0;
                   } else {
                           v = VR((P)r);
                           m->d = 1; m->c = ONE; NEWNBMBDY(m,1);
                           if ( !strcmp(NAME(v),"x") ) NBM_SET(m->b,0);
                           else NBM_CLR(m->b,0);
                   }
                   MKNODE(b,m,0); MKNBP(u,b);
                   return u;
           } else if ( IS_NARYADD(f) ) {
                   t = (NODE)FA1(f); u = fnode_to_nbp((FNODE)BDY(t));
                   for ( t = NEXT(t); t; t = NEXT(t) ) {
                           u1 = fnode_to_nbp((FNODE)BDY(t));
                           addnbp(CO,u,u1,&u2); u = u2;
                   }
                   return u;
           } else if ( IS_NARYMUL(f) ) {
                   t = (NODE)FA1(f); u = fnode_to_nbp((FNODE)BDY(t));
                   for ( t = NEXT(t); t; t = NEXT(t) ) {
                           u1 = fnode_to_nbp((FNODE)BDY(t));
                           mulnbp(CO,u,u1,&u2); u = u2;
                   }
                   return u;
           } else if ( IS_BINARYPWR(f) ) {
                   u = fnode_to_nbp((FNODE)FA1(f));
                   r = eval((FNODE)FA2(f));
                   pwrnbp(CO,u,r,&u1);
                   return u1;
           }
   }
   
 void Pnquote_comp(NODE arg,Q *rp)  void Pnquote_comp(NODE arg,Q *rp)
 {  {
         QUOTE q1,q2;          QUOTE q1,q2;
Line 2057  void Pnquote_comp(NODE arg,Q *rp)
Line 2310  void Pnquote_comp(NODE arg,Q *rp)
   
         q1 = (QUOTE)ARG0(arg); f1 = (FNODE)BDY(q1);          q1 = (QUOTE)ARG0(arg); f1 = (FNODE)BDY(q1);
         q2 = (QUOTE)ARG1(arg); f2 = (FNODE)BDY(q2);          q2 = (QUOTE)ARG1(arg); f2 = (FNODE)BDY(q2);
         if ( !q1->normalized ) f1 = fnode_normalize(f1,0);          f1 = fnode_normalize(f1,0);
         if ( !q2->normalized ) f2 = fnode_normalize(f2,0);          f2 = fnode_normalize(f2,0);
         r = nfnode_comp(f1,f2);          r = nfnode_comp(f1,f2);
         STOQ(r,*rp);          STOQ(r,*rp);
 }  }
Line 2211  FNODE nfnode_add(FNODE a1,FNODE a2,int expand);
Line 2464  FNODE nfnode_add(FNODE a1,FNODE a2,int expand);
 FNODE nfnode_mul(FNODE a1,FNODE a2,int expand);  FNODE nfnode_mul(FNODE a1,FNODE a2,int expand);
 FNODE nfnode_pwr(FNODE a1,FNODE a2,int expand);  FNODE nfnode_pwr(FNODE a1,FNODE a2,int expand);
 FNODE nfnode_mul_coef(Num c,FNODE f,int expand);  FNODE nfnode_mul_coef(Num c,FNODE f,int expand);
 FNODE fnode_expand_pwr(FNODE f,int n);  FNODE fnode_expand_pwr(FNODE f,int n,int expand);
 FNODE to_narymul(FNODE f);  FNODE to_narymul(FNODE f);
 FNODE to_naryadd(FNODE f);  FNODE to_naryadd(FNODE f);
 FNODE fnode_node_to_naryadd(NODE n);  FNODE fnode_node_to_naryadd(NODE n);
Line 2226  FNODE fnode_normalize(FNODE f,int expand)
Line 2479  FNODE fnode_normalize(FNODE f,int expand)
         NODE n;          NODE n;
         Q q;          Q q;
   
         if ( f->normalized && (f->expanded || !expand) ) return f;          if ( f->normalized && (f->expanded == expand) ) return f;
         STOQ(-1,q);          STOQ(-1,q);
         mone = mkfnode(1,I_FORMULA,q);          mone = mkfnode(1,I_FORMULA,q);
         switch ( f->id ) {          switch ( f->id ) {
Line 2424  FNODE nfnode_mul(FNODE f1,FNODE f2,int expand)
Line 2677  FNODE nfnode_mul(FNODE f1,FNODE f2,int expand)
         m = (FNODE *)ALLOCA(l*sizeof(FNODE));          m = (FNODE *)ALLOCA(l*sizeof(FNODE));
         for ( r = n1, i = 0; i < l1; r = NEXT(r), i++ ) m[i] = BDY(r);          for ( r = n1, i = 0; i < l1; r = NEXT(r), i++ ) m[i] = BDY(r);
         for ( r = n2; r; r = NEXT(r) ) {          for ( r = n2; r; r = NEXT(r) ) {
                 if ( i == 0 )                  if ( i == 0 || (expand == 2) )
                         m[i++] = BDY(r);                          m[i++] = BDY(r);
                 else {                  else {
                         fnode_base_exp(m[i-1],&b1,&e1); fnode_base_exp(BDY(r),&b2,&e2);                          fnode_base_exp(m[i-1],&b1,&e1); fnode_base_exp(BDY(r),&b2,&e2);
Line 2480  FNODE nfnode_pwr(FNODE f1,FNODE f2,int expand)
Line 2733  FNODE nfnode_pwr(FNODE f1,FNODE f2,int expand)
                 ee = QTOS((Q)nf2);                  ee = QTOS((Q)nf2);
                 cc = mkfnode(1,I_FORMULA,c);                  cc = mkfnode(1,I_FORMULA,c);
                 if ( fnode_is_nonnegative_integer(f2) )                  if ( fnode_is_nonnegative_integer(f2) )
                         b = fnode_expand_pwr(b1,ee);                          b = fnode_expand_pwr(b1,ee,expand);
                 else {                  else {
                         STOQ(-1,q);                          STOQ(-1,q);
                         mone = mkfnode(1,I_FORMULA,q);                          mone = mkfnode(1,I_FORMULA,q);
Line 2490  FNODE nfnode_pwr(FNODE f1,FNODE f2,int expand)
Line 2743  FNODE nfnode_pwr(FNODE f1,FNODE f2,int expand)
                                 MKNODE(t1,inv,t0); t0 = t1;                                  MKNODE(t1,inv,t0); t0 = t1;
                         }                          }
                         b1 = fnode_node_to_narymul(t0);                          b1 = fnode_node_to_narymul(t0);
                         b = fnode_expand_pwr(b1,-ee);                          b = fnode_expand_pwr(b1,-ee,expand);
                 }                  }
                 if ( fnode_is_one(cc) )                  if ( fnode_is_one(cc) )
                         return b;                          return b;
Line 2500  FNODE nfnode_pwr(FNODE f1,FNODE f2,int expand)
Line 2753  FNODE nfnode_pwr(FNODE f1,FNODE f2,int expand)
                         && fnode_is_nonnegative_integer(f2) ) {                          && fnode_is_nonnegative_integer(f2) ) {
                 q = (Q)eval(f2);                  q = (Q)eval(f2);
                 if ( PL(NM(q)) > 1 ) error("nfnode_pwr : exponent too large");                  if ( PL(NM(q)) > 1 ) error("nfnode_pwr : exponent too large");
                 return fnode_expand_pwr(f1,QTOS(q));                  return fnode_expand_pwr(f1,QTOS(q),expand);
         } else          } else
                 return mkfnode(3,I_BOP,pwrfs,f1,f2);                  return mkfnode(3,I_BOP,pwrfs,f1,f2);
 }  }
   
 FNODE fnode_expand_pwr(FNODE f,int n)  FNODE fnode_expand_pwr(FNODE f,int n,int expand)
 {  {
         int n1;          int n1,i;
         FNODE f1,f2;          FNODE f1,f2,fn;
           Q q;
   
         if ( !n ) return mkfnode(1,I_FORMULA,ONE);          if ( !n ) return mkfnode(1,I_FORMULA,ONE);
         else if ( IS_ZERO(f) ) return mkfnode(1,I_FORMULA,0);          else if ( IS_ZERO(f) ) return mkfnode(1,I_FORMULA,0);
         else if ( n == 1 ) return f;          else if ( n == 1 ) return f;
         else {          else {
                 n1 = n/2;                  switch ( expand ) {
                 f1 = fnode_expand_pwr(f,n1);                          case 1:
                 f2 = nfnode_mul(f1,f1,1);                                  n1 = n/2;
                 if ( n%2 ) f2 = nfnode_mul(f2,f,1);                                  f1 = fnode_expand_pwr(f,n1,expand);
                 return f2;                                  f2 = nfnode_mul(f1,f1,expand);
                                   if ( n%2 ) f2 = nfnode_mul(f2,f,1);
                                   return f2;
                           case 2:
                                   for ( i = 1, f1 = f; i < n; i++ )
                                           f1 = nfnode_mul(f1,f,expand);
                                   return f1;
                           case 0: default:
                                   STOQ(n,q);
                                   fn = mkfnode(1,I_FORMULA,q);
                                   return mkfnode(3,I_BOP,pwrfs,f,fn);
                   }
         }          }
 }  }
   
Line 2794  int nfnode_match(FNODE f,FNODE pat,NODE *rp)
Line 3059  int nfnode_match(FNODE f,FNODE pat,NODE *rp)
         NODE m,m1,m2,base,exp,fa,pa,n;          NODE m,m1,m2,base,exp,fa,pa,n;
         LIST l;          LIST l;
         QUOTE qp,qf;          QUOTE qp,qf;
         FNODE fbase,fexp,a;          FNODE fbase,fexp,a,fh;
         FUNC ff,pf;          FUNC ff,pf;
         int r;          int r;
   
           if ( !pat )
                   if ( !f ) {
                           *rp = 0;
                           return 1;
                   } else
                           return 0;
           else if ( !f )
                   return 0;
         switch ( pat->id ) {          switch ( pat->id ) {
                 case I_PVAR:                  case I_PVAR:
                         /* [[pat,f]] */                          /* [[pat,f]] */
                         *rp = mknode(1,mknode(2,(int)FA0(pat),f),0);                          *rp = mknode(1,mknode(2,(int)FA0(pat),f));
                         return 1;                          return 1;
   
                 case I_FORMULA:                  case I_FORMULA:
Line 2836  int nfnode_match(FNODE f,FNODE pat,NODE *rp)
Line 3109  int nfnode_match(FNODE f,FNODE pat,NODE *rp)
                                 if ( strcmp(ff->fullname,pf->fullname) ) return 0;                                  if ( strcmp(ff->fullname,pf->fullname) ) return 0;
                                 m = 0;                                  m = 0;
                         } else {                          } else {
                                 /* XXX only FA0(f) is used */                                  /* XXX : I_FUNC_HEAD is a dummy id to pass FUNC */
                                 m = mknode(1,mknode(2,FA0((FNODE)FA0(pat)),f),0);                                  fh = mkfnode(1,I_FUNC_HEAD,FA0(f));
                                   m = mknode(1,mknode(2,FA0((FNODE)FA0(pat)),fh),0);
                         }                          }
                         /* FA1(f) and FA1(pat) are I_LIST */                          /* FA1(f) and FA1(pat) are I_LIST */
                         fa = (NODE)FA0((FNODE)FA1(f));                          fa = (NODE)FA0((FNODE)FA1(f));
Line 2900  FNODE fnode_left_narymul(FNODE p,int i)
Line 3174  FNODE fnode_left_narymul(FNODE p,int i)
         a = (NODE)FA1(p);          a = (NODE)FA1(p);
         l = length(a);          l = length(a);
         if ( i < 0 || i >= l ) error("fnode_left_narymul : invalid index");          if ( i < 0 || i >= l ) error("fnode_left_narymul : invalid index");
         if ( i == 0 ) return mkfnode(1,I_FORMULA,ONE);          if ( i == 0 ) return 0;
         else if ( i == 1 ) return (FNODE)BDY(a);          else if ( i == 1 ) return (FNODE)BDY(a);
         else {          else {
                 for ( r0 = 0, k = 0, t = a; k < i; k++, t = NEXT(t) ) {                  for ( r0 = 0, k = 0, t = a; k < i; k++, t = NEXT(t) ) {
Line 2921  FNODE fnode_right_narymul(FNODE p,int i)
Line 3195  FNODE fnode_right_narymul(FNODE p,int i)
         a = (NODE)FA1(p);          a = (NODE)FA1(p);
         l = length(a);          l = length(a);
         if ( i < 0 || i >= l ) error("fnode_right_narymul : invalid index");          if ( i < 0 || i >= l ) error("fnode_right_narymul : invalid index");
         if ( i == l-1 ) return mkfnode(1,I_FORMULA,ONE);          if ( i == l-1 ) return 0;
         else {          else {
                 for ( k = 0, t = a; k <= i; k++, t = NEXT(t) );                  for ( k = 0, t = a; k <= i; k++, t = NEXT(t) );
                 return fnode_node_to_narymul(t);                  return fnode_node_to_narymul(t);
Line 3018  int nfnode_match_narymul(FNODE f,FNODE p,NODE *rp)
Line 3292  int nfnode_match_narymul(FNODE f,FNODE p,NODE *rp)
                         pright = fnode_right_narymul(p,pi);                          pright = fnode_right_narymul(p,pi);
                         /* XXX : incomplete */                          /* XXX : incomplete */
                         for ( s = fa, fi = 0; s; s = NEXT(s), fi++ ) {                          for ( s = fa, fi = 0; s; s = NEXT(s), fi++ ) {
                                   if ( fi < pi ) continue;
                                 if ( nfnode_match(BDY(s),pivot,&m) ) {                                  if ( nfnode_match(BDY(s),pivot,&m) ) {
                                         fleft = fnode_left_narymul(f,fi);                                          fleft = fnode_left_narymul(f,fi);
                                         pleft1 = rewrite_fnode(pleft,m);                                          pleft1 = rewrite_fnode(pleft,m);
Legend:
Removed from v.1.95  
changed lines
  Added in v.1.104
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>