Changeset d9ff1b in git


Ignore:
Timestamp:
Aug 7, 2009, 3:55:21 PM (14 years ago)
Author:
Hans Schönemann <hannes@…>
Branches:
(u'spielwiese', '91fdef05f09f54b8d58d92a472e9c4a43aa4656f')
Children:
47b2b2d4786e5e56325d65b21c6f1f85c064cf69
Parents:
b87da29e3432134ed69cb9775567c9df1a4b2b5e
Message:
*hannes: naAdd, naSub


git-svn-id: file:///usr/local/Singular/svn/trunk@12053 2c84dea3-7e68-4137-9b89-c4e89433aadc
Location:
kernel
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • kernel/longalg.cc

    rb87da2 rd9ff1b  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: longalg.cc,v 1.43 2009-08-07 11:13:40 Singular Exp $ */
     4/* $Id: longalg.cc,v 1.44 2009-08-07 13:55:21 Singular Exp $ */
    55/*
    66* ABSTRACT:   algebraic numbers
     7* convention: A) minpoly==0: n->z, n->n are from Z[a] resp. Z/p[a],
     8*                no common div., L(n->n) >0 (or n->n==NULL)
     9*             B) minpoly!=NULL: n->z from k[a], n->n==NULL
    710*/
    811
    … …  
    513516    if (olds == s)
    514517      i++;
    515     else if (*s == '\0') 
     518    else if (*s == '\0')
    516519    {
    517520      *b = a;
    … …  
    943946    lnumber l = (lnumber) * p;
    944947    if (l==NULL) return;
    945     nap_Delete(&(l->z),r);
    946     nap_Delete(&(l->n),r);
     948    p_Delete(&(l->z),r->algring);
     949    p_Delete(&(l->n),r->algring);
    947950    omFreeBin((ADDRESS)l,  rnumber_bin);
    948951  }
    … …  
    984987{
    985988  *z = NULL;
    986 }
    987 
    988 /*2
    989 *  addition; lu:= la + lb
    990 */
    991 number naAdd(number la, number lb)
    992 {
    993   napoly x, y;
    994   lnumber lu;
    995   lnumber a = (lnumber)la;
    996   lnumber b = (lnumber)lb;
    997   if (a==NULL) return naCopy(lb);
    998   if (b==NULL) return naCopy(la);
    999   omCheckAddrSize(a,sizeof(snumber));
    1000   omCheckAddrSize(b,sizeof(snumber));
    1001   lu = (lnumber)omAllocBin(rnumber_bin);
    1002   if (b->n!=NULL) x = napMultCopy(a->z, b->n);
    1003   else            x = napCopy(a->z);
    1004   if (a->n!=NULL) y = napMultCopy(b->z, a->n);
    1005   else            y = napCopy(b->z);
    1006   lu->z = napAdd(x, y);
    1007   if (lu->z==NULL)
    1008   {
    1009     omFreeBin((ADDRESS)lu,  rnumber_bin);
    1010     return (number)NULL;
    1011   }
    1012   if (a->n!=NULL)
    1013   {
    1014     if (b->n!=NULL) x = napMultCopy(a->n, b->n);
    1015     else            x = napCopy(a->n);
    1016   }
    1017   else
    1018   {
    1019     if (b->n!=NULL) x = napCopy(b->n);
    1020     else            x = NULL;
    1021   }
    1022   //if (x!=NULL)
    1023   //{
    1024   //  if (napIsConstant(x))
    1025   //  {
    1026   //    number inv=nacInvers(napGetCoeff(x));
    1027   //    napMultN(lu->z,inv);
    1028   //    n_Delete(&inv,nacRing);
    1029   //    napDelete(&x);
    1030   //  }
    1031   //}
    1032   lu->n = x;
    1033   lu->s = FALSE;
    1034   if (lu->n!=NULL)
    1035   {
    1036      number luu=(number)lu;
    1037      naNormalize(luu);
    1038      lu=(lnumber)luu;
    1039   }
    1040   naTest((number)lu);
    1041   return (number)lu;
    1042 }
    1043 
    1044 /*2
    1045 *  subtraction; r:= la - lb
    1046 */
    1047 number naSub(number la, number lb)
    1048 {
    1049   lnumber lu;
    1050 
    1051   if (lb==NULL) return naCopy(la);
    1052   if (la==NULL)
    1053   {
    1054     lu = (lnumber)naCopy(lb);
    1055     lu->z = napNeg(lu->z);
    1056     return (number)lu;
    1057   }
    1058 
    1059   lnumber a = (lnumber)la;
    1060   lnumber b = (lnumber)lb;
    1061 
    1062   omCheckAddrSize(a,sizeof(snumber));
    1063   omCheckAddrSize(b,sizeof(snumber));
    1064 
    1065   napoly x, y;
    1066   lu = (lnumber)omAllocBin(rnumber_bin);
    1067   if (b->n!=NULL) x = napMultCopy(a->z, b->n);
    1068   else            x = napCopy(a->z);
    1069   if (a->n!=NULL) y = napMult(napCopy(b->z), napCopyNeg(a->n));
    1070   else            y = napCopyNeg(b->z);
    1071   lu->z = napAdd(x, y);
    1072   if (lu->z==NULL)
    1073   {
    1074     omFreeBin((ADDRESS)lu,  rnumber_bin);
    1075     return (number)NULL;
    1076   }
    1077   if (a->n!=NULL)
    1078   {
    1079     if (b->n!=NULL) x = napMultCopy(a->n, b->n);
    1080     else            x = napCopy(a->n);
    1081   }
    1082   else
    1083   {
    1084     if (b->n!=NULL) x = napCopy(b->n);
    1085     else            x = NULL;
    1086   }
    1087   //if (x!=NULL)
    1088   //{
    1089   //  if (napIsConstant(x))
    1090   //  {
    1091   //    number inv=nacInvers(napGetCoeff(x));
    1092   //    napMultN(lu->z,inv);
    1093   //    n_Delete(&inv,nacRing);
    1094   //    napDelete(&x);
    1095   //  }
    1096   //}
    1097   lu->n = x;
    1098   lu->s = FALSE;
    1099   if (lu->n!=NULL)
    1100   {
    1101      number luu=(number)lu;
    1102      naNormalize(luu);
    1103      lu=(lnumber)luu;
    1104   }
    1105   naTest((number)lu);
    1106   return (number)lu;
    1107989}
    1108990
    … …  
    15381420  if (a->n==NULL)
    15391421  {
    1540     if (napIsConstant(a->z)) 
     1422    if (napIsConstant(a->z))
    15411423    {
    15421424#ifdef LDEBUG
    15431425       if (a->z==NULL) return FALSE;
    1544        else 
    1545 #endif 
     1426       else
     1427#endif
    15461428         return nacIsOne(napGetCoeff(a->z));
    15471429    }
    … …  
    16251507  if (a==NULL)  return naCopy(b);
    16261508  if (b==NULL)  return naCopy(a);
    1627  
     1509
    16281510  lnumber x, y;
    16291511  lnumber result = (lnumber)omAlloc0Bin(rnumber_bin);
    … …  
    16491531    napoly rz=napGcd(x->z, y->z);
    16501532    CanonicalForm F, G, R;
    1651     R=convSingTrFactoryP(rz); 
     1533    R=convSingTrFactoryP(rz);
    16521534    napNormalize(x->z);
    1653     F=convSingTrFactoryP(x->z)/R; 
     1535    F=convSingTrFactoryP(x->z)/R;
    16541536    napNormalize(y->z);
    1655     G=convSingTrFactoryP(y->z)/R; 
     1537    G=convSingTrFactoryP(y->z)/R;
    16561538    F = gcd( F, G );
    1657     if (F.isOne()) 
     1539    if (F.isOne())
    16581540      result->z= rz;
    16591541    else
    … …  
    24572339}
    24582340#endif
    2459 
     2341//-------------------------------------------------------------------------
     2342/// static: Normalize: case mipo==0, result: n->z, n->n integer
     2343static void naNormalize_0(number n)
     2344{
     2345  lnumber p = (lnumber) n;
     2346  napoly x = p->z;
     2347  napoly y = p->n;
     2348  if (nacRing->cf->nNormalize!=nDummy2)
     2349  {
     2350    /* collect all denoms from x and multiply x and y by it */
     2351    number n;
     2352    if (y!=NULL)
     2353    {
     2354      n=napLcm(y);
     2355      x=p_Mult_nn(x,n,nacRing); p_Normalize(x,nacRing);
     2356      y=p_Mult_nn(y,n,nacRing); p_Normalize(y,nacRing);
     2357      n_Delete(&n,nacRing);
     2358    }
     2359    /* collect all denoms from x and multiply x and y by it */
     2360    n=napLcm(y);
     2361    x=p_Mult_nn(x,n,nacRing);
     2362    if (y!=NULL)   { y=p_Mult_nn(y,n,nacRing); n_Delete(&n,nacRing); }
     2363    else           y=p_NSet(n,nacRing);
     2364    p->n=y;
     2365    // normalize all coeffs in x
     2366    p_Normalize(x,nacRing);
     2367    // normalize all coeffs in y
     2368    p_Normalize(y,nacRing);
     2369  }
     2370}
     2371/// return la+li
     2372number  naAdd(number la, number lb)               /* lu := la+lb */
     2373{
     2374  napoly x, y;
     2375  lnumber lu;
     2376  lnumber a = (lnumber)la;
     2377  lnumber b = (lnumber)lb;
     2378  if (a==NULL) return naCopy(lb);
     2379  if (b==NULL) return naCopy(la);
     2380  omCheckAddrSize(a,sizeof(snumber));
     2381  omCheckAddrSize(b,sizeof(snumber));
     2382  lu = (lnumber)omAllocBin(rnumber_bin);
     2383  if (b->n!=NULL) x = pp_Mult_qq(a->z, b->n, nacRing);
     2384  else            x = p_Copy(a->z,nacRing);
     2385  if (a->n!=NULL) y = pp_Mult_qq(b->z, a->n,nacRing);
     2386  else            y = p_Copy(b->z,nacRing);
     2387  lu->z = p_Add_q(x, y,nacRing);
     2388  if (lu->z==NULL)
     2389  {
     2390    omFreeBin((ADDRESS)lu,  rnumber_bin);
     2391    return (number)NULL;
     2392  }
     2393  if (a->n!=NULL)
     2394  {
     2395    if (b->n!=NULL) x = pp_Mult_qq(a->n, b->n,nacRing);
     2396    else            x = p_Copy(a->n,nacRing);
     2397  }
     2398  else
     2399  {
     2400    if (b->n!=NULL) x = p_Copy(b->n,nacRing);
     2401    else            x = NULL;
     2402  }
     2403  lu->n = x;
     2404  lu->s = FALSE;
     2405  if (lu->n!=NULL)
     2406  {
     2407     number luu=(number)lu;
     2408     naNormalize_0(luu);
     2409     lu=(lnumber)luu;
     2410  }
     2411  naTest((number)lu);
     2412  return (number)lu;
     2413}
     2414
     2415/// return la -lb
     2416number  naSub(number la, number lb)               /* lu := la-lb */
     2417{
     2418  number llb=naCopy(lb);
     2419  llb=naNeg(llb);
     2420  number res=naAdd(la,llb);
     2421  naDelete(&llb,currRing);
     2422  return res;
     2423}

  • kernel/longalg.h

    rb87da2 rd9ff1b  
    44*  Computer Algebra System SINGULAR     *
    55****************************************/
    6 /* $Id: longalg.h,v 1.13 2009-08-07 11:13:40 Singular Exp $ */
     6/* $Id: longalg.h,v 1.14 2009-08-07 13:55:21 Singular Exp $ */
    77/*
    88* ABSTRACT:   algebraic numbers
    … …  
    7979#define napSetExp(p,i,e)       (p_SetExp(p,i,e,currRing->algring))
    8080#define napDelete(p)           p_Delete(p, currRing->algring)
    81 #define nap_Delete(p,r)        p_Delete(p, (r)->algring)
    8281#define napNew()               (p_Init(currRing->algring))
    8382#define napAdd(p1,p2)          (p_Add_q(p1,p2,currRing->algring))
Note: See TracChangeset for help on using the changeset viewer.