Changeset f9b112 in git


Ignore:
Timestamp:
Nov 30, 2014, 2:55:22 AM (9 years ago)
Author:
Oleksandr Motsak <motsak@…>
Branches:
(u'spielwiese', 'fe61d9c35bf7c61f2b6cbf1b56e25e2f08d536cc')
Children:
0ab2c4c1fc27408db639cea5d0dd682f902463b4
Parents:
e1419f3535e85a849df97ea435b49ca0b2caf946
git-author:
Oleksandr Motsak <motsak@mathematik.uni-kl.de>2014-11-30 02:55:22+01:00
git-committer:
Oleksandr Motsak <motsak@mathematik.uni-kl.de>2014-11-30 03:26:48+01:00
Message:
Fix: seg. fault over Q in J7 due to deleted number

add: more debugging assumes
add: FORCE_INLINE for some small static functions
add: myp_Head = p_Head with testing!
+minor things
File:
1 edited

Legend:

Unmodified
Added
Removed

  • Singular/dyn_modules/syzextra/syzextra.cc

    re1419f rf9b112  
    148148};
    149149   
    150 static inline poly pp_Add_qq( const poly a, const poly b, const ring R)
     150static FORCE_INLINE poly pp_Add_qq( const poly a, const poly b, const ring R)
    151151{
    152152  return p_Add_q( p_Copy(a, R), p_Copy(b, R), R );
    153153}
    154154
    155 static inline poly p_VectorProductLT( poly s,  const ideal& L, const ideal& T, const ring& R)
     155static FORCE_INLINE poly p_VectorProductLT( poly s,  const ideal& L, const ideal& T, const ring& R)
    156156{
    157157  assume( IDELEMS(L) == IDELEMS(T) );
    … …  
    183183}
    184184
    185 static inline int atGetInt(idhdl rootRingHdl, const char* attribute, long def)
     185static FORCE_INLINE int atGetInt(idhdl rootRingHdl, const char* attribute, long def)
    186186{
    187187  return ((int)(long)(atGet(rootRingHdl, attribute, INT_CMD, (void*)def)));
    … …  
    451451
    452452
    453 
     453static FORCE_INLINE poly myp_Head(const poly p, const ring r)
     454{
     455 p_Test(p,r);
     456 const poly pp = p_Head(p, r);
     457 p_Test(pp,r);
     458 return pp; 
     459}
     460   
    454461
    455462/// return a new term: leading coeff * leading monomial of p
    … …  
    457464poly leadmonom(const poly p, const ring r, const bool bSetZeroComp)
    458465{
    459   poly m = NULL;
    460 
    461   if( p != NULL )
    462   {
     466  if( UNLIKELY(p == NULL ) )
     467     return NULL;
     468
    463469    assume( p != NULL );
    464470    p_LmTest(p, r);
    465471
    466     m = p_LmInit(p, r);
     472    poly m = p_LmInit(p, r);
    467473    p_SetCoeff0(m, n_Copy(p_GetCoeff(p, r), r), r);
    468474
    469475    if( bSetZeroComp )
    470476      p_SetComp(m, 0, r);
     477   
    471478    p_Setm(m, r);
    472 
    473479
    474480    assume( m != NULL );
    … …  
    478484    if( bSetZeroComp )
    479485      assume( p_GetComp(m, r) == 0 );
    480   }
    481 
     486   
    482487  return m;
    483488}
    … …  
    487492poly p_Tail(const poly p, const ring r)
    488493{
    489   if( p == NULL)
     494  if( UNLIKELY(p == NULL) )
    490495    return NULL;
    491496  else
    … …  
    496501ideal id_Tail(const ideal id, const ring r)
    497502{
    498   if( id == NULL)
     503  if( UNLIKELY(id == NULL) )
    499504    return NULL;
    500505
    … …  
    14411446#if NOPRODUCT
    14421447    syz_2 = m_div.FindReducer(syz_lead, L->m[rr], syz_lead, m_checker);
     1448    p_Test(syz_2, r);
    14431449
    14441450    if( UNLIKELY( __TREEOUTPUT__ ) )
    … …  
    14561462
    14571463    syz_2 = m_div.FindReducer(aa, syz_lead, m_checker);
     1464    p_Test(syz_2, r);
    14581465
    14591466    p_Delete(&aa, r);
    … …  
    15081515    kbTest(bucket);
    15091516    poly t = m_div.FindReducer(spoly, NULL, m_checker);
     1517    p_Test(t, r);
    15101518
    15111519    if( t != NULL )
    … …  
    15861594  assume(m_idTails !=  NULL && m_idTails->m != NULL);
    15871595  assume( tail >= 0 && tail < IDELEMS(m_idTails) );
     1596
     1597  p_Test(multiplier, r);
    15881598
    15891599  if( UNLIKELY(__NOCACHING__) )
    … …  
    16191629       
    16201630       poly p = p_Copy(itr->second, r); // COPY!!!
     1631       
     1632       p_Test(multiplier, r);
    16211633
    16221634       if( !n_Equal( pGetCoeff(multiplier), pGetCoeff(itr->first), r) ) // normalize coeffs!?
    … …  
    16481660       if( __DEBUG__ )       {         m_div.Verify();         m_checker.Verify();       }
    16491661#endif
     1662       p_Test(multiplier, r);
    16501663       
    16511664       return p;
    … …  
    16581671     }
    16591672     
     1673     p_Test(multiplier, r);
     1674     
    16601675     const poly p = ComputeImage(multiplier, tail);
    16611676
    … …  
    16661681
    16671682     if( UNLIKELY(__PROT__) ) ++ m_stat[8]; // PrintS("S"); // store
    1668 
    1669      T.insert( TP2PCache::value_type(p_Copy(multiplier, r), p) ); //     T[ multiplier ] = p;
     1683     
     1684     p_Test(multiplier, r);
     1685     
     1686     T.insert( TP2PCache::value_type(myp_Head(multiplier, r), p) ); //     T[ multiplier ] = p;
     1687
     1688     p_Test(multiplier, r);
    16701689
    16711690//     if( p == NULL )
    … …  
    16851704    Print("{ \"proc\": \"TTStore%d\", \"nodelabel\": \"", 0); writeLatexTerm(multiplier, r, false); Print(" \\\\GEN{%d}\", \"children\": [", tail + 1);
    16861705  }
    1687 
     1706 
    16881707  const poly p = ComputeImage(multiplier, tail);
    16891708
    … …  
    17161735  assume( tail >= 0 && tail < IDELEMS(m_idTails) );
    17171736 
     1737  p_Test(multiplier, r);
     1738   
    17181739  const poly t = m_idTails->m[tail]; // !!!
    17191740
    … …  
    17301751   
    17311752    const poly p = TraverseTail(multiplier, t);
     1753     
     1754    p_Test(multiplier, r);
    17321755
    17331756    if( UNLIKELY(__TREEOUTPUT__) )
    … …  
    17571780  assume( T != NULL );
    17581781
     1782  p_Test(multiplier, r);
     1783   
    17591784#ifndef SING_NDEBUG
    17601785  if( __DEBUG__ )  {    m_div.Verify();    m_checker.Verify();  }
    … …  
    18421867  }
    18431868
     1869  p_Test(multiplier, r);
     1870   
    18441871  return s;
    1845 
    18461872}
    18471873
    … …  
    18681894  assume( T != NULL );
    18691895
     1896  p_Test(multiplier, r);
     1897   
    18701898  // simple implementation with FindReducer:
    18711899  poly s = NULL;
    18721900
    1873   if( UNLIKELY( (!__TAILREDSYZ__) || m_lcm.Check(multiplier) ) ) // TODO ????
     1901  if( (!__TAILREDSYZ__) || m_lcm.Check(multiplier) ) // TODO: UNLIKELY / LIKELY ????
    18741902  {
    18751903#if NOPRODUCT
    1876     s = m_div.FindReducer(multiplier, term4reduction, syztermCheck, m_checker);
     1904    s = m_div.FindReducer(multiplier, term4reduction, syztermCheck, m_checker); // s ????
     1905    p_Test(s, r);
    18771906   
     1907    p_Test(multiplier, r);
     1908     
    18781909    if( s == NULL ) // No Reducer?
    18791910    {     
    1880       if( UNLIKELY(__PROT__) ) ++ m_stat[4]; // PrintS("$"); // LOT
    1881      
    1882       return s;
     1911      if( UNLIKELY(__PROT__) ) ++ m_stat[4]; // PrintS("$"); // LOT     
     1912      return NULL;
    18831913    }
    18841914
    … …  
    18921922#else
    18931923    // NOTE: only LT(term4reduction) should be used in the following:
    1894     poly product = pp_Mult_mm(multiplier, term4reduction, r);
     1924    poly product = pp_Mult_mm(multiplier, term4reduction, r);     
     1925    p_Test(product, r);
     1926     
    18951927    s = m_div.FindReducer(product, syztermCheck, m_checker); // ??
    1896 
     1928    p_Test(s, r);
     1929
     1930    p_Test(multiplier, r);
     1931     
    18971932    if( s == NULL ) // No Reducer?
    18981933    {
    18991934      if( UNLIKELY(__PROT__) ) ++ m_stat[4]; // PrintS("$"); // LOT
    1900 
    1901       return s;
     1935      return NULL;
    19021936    }
    19031937
    … …  
    19181952  {
    19191953    if( UNLIKELY(__TAILREDSYZ__ && __PROT__) ) ++ m_stat[5]; // PrintS("%"); // check LCM !
    1920    
    1921     return s;
    1922   }
    1923  
     1954    return NULL;
     1955  }
     1956
     1957  p_Test(multiplier, r);
     1958  p_Test(s, r);
     1959
    19241960  poly b = leadmonom(s, r);
    19251961
     1962  p_Test(b, r);
     1963   
    19261964  const int c = p_GetComp(s, r) - 1;
    19271965  assume( c >= 0 && c < IDELEMS(T) );
    … …  
    19491987  }
    19501988
     1989  p_Test(multiplier, r);
    19511990
    19521991  if( t != NULL )
    … …  
    19581997#endif
    19591998
     1999  p_Test(multiplier, r);
    19602000 
    19612001  return s;
    … …  
    20012041    m_sev( p_GetShortExpVector(_lt, R) ),  m_label( _label ),  m_lt( _lt )
    20022042#ifndef SING_NDEBUG
    2003     , _R(R), m_lt_copy( p_Head(_lt, R) )
     2043    , _R(R), m_lt_copy( myp_Head(_lt, R) )
    20042044#endif 
    20052045{
    … …  
    21792219  assume( (p_GetComp(lt(), r) == p_GetComp(t, r))  || (p_GetComp(lt(), r) == 0)  );
    21802220
     2221  p_Test(m, r);
     2222  p_Test(t, r);
    21812223//  const int k = label();
    21822224//  assume( m_L->m[k] == p );
    … …  
    24512493      assume ( !n_IsZero( p_GetCoeff(m, m_rBaseRing), m_rBaseRing ) );
    24522494      assume ( !n_IsZero( p_GetCoeff(t, m_rBaseRing), m_rBaseRing ) );
    2453      
     2495       
     2496      p_Test(m, m_rBaseRing);
     2497
    24542498//      assume( p_GetComp(m_multiplier, m_rBaseRing) == 0 );
    24552499#ifndef SING_NDEBUG
    … …  
    25302574                                 const CReducerFinder& syz_checker) const
    25312575{
     2576  const ring& r = m_rBaseRing;
     2577   
    25322578#ifndef SING_NDEBUG
    25332579  if( __DEBUG__ )  {    Verify();    syz_checker.Verify();  }
    25342580#endif
     2581   
     2582  p_Test(multiplier, r);
    25352583
    25362584  CDivisorEnumerator2 itr(*this, multiplier, t);
    … …  
    25402588  // don't care about the module component of multiplier (as it may be the syzygy term)
    25412589  // product = multiplier * t?
    2542   const ring& r = m_rBaseRing;
    25432590
    25442591  assume( multiplier != NULL ); assume( t != NULL );
    … …  
    25532600  assume( c >= 0 && c < IDELEMS(L) );
    25542601
     2602  p_Test(multiplier, r);
     2603   
    25552604  if (UNLIKELY( __DEBUG__ && (syzterm != NULL) ))
    25562605  {
    … …  
    25742623  const BOOLEAN to_check = (syz_checker.IsNonempty()); // __TAILREDSYZ__ &&
    25752624
     2625//  const poly q = p_One(r);
    25762626  const poly q = p_New(r); pNext(q) = NULL;
    25772627
    25782628  if( UNLIKELY(__DEBUG__) )
    25792629    p_SetCoeff0(q, 0, r); // for printing q
    2580 
     2630   
     2631  assume( pNext(q) == NULL );
     2632
     2633  p_Test(multiplier, r);
    25812634  while( itr.MoveNext() )
    25822635  {
    … …  
    25922645    p_Setm(q, r);
    25932646
     2647    p_Test(multiplier, r);
     2648     
    25942649    // cannot allow something like: a*gen(i) - a*gen(i)
    25952650    if (syzterm != NULL && (k == c))
    … …  
    26312686
    26322687    p_SetCoeff0(q, n_InpNeg(n, r), r);
    2633     n_Delete(&n, r);
     2688//    n_Delete(&n, r);
    26342689
    26352690#ifndef SING_NDEBUG
    26362691    if( __DEBUG__ )    {      Verify();      syz_checker.Verify();    }
    26372692#endif
     2693    p_Test(multiplier, r);
     2694    p_Test(q, r);
    26382695   
    26392696    assume( itr.Current().CheckLT( L ) ); // ???
    … …  
    27312788  if( __DEBUG__ )  {    Verify();    syz_checker.Verify();  }
    27322789#endif
     2790   
     2791  p_Test(multiplier, r);
    27332792
    27342793  return NULL;
Note: See TracChangeset for help on using the changeset viewer.