[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.74 and 1.75

version 1.74, 2005/10/14 07:49:21 version 1.75, 2005/10/15 01:10:15
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.73 2005/10/14 07:39:38 noro Exp $   * $OpenXM: OpenXM_contrib2/asir2000/builtin/strobj.c,v 1.74 2005/10/14 07:49:21 noro Exp $
 */  */
 #include "ca.h"  #include "ca.h"
 #include "parse.h"  #include "parse.h"
Line 64  struct TeXSymbol {
Line 64  struct TeXSymbol {
 };  };
   
 #define OPNAME(f) (((ARF)FA0(f))->name[0])  #define OPNAME(f) (((ARF)FA0(f))->name[0])
   #define IS_BINARYPWR(f) (((f)->id==I_BOP) &&(OPNAME(f)=='^'))
   #define IS_NARYADD(f) (((f)->id==I_NARYOP) &&(OPNAME(f)=='+'))
   #define IS_NARYMUL(f) (((f)->id==I_NARYOP) &&(OPNAME(f)=='*'))
   
 extern char *parse_strp;  extern char *parse_strp;
   
Line 2098  FNODE fnode_normalize_mul(FNODE a1,FNODE a2);
Line 2101  FNODE fnode_normalize_mul(FNODE a1,FNODE a2);
 FNODE fnode_normalize_pwr(FNODE a1,FNODE a2);  FNODE fnode_normalize_pwr(FNODE a1,FNODE a2);
 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_narymul(NODE n);
 FNODE fnode_normalize_mul_coef(Num c,FNODE f);  FNODE fnode_normalize_mul_coef(Num c,FNODE f);
 void fnode_base_exp(FNODE f,FNODE *bp,FNODE *ep);  void fnode_base_exp(FNODE f,FNODE *bp,FNODE *ep);
 void fnode_coef_body(FNODE f,Num *cp,FNODE *bp);  void fnode_coef_body(FNODE f,Num *cp,FNODE *bp);
Line 2107  FNODE fnode_normalize(FNODE f)
Line 2112  FNODE fnode_normalize(FNODE f)
 {  {
         FNODE a1,a2,mone,r,b2;          FNODE a1,a2,mone,r,b2;
         NODE n;          NODE n;
         Num invc2,c2;  
         Q q;          Q q;
   
         STOQ(-1,q);          STOQ(-1,q);
Line 2209  FNODE fnode_normalize_add(FNODE f1,FNODE f2)
Line 2213  FNODE fnode_normalize_add(FNODE f1,FNODE f2)
   
         if ( fnode_is_zero(f1) ) return f2;          if ( fnode_is_zero(f1) ) return f2;
         else if ( fnode_is_zero(f2) ) return f1;          else if ( fnode_is_zero(f2) ) return f1;
         if ( f1->id != I_NARYOP || OPNAME(f1) != '+' ) f1 = to_naryadd(f1);          f1 = to_naryadd(f1); f2 = to_naryadd(f2);
         if ( f2->id != I_NARYOP || OPNAME(f2) != '+' ) f2 = to_naryadd(f2);          n1 = (NODE)FA1(f1); n2 = (NODE)FA1(f2);
         n1 = (NODE)FA1(f1);  
         n2 = (NODE)FA1(f2);  
         r0 = 0;          r0 = 0;
         while ( n1 && n2 ) {          while ( n1 && n2 ) {
                 fnode_coef_body(BDY(n1),&c1,&b1);                  fnode_coef_body(BDY(n1),&c1,&b1); fnode_coef_body(BDY(n2),&c2,&b2);
                 fnode_coef_body(BDY(n2),&c2,&b2);                  if ( (s = compfnode(b1,b2)) > 0 ) {
                 s = compfnode(b1,b2);  
                 if ( s > 0 ) {  
                         NEXTNODE(r0,r); BDY(r) = BDY(n1); n1 = NEXT(n1);                          NEXTNODE(r0,r); BDY(r) = BDY(n1); n1 = NEXT(n1);
                 } else if ( s < 0 ) {                  } else if ( s < 0 ) {
                         NEXTNODE(r0,r); BDY(r) = BDY(n2); n2 = NEXT(n2);                          NEXTNODE(r0,r); BDY(r) = BDY(n2); n2 = NEXT(n2);
                 } else {                  } else {
                         addnum(0,c1,c2,&c);                          addnum(0,c1,c2,&c);
                         if ( c ) {                          if ( c ) {
                                 NEXTNODE(r0,r);                                  NEXTNODE(r0,r); BDY(r) = fnode_normalize_mul_coef(c,b1);
                                 BDY(r) = UNIQ(c) ? b1 : fnode_normalize_mul_coef(c,b1);  
                         }                          }
                         n1 = NEXT(n1); n2 = NEXT(n2);                          n1 = NEXT(n1); n2 = NEXT(n2);
                 }                  }
Line 2240  FNODE fnode_normalize_add(FNODE f1,FNODE f2)
Line 2239  FNODE fnode_normalize_add(FNODE f1,FNODE f2)
         else if ( r0 )          else if ( r0 )
                 NEXT(r) = 0;                  NEXT(r) = 0;
   
         if ( !r0 )          return fnode_node_to_naryadd(r0);
                 return mkfnode(1,I_FORMULA,0);  
         else if ( !NEXT(r0) )  
                 return BDY(r0);  
         else  
                 return mkfnode(2,I_NARYOP,addfs,r0);  
 }  }
   
   FNODE fnode_node_to_naryadd(NODE n)
   {
           if ( !n ) return mkfnode(1,I_FORMULA,0);
           else if ( !NEXT(n) ) return BDY(n);
           else return mkfnode(2,I_NARYOP,addfs,n);
   }
   
   FNODE fnode_node_to_narymul(NODE n)
   {
           if ( !n ) return mkfnode(1,I_FORMULA,ONE);
           else if ( !NEXT(n) ) return BDY(n);
           else return mkfnode(2,I_NARYOP,mulfs,n);
   }
   
 FNODE fnode_normalize_mul(FNODE f1,FNODE f2)  FNODE fnode_normalize_mul(FNODE f1,FNODE f2)
 {  {
         NODE n1,n2,r0,r,r1;          NODE n1,n2,r0,r,r1;
Line 2255  FNODE fnode_normalize_mul(FNODE f1,FNODE f2)
Line 2263  FNODE fnode_normalize_mul(FNODE f1,FNODE f2)
         FNODE *m;          FNODE *m;
         int s;          int s;
         Num c1,c2,c,e;          Num c1,c2,c,e;
         int l1,l2,l,i,j;          int l1,l,i,j;
   
         if ( fnode_is_zero(f1) || fnode_is_zero(f2) ) return 0;          if ( fnode_is_zero(f1) || fnode_is_zero(f2) ) return 0;
           else if ( fnode_is_number(f1) )
                   return fnode_normalize_mul_coef((Num)eval(f1),f2);
           else if ( fnode_is_number(f2) )
                   return fnode_normalize_mul_coef((Num)eval(f2),f1);
   
         if ( f1->id != I_NARYOP || OPNAME(f1) != '*' ) f1 = to_narymul(f1);          fnode_coef_body(f1,&c1,&b1); fnode_coef_body(f2,&c2,&b2);
         if ( f2->id != I_NARYOP || OPNAME(f2) != '*' ) f2 = to_narymul(f2);          mulnum(0,c1,c2,&c);
         n1 = (NODE)FA1(f1);  
         n2 = (NODE)FA1(f2);  
         if ( fnode_is_number(BDY(n1)) )  
                 if ( fnode_is_number(BDY(n2)) ) {  
                         mulnum(0,eval(BDY(n1)),eval(BDY(n2)),&c);  
                         n1 = NEXT(n1); n2 = NEXT(n2);  
                 } else {  
                         c = eval(BDY(n1)); n1 = NEXT(n1);  
                 }  
         else if ( fnode_is_number(BDY(n2)) ) {  
                 c = eval(BDY(n2)); n2 = NEXT(n2);  
         } else  
                 c = (Num)ONE;  
         if ( !c ) return mkfnode(1,I_FORMULA,0);          if ( !c ) return mkfnode(1,I_FORMULA,0);
   
         l1 = length(n1);          n1 = (NODE)FA1(to_narymul(b1)); n2 = (NODE)FA1(to_narymul(b2));
         l2 = length(n2);          l1 = length(n1); l = l1+length(n2);
         l = l1+l2;  
         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 )
                         m[i++] = BDY(r);                          m[i++] = BDY(r);
                 else {                  else {
                         fnode_base_exp(m[i-1],&b1,&e1);                          fnode_base_exp(m[i-1],&b1,&e1); fnode_base_exp(BDY(r),&b2,&e2);
                         fnode_base_exp(BDY(r),&b2,&e2);                          if ( compfnode(b1,b2) ) break;
                         if ( compfnode(b1,b2) ) {                          addnum(0,eval(e1),eval(e2),&e);
                                 for ( j = i-1; j >= 0; j-- ) {                          if ( !e ) i--;
                                         MKNODE(r1,m[j],r); r = r1;                          else if ( UNIQ(e) )
                                 }                                  m[i-1] = b1;
                                 cc = mkfnode(1,I_FORMULA,c);                          else
                                 MKNODE(r1,cc,r); r = r1;                                  m[i-1] = mkfnode(3,I_BOP,pwrfs,b1,mkfnode(1,I_FORMULA,e));
                                 return mkfnode(2,I_NARYOP,mulfs,r);  
                         } else {  
                                 addnum(0,eval(e1),eval(e2),&e);  
                                 if ( !e ) i--;  
                                 else if ( UNIQ(e) )  
                                         m[i-1] = b1;  
                                 else  
                                         m[i-1] = mkfnode(3,I_BOP,pwrfs,b1,mkfnode(1,I_FORMULA,e));  
                         }  
                 }                  }
         }          }
         if ( !i ) return mkfnode(1,I_FORMULA,c);          for ( j = i-1; j >= 0; j-- ) {
         else {                  MKNODE(r1,m[j],r); r = r1;
                 r = 0;  
                 for ( j = i-1; j >= 0; j-- ) {  
                         MKNODE(r1,m[j],r); r = r1;  
                 }  
                 cc = mkfnode(1,I_FORMULA,c);  
                 MKNODE(r1,cc,r);  
                 r = r1;  
                 return mkfnode(2,I_NARYOP,mulfs,r);  
         }          }
           if ( !UNIQ(c) ) {
                   cc = mkfnode(1,I_FORMULA,c); MKNODE(r1,cc,r); r = r1;
           }
           return fnode_node_to_narymul(r);
 }  }
   
 FNODE fnode_normalize_pwr(FNODE f1,FNODE f2)  FNODE fnode_normalize_pwr(FNODE f1,FNODE f2)
