Changeset e5c9e5 in git


Ignore:
Timestamp:
Mar 5, 2013, 4:43:58 PM (10 years ago)
Author:
Hans Schoenemann <hannes@…>
Branches:
(u'jengelh-datetime', 'ceac47cbc86fe4a15902392bdbb9bd2ae0ea02c6')(u'spielwiese', '5a0dde71de01068fad5736a17555c993ecbbf495')
Children:
803cb2d20d4037b513adf020767d48f6893fc9a2
Parents:
161e20729b9213f0aaa51ebeacdbd63260916ff6
Message:
fix: normalization for trans. ext.
Location:
libpolys/polys
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • libpolys/polys/ext_fields/transext.cc

    r161e20 re5c9e5  
    152152    assume( _p_Test(den, ntRing,1) );
    153153
    154     if(p_IsConstant(den, ntRing) && (n_IsOne(pGetCoeff(den), ntRing->cf)))
     154    if(p_IsConstant(den, ntRing) && (n_IsOne(pGetCoeff(den), ntCoeffs)))
    155155    {
    156156      Print("?/1 in %s:%d\n",f,l);
     
    158158    }
    159159
    160     if( !n_GreaterZero(pGetCoeff(den), ntRing->cf) )
     160    if( !n_GreaterZero(pGetCoeff(den), ntCoeffs) )
    161161    {
    162162      Print("negative sign of DEN. of a fraction in %s:%d\n",f,l);
     
    300300
    301301
    302     n_ClearDenominators(itr, g, ntRing->cf);
    303 
    304     if( !n_GreaterZero(g, ntRing->cf) )
     302    n_ClearDenominators(itr, g, ntCoeffs);
     303
     304    if( !n_GreaterZero(g, ntCoeffs) )
    305305    {
    306306      NUM (f) = p_Neg(NUM (f), ntRing); // Ugly :(((
    307       g = n_Neg(g, ntRing->cf);
     307      g = n_Neg(g, ntCoeffs);
    308308    }
    309309
    310310    // g should be a positive integer now!
    311     assume( n_GreaterZero(g, ntRing->cf) );
    312 
    313     if( !n_IsOne(g, ntRing->cf) )
     311    assume( n_GreaterZero(g, ntCoeffs) );
     312
     313    if( !n_IsOne(g, ntCoeffs) )
    314314    {
    315315      DEN (f) = p_NSet(g, ntRing); // update COM(f)???
     
    318318    }
    319319    else
    320       n_Delete(&g, ntRing->cf);
     320      n_Delete(&g, ntCoeffs);
    321321
    322322    ntTest(a);
     
    386386  CPolyCoeffsEnumerator itr(NUM(f));
    387387
    388   n_ClearDenominators(itr, g, ntRing->cf); // may return -1 :(((
    389 
    390   if( !n_GreaterZero(g, ntRing->cf) )
     388  n_ClearDenominators(itr, g, ntCoeffs); // may return -1 :(((
     389
     390  if( !n_GreaterZero(g, ntCoeffs) )
    391391  {
    392392//     NUM (f) = p_Neg(NUM (f), ntRing); // Ugly :(((
    393 //     g = n_Neg(g, ntRing->cf);
     393//     g = n_Neg(g, ntCoeffs);
    394394    NUM (f) = p_Neg(NUM (f), ntRing); // Ugly :(((
    395     g = n_Neg(g, ntRing->cf);
     395    g = n_Neg(g, ntCoeffs);
    396396  }
    397397
    398398  // g should be a positive integer now!
    399   assume( n_GreaterZero(g, ntRing->cf) );
    400 
    401   if( !n_IsOne(g, ntRing->cf) )
    402   {
    403     assume( n_GreaterZero(g, ntRing->cf) );
    404     assume( !n_IsOne(g, ntRing->cf) );
     399  assume( n_GreaterZero(g, ntCoeffs) );
     400
     401  if( !n_IsOne(g, ntCoeffs) )
     402  {
     403    assume( n_GreaterZero(g, ntCoeffs) );
     404    assume( !n_IsOne(g, ntCoeffs) );
    405405
    406406    DEN (f) = p_NSet(g, ntRing); // update COM(f)???
     
    413413  { // common denom == 1?
    414414    NUM (result)= p_NSet(g, ntRing); // p_Copy (DEN (f), ntRing);
    415 //  n_Delete(&g, ntRing->cf);
     415//  n_Delete(&g, ntCoeffs);
    416416  }
    417417
     
    419419//    else
    420420//      g= p_GetAllDenom (num, ntRing);
    421 //    result= (fraction) ntSetMap (ntRing->cf, cf) (g, ntRing->cf, cf);
     421//    result= (fraction) ntSetMap (ntCoeffs, cf) (g, ntCoeffs, cf);
    422422
    423423  ntTest((number)result);
     
    533533  if (p == NULL) return NULL;
    534534
     535  fraction f = (fraction)omAlloc0Bin(fractionObjectBin);
     536
     537  if (nCoeff_is_Q(ntCoeffs))
     538  {
    535539    number g;
    536540    // TODO/NOTE: the following should not be necessary (due to
    537541    // Hannes!) as NUM (f) should be over Z!!!
     542    // but it is not: normalize it
    538543    CPolyCoeffsEnumerator itr(p);
    539544
    540     n_ClearDenominators(itr, g, ntRing->cf);
    541 
    542     if( !n_GreaterZero(g, ntRing->cf) )
    543     {
    544       p = p_Neg(p, ntRing); // Ugly :(((
    545       g = n_Neg(g, ntRing->cf);
     545    n_ClearDenominators(itr, g, ntCoeffs);
     546
     547    if( !n_GreaterZero(g, ntCoeffs) )
     548    {
     549      p = p_Neg(p, ntRing);
     550      g = n_Neg(g, ntCoeffs);
    546551    }
    547552
    548553    // g should be a positive integer now!
    549     assume( n_GreaterZero(g, ntRing->cf) );
    550 
    551     fraction f = (fraction)omAlloc0Bin(fractionObjectBin);
    552 
    553     if( !n_IsOne(g, ntRing->cf) )
     554    assume( n_GreaterZero(g, ntCoeffs) );
     555
     556    if( !n_IsOne(g, ntCoeffs) )
    554557    {
    555558      DEN (f) = p_NSet(g, ntRing);
    556 //      COM (f) ++; // update COM(f)???
    557559      assume( DEN (f) != NULL );
    558560    }
    559561    else
    560562    {
    561       DEN(f) = NULL;
    562       n_Delete(&g, ntRing->cf);
    563     }
    564 
    565     NUM(f) = p;
    566     COM(f) = 0;
    567 
    568     ntTest((number)f);
    569     return (number)f;
     563      //DEN(f) = NULL; // done by omAlloc0
     564      n_Delete(&g, ntCoeffs);
     565    }
     566  }
     567
     568  NUM(f) = p;
     569  COM(f) = 0;
     570
     571  ntTest((number)f);
     572  return (number)f;
    570573}
    571574
     
    633636  number aa;
    634637  number bb;
    635   if (bDenCoeff==NULL) aa=n_Copy(aNumCoeff,ntRing->cf);
    636   else                 aa=n_Mult(aNumCoeff,bDenCoeff,ntRing->cf);
    637   if (aDenCoeff==NULL) bb=n_Copy(bNumCoeff,ntRing->cf);
    638   else                 bb=n_Mult(bNumCoeff,aDenCoeff,ntRing->cf);
     638  if (bDenCoeff==NULL) aa=n_Copy(aNumCoeff,ntCoeffs);
     639  else                 aa=n_Mult(aNumCoeff,bDenCoeff,ntCoeffs);
     640  if (aDenCoeff==NULL) bb=n_Copy(bNumCoeff,ntCoeffs);
     641  else                 bb=n_Mult(bNumCoeff,aDenCoeff,ntCoeffs);
    639642  BOOLEAN rr= n_Greater(aa, bb, ntCoeffs);
    640   n_Delete(&aa,ntRing->cf);
    641   n_Delete(&bb,ntRing->cf);
     643  n_Delete(&aa,ntCoeffs);
     644  n_Delete(&bb,ntCoeffs);
    642645  return rr;
    643646}
     
    849852  fraction result = (fraction)omAlloc0Bin(fractionObjectBin);
    850853  NUM(result) = g;
    851   if (!n_GreaterZero(pGetCoeff(f),ntRing->cf))
     854  if (!n_GreaterZero(pGetCoeff(f),ntCoeffs))
    852855  {
    853856    g=p_Neg(g,ntRing);
     
    855858    NUM(result) = g;
    856859  }
    857   if (!p_IsConstant(f,ntRing) || !n_IsOne(pGetCoeff(f),ntRing->cf))
     860  if (!p_IsConstant(f,ntRing) || !n_IsOne(pGetCoeff(f),ntCoeffs))
    858861  {
    859862    DEN(result) = f;
     
    12821285    definiteGcdCancellation(a, cf, FALSE);
    12831286    if ((DEN(a)!=NULL)
    1284     &&(!n_GreaterZero(pGetCoeff(DEN(a)),ntRing->cf)))
     1287    &&(!n_GreaterZero(pGetCoeff(DEN(a)),ntCoeffs)))
    12851288    {
    12861289      NUM(a)=p_Neg(NUM(a),ntRing);
     
    14501453  {
    14511454    poly num_f=NUM(f);
    1452     BOOLEAN neg= !n_GreaterZero(pGetCoeff(num_f),ntRing->cf);
     1455    BOOLEAN neg= !n_GreaterZero(pGetCoeff(num_f),ntCoeffs);
    14531456    if (neg)
    14541457    {
  • libpolys/polys/monomials/p_polys.cc

    r161e20 re5c9e5  
    20612061    assume( pNext(ph) != NULL );
    20622062#if CLEARENUMERATORS
    2063     if( nCoeff_is_Q(r->cf) || nCoeff_is_Q_a(r->cf) )
     2063    if( nCoeff_is_Q(r->cf) )
    20642064    {
    20652065      // experimentall (recursive enumerator treatment) of alg. Ext!
     
    21112111        //  StringSetS("** div0:");nWrite(pGetCoeff(p));StringAppendS("/");
    21122112        //  nWrite(h);StringAppendS("=");nWrite(d);StringAppendS(" int:");
    2113         //  nWrite(tmp);Print(StringEndS("\n")); // NOTE/TODO: use StringAppendS("\n"); omFree(s); 
     2113        //  nWrite(tmp);Print(StringEndS("\n")); // NOTE/TODO: use StringAppendS("\n"); omFree(s);
    21142114        //}
    21152115        //nDelete(&tmp);
     
    24242424        //  StringSetS("** div0:");nWrite(pGetCoeff(p));StringAppendS("/");
    24252425        //  nWrite(h);StringAppendS("=");nWrite(d);StringAppendS(" int:");
    2426         //  nWrite(tmp);Print(StringEndS("\n")); // NOTE/TODO: use StringAppendS("\n"); omFree(s); 
     2426        //  nWrite(tmp);Print(StringEndS("\n")); // NOTE/TODO: use StringAppendS("\n"); omFree(s);
    24272427        //}
    24282428        //nDelete(&tmp);
     
    24452445/* ---------------------------------------------------------------------------*/
    24462446/* cleardenom suff                                                           */
    2447 poly p_Cleardenom(poly ph, const ring r)
    2448 {
    2449   if( ph == NULL )
     2447poly p_Cleardenom(poly p, const ring r)
     2448{
     2449  if( p == NULL )
    24502450    return NULL;
    24512451
     
    24552455  if( 0 )
    24562456  {
    2457     CPolyCoeffsEnumerator itr(ph);
     2457    CPolyCoeffsEnumerator itr(p);
    24582458
    24592459    n_ClearDenominators(itr, C);
     
    24612461    n_ClearContent(itr, C); // divide out the content
    24622462
    2463     p_Test(ph, r); n_Test(pGetCoeff(ph), C);
    2464     assume(n_GreaterZero(pGetCoeff(ph), C)); // ??
    2465 //    if(!n_GreaterZero(pGetCoeff(ph),C)) ph = p_Neg(ph,r);
    2466 
    2467     return ph;
    2468   }
    2469 #endif
    2470 
    2471   poly start=ph;
     2463    p_Test(p, r); n_Test(pGetCoeff(p), C);
     2464    assume(n_GreaterZero(pGetCoeff(p), C)); // ??
     2465//    if(!n_GreaterZero(pGetCoeff(p),C)) p = p_Neg(p,r);
     2466
     2467    return p;
     2468  }
     2469#endif
     2470
     2471  poly start=p;
    24722472
    24732473  number d, h;
    2474   poly p;
    24752474
    24762475#ifdef HAVE_RINGS
    24772476  if (rField_is_Ring(r))
    24782477  {
    2479     p_Content(ph,r);
    2480     assume( n_GreaterZero(pGetCoeff(ph),C) );
    2481     if(!n_GreaterZero(pGetCoeff(ph),C)) ph = p_Neg(ph,r);
     2478    p_Content(p,r);
     2479    assume( n_GreaterZero(pGetCoeff(p),C) );
     2480    if(!n_GreaterZero(pGetCoeff(p),C)) p = p_Neg(p,r);
    24822481    return start;
    24832482  }
     
    24862485  if (rField_is_Zp(r) && TEST_OPT_INTSTRATEGY)
    24872486  {
    2488     if(!n_GreaterZero(pGetCoeff(ph),C)) ph = p_Neg(ph,r);
     2487    if(!n_GreaterZero(pGetCoeff(p),C)) p = p_Neg(p,r);
    24892488    return start;
    24902489  }
    2491   p = ph;
    24922490
    24932491  assume(p != NULL);
     
    25112509      p_SetCoeff(p,n_Init(1,r->cf),r);
    25122510
    2513     assume( n_GreaterZero(pGetCoeff(ph),C) );
    2514     if(!n_GreaterZero(pGetCoeff(ph),C)) ph = p_Neg(ph,r);
     2511    assume( n_GreaterZero(pGetCoeff(p),C) );
     2512    if(!n_GreaterZero(pGetCoeff(p),C)) p = p_Neg(p,r);
    25152513
    25162514    return start;
     
    25212519#if 0 && CLEARENUMERATORS
    25222520//CF: does not seem to work that well..
    2523  
     2521
    25242522  if( nCoeff_is_Q(C) || nCoeff_is_Q_a(C) )
    25252523  {
    2526     CPolyCoeffsEnumerator itr(ph);
     2524    CPolyCoeffsEnumerator itr(p);
    25272525
    25282526    n_ClearDenominators(itr, C);
     
    25302528    n_ClearContent(itr, C); // divide out the content
    25312529
    2532     p_Test(ph, r); n_Test(pGetCoeff(ph), C);
    2533     assume(n_GreaterZero(pGetCoeff(ph), C)); // ??
    2534 //    if(!n_GreaterZero(pGetCoeff(ph),C)) ph = p_Neg(ph,r);
     2530    p_Test(p, r); n_Test(pGetCoeff(p), C);
     2531    assume(n_GreaterZero(pGetCoeff(p), C)); // ??
     2532//    if(!n_GreaterZero(pGetCoeff(p),C)) p = p_Neg(p,r);
    25352533
    25362534    return start;
     
    25522550    if(!n_IsOne(h,r->cf))
    25532551    {
    2554       p = ph;
     2552      p = start;
    25552553      while (p!=NULL)
    25562554      {
     
    25722570      }
    25732571      n_Delete(&h,r->cf);
    2574       if (n_GetChar(r->cf)==1)
    2575       {
    2576         loop
    2577         {
    2578           h = n_Init(1,r->cf);
    2579           p=ph;
    2580           while (p!=NULL)
    2581           {
    2582             d=n_Lcm(h,pGetCoeff(p),r->cf);
    2583             n_Delete(&h,r->cf);
    2584             h=d;
    2585             pIter(p);
    2586           }
    2587           /* contains the 1/lcm of all denominators */
    2588           if(!n_IsOne(h,r->cf))
    2589           {
    2590             p = ph;
    2591             while (p!=NULL)
    2592             {
    2593               /* should be:
    2594               * number hh;
    2595               * nGetDenom(p->coef,&hh);
    2596               * nMult(&h,&hh,&d);
    2597               * nNormalize(d);
    2598               * nDelete(&hh);
    2599               * nMult(d,p->coef,&hh);
    2600               * nDelete(&d);
    2601               * nDelete(&(p->coef));
    2602               * p->coef =hh;
    2603               */
    2604               d=n_Mult(h,pGetCoeff(p),r->cf);
    2605               n_Normalize(d,r->cf);
    2606               p_SetCoeff(p,d,r);
    2607               pIter(p);
    2608             }
    2609             n_Delete(&h,r->cf);
    2610           }
    2611           else
    2612           {
    2613             n_Delete(&h,r->cf);
    2614             break;
    2615           }
    2616         }
    2617       }
    26182572    }
    26192573    if (h!=NULL) n_Delete(&h,r->cf);
    2620 
    2621     p_Content(ph,r);
     2574    p=start;
     2575
     2576    p_Content(p,r);
    26222577#ifdef HAVE_RATGRING
    26232578    if (rIsRatGRing(r))
    26242579    {
    26252580      /* quick unit detection in the rational case is done in gr_nc_bba */
    2626       pContentRat(ph);
    2627       start=ph;
    2628     }
    2629 #endif
    2630   }
    2631 
    2632   assume( n_GreaterZero(pGetCoeff(ph),C) );
    2633   if(!n_GreaterZero(pGetCoeff(ph),C)) ph = p_Neg(ph,r);
     2581      pContentRat(p);
     2582      start=p;
     2583    }
     2584#endif
     2585  }
     2586
     2587  assume( n_GreaterZero(pGetCoeff(p),C) );
     2588  if(!n_GreaterZero(pGetCoeff(p),C)) p = p_Neg(p,r);
    26342589
    26352590  return start;
     
    28442799    assume( n_GreaterZero(pGetCoeff(ph),C) );
    28452800    if(!n_GreaterZero(pGetCoeff(ph),C)) ph = p_Neg(ph,r);
    2846     return; 
     2801    return;
    28472802  }
    28482803  p = ph;
Note: See TracChangeset for help on using the changeset viewer.