[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.79 and 1.87

version 1.79, 2005/10/19 10:31:18 version 1.87, 2005/10/31 10:03:48
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.78 2005/10/17 00:38:11 noro Exp $   * $OpenXM: OpenXM_contrib2/asir2000/builtin/strobj.c,v 1.86 2005/10/26 23:43:23 noro Exp $
 */  */
 #include "ca.h"  #include "ca.h"
 #include "parse.h"  #include "parse.h"
Line 87  void Pflatten_quote();
Line 87  void Pflatten_quote();
 void Pquote_is_integer(),Pquote_is_rational(),Pquote_is_number();  void Pquote_is_integer(),Pquote_is_rational(),Pquote_is_number();
 void Pquote_is_dependent(),Pquote_is_function();  void Pquote_is_dependent(),Pquote_is_function();
 void Pquote_normalize();  void Pquote_normalize();
   void Pquote_normalize_comp();
   
 void Pquote_to_funargs(),Pfunargs_to_quote(),Pget_function_name();  void Pquote_to_funargs(),Pfunargs_to_quote(),Pget_function_name();
 void Pquote_unify(),Pget_quote_id(),Pquote_match_rewrite();  void Pquote_unify(),Pget_quote_id(),Pquote_match_rewrite();
Line 126  struct ftab str_tab[] = {
Line 127  struct ftab str_tab[] = {
         {"quote_is_dependent",Pquote_is_dependent,2},          {"quote_is_dependent",Pquote_is_dependent,2},
   
         {"quote_normalize",Pquote_normalize,-2},          {"quote_normalize",Pquote_normalize,-2},
           {"quote_normalize_comp",Pquote_normalize_comp,2},
   
         {"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 1940  void Pquote_normalize(NODE arg,QUOTE *rp)
Line 1942  void Pquote_normalize(NODE arg,QUOTE *rp)
         if ( !q || OID(q) != O_QUOTE ) {          if ( !q || OID(q) != O_QUOTE ) {
                 *rp = q;                  *rp = q;
                 return;                  return;
         } else {          } else if ( q->normalized && (q->expanded || !expand) )
                   *rp = q;
           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;
         }          }
 }  }
   
   void Pquote_normalize_comp(NODE arg,Q *rp)
   {
           QUOTE q1,q2;
           FNODE f1,f2;
           int r;
   
           q1 = (QUOTE)ARG0(arg); f1 = (FNODE)BDY(q1);
           q2 = (QUOTE)ARG1(arg); f2 = (FNODE)BDY(q2);
           if ( !q1->normalized ) f1 = fnode_normalize(f1,0);
           if ( !q2->normalized ) f2 = fnode_normalize(f2,0);
           r = fnode_normalize_comp(f1,f2);
           STOQ(r,*rp);
   }
   
 int fnode_is_number(FNODE f)  int fnode_is_number(FNODE f)
 {  {
         Obj obj;          Obj obj;
Line 2215  FNODE fnode_normalize_add(FNODE f1,FNODE f2,int expand
Line 2235  FNODE fnode_normalize_add(FNODE f1,FNODE f2,int expand
         r0 = 0;          r0 = 0;
         while ( n1 && n2 ) {          while ( n1 && n2 ) {
                 fnode_coef_body(BDY(n1),&c1,&b1); fnode_coef_body(BDY(n2),&c2,&b2);                  fnode_coef_body(BDY(n1),&c1,&b1); fnode_coef_body(BDY(n2),&c2,&b2);
                 if ( (s = compfnode(b1,b2)) > 0 ) {                  if ( (s = fnode_normalize_comp(b1,b2)) > 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);
Line 2349  FNODE fnode_normalize_pwr(FNODE f1,FNODE f2,int expand
Line 2369  FNODE fnode_normalize_pwr(FNODE f1,FNODE f2,int expand
                         return b;                          return b;
                 else                  else
                         return fnode_node_to_narymul(mknode(2,cc,b));                          return fnode_node_to_narymul(mknode(2,cc,b));
         } else if ( expand && fnode_is_nonnegative_integer(f2) ) {          } else if ( expand && fnode_is_integer(f2)
                           && fnode_is_nonnegative_integer(f2) ) {
                 q = (Q)eval(f2);                  q = (Q)eval(f2);
                 if ( PL(NM(q)) > 1 ) error("fnode_normalize_pwr : exponent too large");                  if ( PL(NM(q)) > 1 ) error("fnode_normalize_pwr : exponent too large");
                 return fnode_expand_pwr(f1,QTOS(q));                  return fnode_expand_pwr(f1,QTOS(q));
Line 2461  void fnode_coef_body(FNODE f,Num *cp,FNODE *bp)
Line 2482  void fnode_coef_body(FNODE f,Num *cp,FNODE *bp)
                 *cp = (Num)ONE; *bp = f;                  *cp = (Num)ONE; *bp = f;
         }          }
 }  }
   
   int fnode_normalize_comp_pwr(FNODE f1,FNODE f2);
   
   int fnode_normalize_comp(FNODE f1,FNODE f2)
   {
           NODE n1,n2;
           int r,i1,i2;
           char *nm1,*nm2;
           FNODE b1,b2,e1,e2,g;
           Num ee,ee1,c1,c2;
   
           if ( IS_NARYADD(f1) || IS_NARYADD(f2) ) {
                   f1 = to_naryadd(f1); f2 = to_naryadd(f2);
                   n1 = (NODE)FA1(f1); n2 = (NODE)FA1(f2);
                   while ( n1 && n2 )
                           if ( r = fnode_normalize_comp(BDY(n1),BDY(n2)) ) return r;
                           else {
                                   n1 = NEXT(n1); n2 = NEXT(n2);
                           }
                   return n1?1:(n2?-1:0);
           }
           if ( IS_NARYMUL(f1) || IS_NARYMUL(f2) ) {
                   fnode_coef_body(f1,&c1,&b1);
                   fnode_coef_body(f2,&c2,&b2);
                   if ( !compfnode(b1,b2) ) return compnum(0,c1,c2);
                   b1 = to_narymul(b1); b2 = to_narymul(b2);
                   n1 = (NODE)FA1(b1); n2 = (NODE)FA1(b2);
                   while ( 1 ) {
                           while ( n1 && n2 && !compfnode(BDY(n1),BDY(n2)) ) {
                                   n1 = NEXT(n1); n2 = NEXT(n2);
                           }
                           if ( !n1 || !n2 ) {
                                   return n1?1:(n2?-1:0);
                           }
                           fnode_base_exp(BDY(n1),&b1,&e1);
                           fnode_base_exp(BDY(n2),&b2,&e2);
   
                           if ( r = fnode_normalize_comp(b1,b2) ) {
                                   if ( r > 0 )
                                           return fnode_normalize_comp(e1,mkfnode(1,I_FORMULA,0));
                                   else if ( r < 0 )
                                           return fnode_normalize_comp(mkfnode(1,I_FORMULA,0),e2);
                           } else {
                                   n1 = NEXT(n1); n2 = NEXT(n2);
                                   if ( fnode_is_number(e1) && fnode_is_number(e2) ) {
                                           /* f1 = t b^e1 ... , f2 = t b^e2 ... */
                                           subnum(0,eval(e1),eval(e2),&ee);
                                           r = compnum(0,ee,0);
                                           if ( r > 0 ) {
                                                   g = mkfnode(3,I_BOP,pwrfs,b1,mkfnode(1,I_FORMULA,ee));
                                                   MKNODE(n1,g,n1);
                                           } else if ( r < 0 ) {
                                                   chsgnnum(ee,&ee1);
                                                   g = mkfnode(3,I_BOP,pwrfs,b1,mkfnode(1,I_FORMULA,ee1));
                                                   MKNODE(n2,g,n2);
                                           }
                                   } else {
                                           r = fnode_normalize_comp(e1,e2);
                                           if ( r > 0 ) return 1;
                                           else if ( r < 0 ) return -1;
                                   }
                           }
                   }
           }
           if ( IS_BINARYPWR(f1) || IS_BINARYPWR(f2) )
                   return fnode_normalize_comp_pwr(f1,f2);
   
           /* now, IDs of f1 and f2 must be I_FORMULA, I_FUNC, or I_PVAR */
           switch ( f1->id ) {
                   case I_FORMULA:
                           switch ( f2->id ) {
                                   case I_FORMULA:
                                           return arf_comp(CO,FA0(f1),FA0(f2));
                                   case I_FUNC: case I_PVAR:
                                           return -1;
                                   default:
                                           error("fnode_normalize_comp : undefined");
                           }
                           break;
                   case I_FUNC:
                           switch ( f2->id ) {
                                   case I_FORMULA:
                                           return 1;
                                   case I_FUNC:
                                           nm1 = ((FUNC)FA0(f1))->name; nm2 = ((FUNC)FA0(f2))->name;
                                           r = strcmp(nm1,nm2);
                                           if ( r > 0 ) return 1;
                                           else if ( r < 0 ) return -1;
                                           else {
                                                   /* compare args */
                                                   n1 = FA0((FNODE)FA1(f1)); n2 = FA0((FNODE)FA1(f2));
                                                   while ( n1 && n2 )
                                                           if ( r = fnode_normalize_comp(BDY(n1),BDY(n2)) ) return r;
                                                           else {
                                                                   n1 = NEXT(n1); n2 = NEXT(n2);
                                                           }
                                                   return n1?1:(n2?-1:0);
                                           }
                                           break;
                                   case I_PVAR:
                                           return -1;
                                   default:
                                           error("fnode_normalize_comp : undefined");
                           }
                   case I_PVAR:
                           switch ( f2->id ) {
                                   case I_FORMULA: case I_FUNC:
                                           return 1;
                                   case I_PVAR:
                                           i1 = (int)FA0(f1); i2 = (int)FA0(f2);
                                           if ( i1 > i2 ) return 1;
                                           else if ( i1 < i2 ) return -1;
                                           else return 0;
                                   default:
                                           error("fnode_normalize_comp : undefined");
                           }
                           break;
                   default:
                           error("fnode_normalize_comp : undefined");
           }
   }
   
   int fnode_normalize_comp_pwr(FNODE f1,FNODE f2)
   {
           FNODE b1,b2,e1,e2;
           int r;
   
           fnode_base_exp(f1,&b1,&e1);
           fnode_base_exp(f2,&b2,&e2);
           if ( r = fnode_normalize_comp(b1,b2) ) {
                   if ( r > 0 )
                           return fnode_normalize_comp(e1,mkfnode(1,I_FORMULA,0));
                   else if ( r < 0 )
                           return fnode_normalize_comp(mkfnode(1,I_FORMULA,0),e2);
           } else return fnode_normalize_comp(e1,e2);
   }
   
   int fnode_normalize_unify(FNODE f,FNODE pat,NODE *rp)
   {
           NODE m,m1,m2,base,exp,fa,pa,n;
           LIST l;
           QUOTE qp,qf;
           FNODE fbase,fexp;
           FUNC ff,pf;
           int r;
   
           switch ( pat->id ) {
                   case I_PVAR:
                           /* [[pat,f]] */
                           MKQUOTE(qf,f);
                           MKQUOTE(qp,pat);
                           n = mknode(2,qp,qf); MKLIST(l,n);
                           *rp =  mknode(1,l);
                           return 1;
   
                   case I_FORMULA:
                           if ( !arf_comp(CO,(Obj)FA0(f),(Obj)FA0(pat)) ) {
                                   *rp = 0; return 1;
                           } else
                                   return 0;
   
                   case I_BOP:
                           /* OPNAME should be "^" */
                           if ( !IS_BINARYPWR(pat) )
                                   error("fnode_normalize_unify : invalid BOP");
                           if ( IS_BINARYPWR(f) ) {
                                   fbase = FA1(f); fexp = FA2(f);
                           } else {
                                   fbase = f; fexp = mkfnode(1,I_FORMULA,ONE);
                           }
                           r = fnode_normalize_unify(fbase,FA1(pat),&base);
                           if ( !r ) return 0;
                           r = fnode_normalize_unify(fexp,FA2(pat),&exp);
                           if ( !r ) return 0;
                           else return merge_matching_node(base,exp,rp);
                           break;
   
                   case I_FUNC:
                           if ( f->id != I_FUNC ) return 0;
                           ff = (FUNC)FA0(f); pf = (FUNC)FA0(pat);
                           if ( strcmp(ff->fullname,pf->fullname) ) return 0;
                           /* FA1(f) and FA1(pat) are I_LIST */
                           fa = (NODE)FA0((FNODE)FA1(f));
                           pa = (NODE)FA0((FNODE)FA1(pat));
                           m = 0;
                           while ( fa && pa ) {
                                   r = fnode_normalize_unify(BDY(fa),BDY(pa),&m1);
                                   if ( !r ) return 0;
                                   r = merge_matching_node(m,m1,&m2);
                                   if ( !r ) return 0;
                                   else m = m2;
                           }
                           if ( fa || pa ) return 0;
                           else {
                                   *rp = m;
                                   return 1;
                           }
   
                   case I_NARYOP:
                           if ( IS_NARYADD(pat) )
                                   return fnode_normalize_unify_naryadd(f,pat,rp);
                           else if ( IS_NARYMUL(pat) )
                                   return fnode_normalize_unify_narymul(f,pat,rp);
                           else
                                   error("fnode_normalize_unify : invalid NARYOP");
                           break;
   
                   default:
                           error("fnode_normalize_unify : invalid pattern");
           }
   }
   
   int fnode_normalize_unify_naryadd(FNODE f,FNODE pat,NODE *rp){}
   
   int fnode_normalize_unify_narymul(FNODE f,FNODE pat,NODE *rp){}
   
   /*
   int fnode_normalize_unify_naryadd(FNODE f,FNODE pat,NODE *rp)
   {
           int lf,lp;
   
           f = to_naryadd(f);
           lf = length((NODE)FA1(f));
           lp = length((NODE)FA1(pat));
           if ( lf < lp ) return 0;
           else if ( lp == 1 ) {
                   if ( lf == 1 )
                           return fnode_normalize_unify(
                                   BDY((NODE)FA1(f)),BDY((NODE)FA1(pat)),rp);
                   else
                           return 0;
           } else {
                   sel = (int *)ALLOCA(lf);
           }
   }
   */
   
Legend:
Removed from v.1.79  
changed lines
  Added in v.1.87
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>