Line 2332  FNODE fnode_normalize_pwr(FNODE f1,FNODE f2)
Line 2317  FNODE fnode_normalize_pwr(FNODE f1,FNODE f2)
                         return mkfnode(1,I_FORMULA,c);                          return mkfnode(1,I_FORMULA,c);
                 } else                  } else
                         return mkfnode(3,I_BOP,pwrfs,f1,f2);                          return mkfnode(3,I_BOP,pwrfs,f1,f2);
         else if ( f1->id == I_BOP && OPNAME(f1) == '^' ) {          else if ( IS_BINARYPWR(f1) ) {
                 b1 = FA1(f1); e1 = FA2(f1);                  b1 = FA1(f1); e1 = FA2(f1);
                 e = fnode_normalize_mul(e1,f2);                  e = fnode_normalize_mul(e1,f2);
                 if ( fnode_is_one(e) )                  if ( fnode_is_one(e) )
                         return b1;                          return b1;
                 else                  else
                         return mkfnode(3,I_BOP,FA0(f1),b1,e);                          return mkfnode(3,I_BOP,FA0(f1),b1,e);
         } else if ( f1->id == I_NARYOP && OPNAME(f1) == '*' ) {          } else if ( IS_NARYMUL(f1) && fnode_is_integer(f2) ) {
                 fnode_coef_body(f1,&c1,&b1);                  fnode_coef_body(f1,&c1,&b1);
                 if ( fnode_is_integer(f2) ) {                  pwrnum(0,(Num)c1,(Num)eval(f2),&c);
                         pwrnum(0,(Num)c1,(Num)eval(f2),&c);                  cc = mkfnode(1,I_FORMULA,c);
                         cc = mkfnode(1,I_FORMULA,c);                  b = fnode_normalize_pwr(b1,f2);
                         b = fnode_normalize_pwr(b1,f2);                  if ( fnode_is_one(cc) )
                         if ( fnode_is_one(cc) )                          return b;
                                 return b;                  else
                         else {                          return fnode_node_to_narymul(mknode(2,cc,b));
                                 NEWFNODE(r,2);  
                                 r->id = I_NARYOP; FA0(r) = mulfs; FA1(r) = mknode(2,cc,b);  
                                 return r;  
                         }  
                 } else  
                         return mkfnode(3,I_BOP,pwrfs,f1,f2);  
         } else          } else
                 return mkfnode(3,I_BOP,pwrfs,f1,f2);                  return mkfnode(3,I_BOP,pwrfs,f1,f2);
 }  }
Line 2361  FNODE fnode_normalize_pwr(FNODE f1,FNODE f2)
Line 2340  FNODE fnode_normalize_pwr(FNODE f1,FNODE f2)
 /* f = b^e */  /* f = b^e */
 void fnode_base_exp(FNODE f,FNODE *bp,FNODE *ep)  void fnode_base_exp(FNODE f,FNODE *bp,FNODE *ep)
 {  {
         if ( f->id == I_BOP && OPNAME(f) == '^' ) {          if ( IS_BINARYPWR(f) ) {
                 *bp = FA1(f); *ep = FA2(f);                  *bp = FA1(f); *ep = FA2(f);
         } else {          } else {
                 *bp = f; *ep = mkfnode(1,I_FORMULA,ONE);                  *bp = f; *ep = mkfnode(1,I_FORMULA,ONE);
Line 2373  FNODE to_naryadd(FNODE f)
Line 2352  FNODE to_naryadd(FNODE f)
         FNODE r;          FNODE r;
         NODE n;          NODE n;
   
         NEWFNODE(r,2);          if ( IS_NARYADD(f) ) return f;
         r->id = I_NARYOP;  
         FA0(r) = addfs;          NEWFNODE(r,2); r->id = I_NARYOP;
         MKNODE(n,f,0);          FA0(r) = addfs; MKNODE(n,f,0); FA1(r) = n;
         FA1(r) = n;  
         return r;          return r;
 }  }
   
Line 2386  FNODE to_narymul(FNODE f)
Line 2364  FNODE to_narymul(FNODE f)
         FNODE r;          FNODE r;
         NODE n;          NODE n;
   
         NEWFNODE(r,2);          if ( IS_NARYMUL(f) ) return f;
         r->id = I_NARYOP;  
         FA0(r) = mulfs;          NEWFNODE(r,2); r->id = I_NARYOP;
         MKNODE(n,f,0);          FA0(r) = mulfs; MKNODE(n,f,0); FA1(r) = n;
         FA1(r) = n;  
         return r;          return r;
 }  }
   
 FNODE fnode_normalize_mul_coef(Num c,FNODE f)  FNODE fnode_normalize_mul_coef(Num c,FNODE f)
 {  {
         FNODE cc;          FNODE b1,cc,r;
         Num c1,c2;          Num c1,c2;
         NODE n,r0,r;          NODE n;
   
         if ( !c )          if ( !c )
                 return mkfnode(I_FORMULA,0);                  return mkfnode(I_FORMULA,0);
         else if ( UNIQ(c) )          else {
                 return f;                  fnode_coef_body(f,&c1,&b1);
         else if ( fnode_is_number(f) ) {                  mulnum(0,c,c1,&c2);
                 mulnum(0,c,eval(f),&c1); return mkfnode(1,I_FORMULA,c1);                  if ( UNIQ(c2) ) return b1;
         } else if ( f->id == I_NARYOP && OPNAME(f) == '*' ) {                  else {
                 cc = (FNODE)BDY((NODE)FA1(f));                          cc = mkfnode(1,I_FORMULA,c2);
                 if ( fnode_is_number(cc) ) {                          if ( fnode_is_number(b1) ) {
                         mulnum(0,c,eval(cc),&c2);                                  if ( !fnode_is_one(b1) )
                         if ( UNIQ(c2) )                                          error("fnode_normalize_mul_coef : cannot happen");
                                 n = NEXT((NODE)FA1(f));                                  else
                         else {                                          return cc;
                                 cc = mkfnode(1,I_FORMULA,c2);                          } else
                                 MKNODE(n,cc,NEXT((NODE)FA1(f)));                          if ( IS_NARYMUL(b1) ) {
                                   MKNODE(n,cc,FA1(b1));
                           } else {
                                   n = mknode(2,cc,b1);
                         }                          }
                 } else {                          r = fnode_node_to_narymul(n);
                         cc = mkfnode(1,I_FORMULA,c);                          return r;
                         MKNODE(n,cc,(NODE)FA1(f));  
                 }                  }
                 if ( NEXT(n) )  
                         return mkfnode(2,I_NARYOP,FA0(f),n);  
                 else  
                         return (FNODE)BDY(n);  
         } else if ( f->id == I_NARYOP && OPNAME(f) == '+' ) {  
                 for ( r0 = 0, n = (NODE)FA1(f); n; n = NEXT(n) ) {  
                         NEXTNODE(r0,r);  
                         BDY(r) = fnode_normalize_mul_coef(c,BDY(n));  
                 }  
                 if ( r0 ) NEXT(r) = 0;  
                 return mkfnode(2,I_NARYOP,FA0(f),r0);  
         } else {  
                 cc = mkfnode(1,I_FORMULA,c);  
                 n = mknode(2,cc,f);  
                 return mkfnode(2,I_NARYOP,mulfs,n);  
         }          }
 }  }
   
 void fnode_coef_body(FNODE f,Num *cp,FNODE *bp)  void fnode_coef_body(FNODE f,Num *cp,FNODE *bp)
 {  {
         FNODE c;          FNODE c;
         NODE n;  
   
         if ( fnode_is_number(f) ) {          if ( fnode_is_number(f) ) {
                 *cp = eval(f); *bp = mkfnode(1,I_FORMULA,ONE);                  *cp = eval(f); *bp = mkfnode(1,I_FORMULA,ONE);
         } else if ( f->id == I_NARYOP && OPNAME(f) == '*' ) {          } else if ( IS_NARYMUL(f) ) {
                 c = (FNODE)BDY((NODE)FA1(f));                  c=(FNODE)BDY((NODE)FA1(f));
                 if ( fnode_is_number(c) ) {                  if ( fnode_is_number(c) ) {
                         *cp = eval(c);                          *cp = eval(c);
                         n = NEXT((NODE)FA1(f));                          *bp = fnode_node_to_narymul(NEXT((NODE)FA1(f)));
                         if ( !n )  
                                 *bp = mkfnode(1,I_FORMULA,ONE);  
                         else if ( !NEXT(n) )  
                                 *bp = BDY(n);  
                         else  
                                 *bp = mkfnode(2,I_NARYOP,FA0(f),n);  
                 } else {                  } else {
                         *cp = (Num)ONE; *bp = f;                          *cp = (Num)ONE; *bp = f;
                 }                  }
Legend:
Removed from v.1.74  
changed lines
  Added in v.1.75
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>