Changeset 058832 in git


Ignore:
Timestamp:
Feb 2, 2018, 12:07:43 PM (6 years ago)
Author:
Hans Schoenemann <hannes@…>
Branches:
(u'spielwiese', '5b153614cbc72bfa198d75b1e9e33dab2645d9fe')
Children:
bdba4c7aea5d095e5600cd49b599f5a54db626ba
Parents:
68395808f4180002f73bcf7dd2f2447899b0d8650756dfbab9f76c7f0d53379f68521798673c6ff0
git-author:
Hans Schoenemann <hannes@mathematik.uni-kl.de>2018-02-02 12:07:43+01:00
git-committer:
GitHub <noreply@github.com>2018-02-02 12:07:43+01:00
Message:
Merge pull request #848 from dimpase/spielwiese

templated call to pow() needs std::
Files:
6 added
12 edited

Legend:

Unmodified
Added
Removed
  • Singular/LIB/ncfactor.lib

    r0756df r058832  
    1047410474 - We have n parameters q_1,..., q_n given.
    1047510475
    10476 SEE ALSO: homogfacNthWeyl, homogfacFirstQWeyl, homogfacFirstQWeyl_all
     10476SEE ALSO: homogfacFirstQWeyl, homogfacFirstQWeyl_all
    1047710477"
    1047810478{//proc homogfacNthQWeyl_all
  • Singular/dyn_modules/syzextra/syzextra.cc

    r0756df r058832  
    6262#endif
    6363
    64 #ifndef SING_NDEBUG
    65 ring SBucketFactory::_GetBucketRing(const SBucketFactory::Bucket& bt)
    66 {
     64SBucketFactory::Bucket SBucketFactory::_CreateBucket(const ring r)
     65{
     66  const Bucket bt = sBucketCreate(r);
     67
    6768  assume( bt != NULL );
    68   return sBucketGetRing(bt);
    69 }
    70 
    71 bool SBucketFactory::_IsBucketEmpty(const SBucketFactory::Bucket& bt)
    72 {
    73   assume( bt != NULL );
    74   return sIsEmpty(bt);
    75 }
    76 #endif
    77 
    78 SBucketFactory::Bucket SBucketFactory::_CreateBucket(const ring r)
    79 {
    80   const Bucket bt = sBucketCreate(r);
    81 
    82   assume( bt != NULL );
    83   assume( _IsBucketEmpty(bt) );
    84   assume( r == _GetBucketRing(bt) );
    85 
    8669  return bt;
    8770}
     
    9174  if( bt != NULL )
    9275  {
    93     assume( _IsBucketEmpty(bt) );
    9476    sBucketDestroy( &bt );
    9577    bt = NULL;
     
    14821464CLeadingTerm::CLeadingTerm(unsigned int _label,  const poly _lt, const ring R):
    14831465    m_sev( p_GetShortExpVector(_lt, R) ),  m_label( _label ),  m_lt( _lt )
    1484 #ifndef SING_NDEBUG
    1485     , _R(R), m_lt_copy( myp_Head(_lt, true, R) ) // note that p_LmEqual only tests exponents!
    1486 #endif
    1487 {
    1488 #ifndef SING_NDEBUG
    1489   assume( pNext(m_lt_copy) == NULL );
    1490 #endif
     1466{
    14911467  assume( sev() == p_GetShortExpVector(lt(), R) );
    14921468}
    1493 
    1494 #ifndef SING_NDEBUG
    1495 CLeadingTerm::~CLeadingTerm()
    1496 {
    1497   assume( p_LmEqual(m_lt, m_lt_copy, _R) );
    1498   assume( m_sev == p_GetShortExpVector(m_lt, _R) );
    1499 
    1500   poly p = const_cast<poly>(m_lt_copy);
    1501   p_Delete(&p, _R);
    1502 }
    1503 poly CLeadingTerm::lt() const
    1504 {
    1505   assume( p_LmEqual(m_lt, m_lt_copy, _R) );
    1506   assume( m_sev == p_GetShortExpVector(m_lt, _R) );
    1507   return m_lt;
    1508 }
    1509 
    1510 unsigned long CLeadingTerm::sev() const
    1511 {
    1512   assume( p_LmEqual(m_lt, m_lt_copy, _R) );
    1513   assume( m_sev == p_GetShortExpVector(m_lt, _R) );
    1514   return m_sev;
    1515 }
    1516 
    1517 unsigned int CLeadingTerm::label() const
    1518 {
    1519   assume( p_LmEqual(m_lt, m_lt_copy, _R) );
    1520   assume( m_sev == p_GetShortExpVector(m_lt, _R) );
    1521   return m_label;
    1522 }
    1523 #endif
    1524 
    1525 
    15261469
    15271470CReducerFinder::~CReducerFinder()
     
    16341577  assume( (p_GetComp(lt(), r) == p_GetComp(product, r)) || (p_GetComp(lt(), r) == 0) );
    16351578
    1636 #ifndef SING_NDEBUG
    1637   assume( r == _R );
    1638 #endif
    1639 
    16401579//  const int k = label();
    16411580//  assume( m_L->m[k] == p );
     
    16651604//  const int k = label();
    16661605//  assume( m_L->m[k] == p );
    1667 
    1668 #ifndef SING_NDEBUG
    1669   assume( r == _R );
    1670 #endif
    16711606
    16721607  if (sev() & not_sev)
     
    17711706
    17721707
    1773 
    17741708bool CReducerFinder::IsDivisible(const poly product) const
    17751709{
     
    17841718  return itr.MoveNext();
    17851719
    1786 /*
    1787   const ring& r = m_rBaseRing;
    1788 
    1789   const long comp = p_GetComp(product, r);
    1790   const unsigned long not_sev = ~p_GetShortExpVector(product, r);
    1791 
    1792   assume( comp >= 0 );
    1793 
    1794   CReducersHash::const_iterator it = m_hash.find(comp); // same module component
    1795 
    1796   assume( m_L != NULL );
    1797 
    1798   if( it == m_hash.end() )
    1799     return false;
    1800   // assume comp!
    1801 
    1802   const TReducers& reducers = it->second;
    1803 
    1804   for(TReducers::const_iterator vit = reducers.begin(); vit != reducers.end(); vit++ )
    1805   {
    1806     assume( (*vit)->CheckLT( m_L ) );
    1807 
    1808     if( (*vit)->DivisibilityCheck(product, not_sev, r) )
    1809     {
    1810       return true;
    1811     }
    1812   }
    1813 
    1814   return false;
    1815 */
    1816 }
    1817 
    1818 
    1819 #ifndef SING_NDEBUG
    1820 void CReducerFinder::Verify() const
    1821 {
    1822   const ring& r = m_rBaseRing;
    1823 
    1824   for( CReducersHash::const_iterator it = m_hash.begin(); it != m_hash.end(); it++)
    1825   {
    1826     const TReducers& reducers = it->second;
    1827 
    1828     for(TReducers::const_iterator vit = reducers.begin(); vit != reducers.end(); vit++ )
    1829     {
    1830       assume( (*vit)->CheckLT( m_L ) );
    1831 
    1832       const poly p = (*vit)->lt();
    1833 
    1834       const unsigned long p_sev = (*vit)->sev();
    1835       assume( p_sev == p_GetShortExpVector(p, r) );
    1836 
    1837       assume( p_GetComp(p, r) == it->first );
    1838 
    1839       const int k = (*vit)->label();
    1840       assume( m_L->m[k] == p );
    1841 
    1842       pp_Test(p, r, r);
    1843     }
    1844   }
    1845 }
    1846 
    1847 
    1848 
    1849 void CReducerFinder::DebugPrint() const
    1850 {
    1851   const ring& r = m_rBaseRing;
    1852 
    1853   for( CReducersHash::const_iterator it = m_hash.begin(); it != m_hash.end(); it++)
    1854   {
    1855     Print("Hash Key: %ld, Values: \n", it->first);
    1856     const TReducers& reducers = it->second;
    1857 
    1858     for(TReducers::const_iterator vit = reducers.begin(); vit != reducers.end(); vit++ )
    1859     {
    1860       assume( (*vit)->CheckLT( m_L ) );
    1861 
    1862       const int k = (*vit)->label();
    1863       const poly p = (*vit)->lt();
    1864 
    1865       pp_Test(p, r, r);
    1866 
    1867       assume( m_L->m[k] == p );
    1868 
    1869       const unsigned long p_sev = (*vit)->sev();
    1870       assume( p_sev == p_GetShortExpVector(p, r) );
    1871 
    1872       assume( p_GetComp(p, r) == it->first );
    1873 
    1874       Print("L[%d]: ", k); Print("SEV: %ld\n", p_sev);
    1875 
    1876       assume( m_L->m[k] == p );
    1877     }
    1878   }
    1879 }
    1880 #endif
     1720}
    18811721
    18821722#if NOPRODUCT
     
    19181758      p_Test(m, m_rBaseRing);
    19191759
    1920 //      assume( p_GetComp(m_multiplier, m_rBaseRing) == 0 );
    19211760    }
    19221761
     
    20681907  }
    20691908
     1909  p_LmFree(q, r);
     1910
     1911  p_Test(multiplier, r);
     1912
     1913  return NULL;
     1914
     1915}
     1916#endif
     1917
     1918
     1919poly CReducerFinder::FindReducer(const poly product, const poly syzterm, const CReducerFinder& syz_checker) const
     1920{
     1921  CDivisorEnumerator itr(*this, product);
     1922  if( !itr.Reset() )
     1923    return NULL;
     1924
     1925
     1926
     1927  const ring& r = m_rBaseRing;
     1928
     1929  assume( product != NULL );
     1930
     1931  const ideal& L = m_L; assume( L != NULL ); // for debug/testing only!
     1932
     1933  long c = 0;
     1934
     1935  if (syzterm != NULL)
     1936    c = p_GetComp(syzterm, r) - 1;
     1937
     1938  assume( c >= 0 && c < IDELEMS(L) );
     1939
     1940  const BOOLEAN to_check = (syz_checker.IsNonempty()); // OPT__TAILREDSYZ &&
     1941
     1942  const poly q = p_New(r); pNext(q) = NULL;
     1943
     1944  while( itr.MoveNext() )
     1945  {
     1946    assume( itr.Current().CheckLT( L ) ); // ???
     1947
     1948    const poly p = itr.Current().lt(); // ??
     1949    const int k  = itr.Current().label();
     1950
     1951    p_ExpVectorDiff(q, product, p, r); // (LM(product) / LM(L[k]))
     1952    p_SetComp(q, k + 1, r);
     1953    p_Setm(q, r);
     1954
     1955    // cannot allow something like: a*gen(i) - a*gen(i)
     1956    if (syzterm != NULL && (k == c))
     1957      if (p_ExpVectorEqual(syzterm, q, r))
     1958      {
     1959        assume( itr.Current().CheckLT( L ) ); // ???
     1960        continue;
     1961      }
     1962
     1963    // while the complement (the fraction) is not reducible by leading syzygies
     1964    if( to_check && syz_checker.IsDivisible(q) ) // ?????
     1965    {
     1966      assume( itr.Current().CheckLT( L ) ); // ???
     1967      continue;
     1968    }
     1969
     1970
     1971#if NODIVISION
     1972    assume( n_IsOne(p_GetCoeff(p, r), r->cf) );
     1973    p_SetCoeff0(q, n_InpNeg( n_Copy(pGetCoeff(product), r->cf), r->cf), r);
     1974#else
     1975    p_SetCoeff0(q, n_InpNeg( n_Div( pGetCoeff(product), p_GetCoeff(p), r->cf), r->cf), r);
     1976#endif
     1977
     1978    assume( itr.Current().CheckLT( L ) ); // ???
     1979    return q;
     1980  }
     1981
     1982
     1983
    20701984/*
    2071   const long comp = p_GetComp(t, r); assume( comp >= 0 );
    2072   const unsigned long not_sev = ~p_GetShortExpVector(multiplier, t, r); // !
     1985  const long comp = p_GetComp(product, r);
     1986  const unsigned long not_sev = ~p_GetShortExpVector(product, r);
     1987
     1988  assume( comp >= 0 );
    20731989
    20741990//   for( int k = IDELEMS(L)-1; k>= 0; k-- )
     
    20872003    return NULL;
    20882004
    2089   // assume comp!
    2090 
    20912005  assume( m_L != NULL );
    20922006
    20932007  const TReducers& reducers = it->second;
    20942008
     2009  const BOOLEAN to_check = (syz_checker.IsNonempty()); // OPT__TAILREDSYZ &&
     2010
     2011  const poly q = p_New(r); pNext(q) = NULL;
     2012
    20952013  for(TReducers::const_iterator vit = reducers.begin(); vit != reducers.end(); vit++ )
    20962014  {
    2097 
    2098     const poly p = (*vit)->lt(); // ??
     2015    const poly p = (*vit)->lt(); // ???
     2016
     2017    assume( p_GetComp(p, r) == comp );
     2018
    20992019    const int k = (*vit)->label();
    21002020
    21012021    assume( L->m[k] == p ); // CheckLT
    21022022
    2103 //    const unsigned long p_sev = (*vit)->sev();
    2104 //    assume( p_sev == p_GetShortExpVector(p, r) );
    2105 
    2106 //    if( !p_LmShortDivisibleByNoComp(p, p_sev, product, not_sev, r) )
    2107 //      continue;
    2108 
    2109     if( !(*vit)->DivisibilityCheck(multiplier, t, not_sev, r) )
     2023    const unsigned long p_sev = (*vit)->sev();
     2024
     2025    assume( p_sev == p_GetShortExpVector(p, r) );
     2026
     2027    if( !p_LmShortDivisibleByNoComp(p, p_sev, product, not_sev, r) )
    21102028      continue;
    21112029
    2112 
    2113 //    if (p_sev & not_sev) continue;
    2114 //    if( !_p_LmDivisibleByNoComp(p, multiplier, t, r) ) continue;
    2115 
    2116 
    2117     p_ExpVectorSum(q, multiplier, t, r); // q == product == multiplier * t
    2118     p_ExpVectorDiff(q, q, p, r); // (LM(product) / LM(L[k]))
    2119 
     2030//     // ... which divides the product, looking for the _1st_ appropriate one!
     2031//     if( !p_LmDivisibleByNoComp(p, product, r) ) // included inside  p_LmShortDivisibleBy!
     2032//       continue;
     2033
     2034    p_ExpVectorDiff(q, product, p, r); // (LM(product) / LM(L[k]))
    21202035    p_SetComp(q, k + 1, r);
    21212036    p_Setm(q, r);
     
    21342049    }
    21352050
    2136     number n = n_Mult( p_GetCoeff(multiplier, r), p_GetCoeff(t, r), r);
    2137     p_SetCoeff0(q, n_InpNeg( n_Div(n, p_GetCoeff(p, r), r), r), r);
    2138     n_Delete(&n, r);
    2139 
    2140     return q;
    2141   }
    2142 */
    2143 
    2144   p_LmFree(q, r);
    2145 
    2146   p_Test(multiplier, r);
    2147 
    2148   return NULL;
    2149 
    2150 }
    2151 #endif
    2152 
    2153 
    2154 poly CReducerFinder::FindReducer(const poly product, const poly syzterm, const CReducerFinder& syz_checker) const
    2155 {
    2156   CDivisorEnumerator itr(*this, product);
    2157   if( !itr.Reset() )
    2158     return NULL;
    2159 
    2160 
    2161 
    2162   const ring& r = m_rBaseRing;
    2163 
    2164   assume( product != NULL );
    2165 
    2166   const ideal& L = m_L; assume( L != NULL ); // for debug/testing only!
    2167 
    2168   long c = 0;
    2169 
    2170   if (syzterm != NULL)
    2171     c = p_GetComp(syzterm, r) - 1;
    2172 
    2173   assume( c >= 0 && c < IDELEMS(L) );
    2174 
    2175   const BOOLEAN to_check = (syz_checker.IsNonempty()); // OPT__TAILREDSYZ &&
    2176 
    2177   const poly q = p_New(r); pNext(q) = NULL;
    2178 
    2179   while( itr.MoveNext() )
    2180   {
    2181     assume( itr.Current().CheckLT( L ) ); // ???
    2182 
    2183     const poly p = itr.Current().lt(); // ??
    2184     const int k  = itr.Current().label();
    2185 
    2186     p_ExpVectorDiff(q, product, p, r); // (LM(product) / LM(L[k]))
    2187     p_SetComp(q, k + 1, r);
    2188     p_Setm(q, r);
    2189 
    2190     // cannot allow something like: a*gen(i) - a*gen(i)
    2191     if (syzterm != NULL && (k == c))
    2192       if (p_ExpVectorEqual(syzterm, q, r))
    2193       {
    2194         assume( itr.Current().CheckLT( L ) ); // ???
    2195         continue;
    2196       }
    2197 
    2198     // while the complement (the fraction) is not reducible by leading syzygies
    2199     if( to_check && syz_checker.IsDivisible(q) ) // ?????
    2200     {
    2201       assume( itr.Current().CheckLT( L ) ); // ???
    2202       continue;
    2203     }
    2204 
    2205 
    2206 #if NODIVISION
    2207     assume( n_IsOne(p_GetCoeff(p, r), r->cf) );
    2208     p_SetCoeff0(q, n_InpNeg( n_Copy(pGetCoeff(product), r->cf), r->cf), r);
    2209 #else
    2210     p_SetCoeff0(q, n_InpNeg( n_Div( pGetCoeff(product), p_GetCoeff(p), r->cf), r->cf), r);
    2211 #endif
    2212 
    2213     assume( itr.Current().CheckLT( L ) ); // ???
    2214     return q;
    2215   }
    2216 
    2217 
    2218 
    2219 /*
    2220   const long comp = p_GetComp(product, r);
    2221   const unsigned long not_sev = ~p_GetShortExpVector(product, r);
    2222 
    2223   assume( comp >= 0 );
    2224 
    2225 //   for( int k = IDELEMS(L)-1; k>= 0; k-- )
    2226 //   {
    2227 //     const poly p = L->m[k];
    2228 //
    2229 //     if ( p_GetComp(p, r) != comp )
    2230 //       continue;
    2231 //
    2232 //     const unsigned long p_sev = p_GetShortExpVector(p, r); // to be stored in m_hash!!!
    2233 
    2234    // looking for an appropriate diviser p = L[k]...
    2235   CReducersHash::const_iterator it = m_hash.find(comp); // same module component
    2236 
    2237   if( it == m_hash.end() )
    2238     return NULL;
    2239 
    2240   assume( m_L != NULL );
    2241 
    2242   const TReducers& reducers = it->second;
    2243 
    2244   const BOOLEAN to_check = (syz_checker.IsNonempty()); // OPT__TAILREDSYZ &&
    2245 
    2246   const poly q = p_New(r); pNext(q) = NULL;
    2247 
    2248   for(TReducers::const_iterator vit = reducers.begin(); vit != reducers.end(); vit++ )
    2249   {
    2250     const poly p = (*vit)->lt(); // ???
    2251 
    2252     assume( p_GetComp(p, r) == comp );
    2253 
    2254     const int k = (*vit)->label();
    2255 
    2256     assume( L->m[k] == p ); // CheckLT
    2257 
    2258     const unsigned long p_sev = (*vit)->sev();
    2259 
    2260     assume( p_sev == p_GetShortExpVector(p, r) );
    2261 
    2262     if( !p_LmShortDivisibleByNoComp(p, p_sev, product, not_sev, r) )
    2263       continue;
    2264 
    2265 //     // ... which divides the product, looking for the _1st_ appropriate one!
    2266 //     if( !p_LmDivisibleByNoComp(p, product, r) ) // included inside  p_LmShortDivisibleBy!
    2267 //       continue;
    2268 
    2269     p_ExpVectorDiff(q, product, p, r); // (LM(product) / LM(L[k]))
    2270     p_SetComp(q, k + 1, r);
    2271     p_Setm(q, r);
    2272 
    2273     // cannot allow something like: a*gen(i) - a*gen(i)
    2274     if (syzterm != NULL && (k == c))
    2275       if (p_ExpVectorEqual(syzterm, q, r))
    2276       {
    2277         continue;
    2278       }
    2279 
    2280     // while the complement (the fraction) is not reducible by leading syzygies
    2281     if( to_check && syz_checker.IsDivisible(q) )
    2282     {
    2283       continue;
    2284     }
    2285 
    22862051    p_SetCoeff0(q, n_InpNeg( n_Div( p_GetCoeff(product, r), p_GetCoeff(p, r), r), r), r);
    22872052    return q;
     
    22922057  return NULL;
    22932058}
    2294 
    22952059
    22962060
     
    23462110}
    23472111
    2348 CCacheCompare::CCacheCompare(): m_ring(currRing) {}
    2349 
    2350 
    2351 template class std::vector<bool>;
    2352 template class std::vector<CLeadingTerm const*>;
    2353 template class std::map< CReducerFinder::TComponentKey, CReducerFinder::TReducers >;
    2354 
    2355 template class std::map<TCacheKey, TCacheValue, struct CCacheCompare>;
    2356 template class std::map<int, TP2PCache>;
    2357 
    2358 template class std::stack <sBucket_pt>;
     2112
     2113
     2114
    23592115
    23602116// Vi-modeline: vim: filetype=c:syntax:shiftwidth=2:tabstop=8:textwidth=0:expandtab
  • Singular/dyn_modules/syzextra/syzextra.h

    r0756df r058832  
    7171  private:
    7272    typedef std::stack <sBucket_pt> Base;
    73 //    typedef std::vector<Bucket> Memory;
    74 //    typedef std::deque <Bucket> Memory;
    75 //    typedef std::stack <Bucket, Memory > Base;
    7673
    7774  public:
     
    7976
    8077    SBucketFactory(const ring r)
    81 #ifndef SING_NDEBUG
    82         : m_ring(r)
    83 #endif
    8478    {
    8579      push ( _CreateBucket(r) ); // start with at least one sBucket...?
     
    9892    Bucket getBucket(const ring r, const bool remove = true)
    9993    {
    100       assume( r == m_ring );
    101 
    10294      Bucket bt = NULL;
    10395
     
    121113
    122114      assume( bt != NULL );
    123       assume( _IsBucketEmpty(bt) );
    124       assume( r == _GetBucketRing(bt) );
    125115
    126116      return bt;
     
    131121    {
    132122      assume( bt != NULL );
    133       assume( _IsBucketEmpty(bt) );
    134       assume( m_ring == _GetBucketRing(bt) );
    135123
    136124      if( empty() )
     
    151139
    152140  private:
    153 
    154 #ifndef SING_NDEBUG
    155     const ring m_ring; ///< For debugging: all buckets are over the same ring... right?!
    156 
    157     /// get bucket ring
    158     static ring _GetBucketRing(const Bucket& bt);
    159 
    160     static bool  _IsBucketEmpty(const Bucket& bt);
    161 #endif
    162 
    163141    /// inital allocation for new buckets
    164142    static Bucket _CreateBucket(const ring r);
     
    258236    CLeadingTerm(unsigned int label,  const poly lt, const ring);
    259237
    260 #ifndef SING_NDEBUG
    261     ~CLeadingTerm();
    262 #endif
    263 
    264238#if NOPRODUCT
    265239    bool DivisibilityCheck(const poly multiplier, const poly t, const unsigned long not_sev, const ring r) const;
     
    269243    bool CheckLT( const ideal & L ) const;
    270244
    271 #ifndef SING_NDEBUG
    272     poly lt() const;
    273     unsigned long sev() const;
    274     unsigned int label() const;
    275 #else
    276245    inline poly lt() const { return m_lt; };
    277246    inline unsigned long sev() const { return m_sev; };
    278247    inline unsigned int label() const { return m_label; };
    279 #endif
    280 
    281248  private:
    282249    const unsigned long m_sev; ///< not short exp. vector
     
    286253
    287254    const poly          m_lt; ///< the leading term itself L[label-1]
    288 
    289 #ifndef SING_NDEBUG
    290     const ring _R;
    291 
    292     const poly          m_lt_copy; ///< original copy of LEAD(lt) (only for debug!!!)
    293 #endif
    294255
    295256    // disable the following:
     
    340301    /// is the term to be "preprocessed" as lower order term or lead to only reducible syzygies...
    341302    int PreProcessTerm(const poly t, CReducerFinder& syzChecker) const;
    342 
    343 #ifndef SING_NDEBUG
    344     void DebugPrint() const;
    345     void Verify() const;
    346 #endif
    347303
    348304  private:
     
    525481    CReducerFinder m_checker;
    526482
    527     /*
    528     // need more data here:
    529     // (m_idLeads : m_tailterm) = (m, pos, compl), s.th: compl * m_tailterm divides m_idLeads[pos]
    530     // but resulting sysygy compl * gen(pos) should not be in
    531     // Idea: extend CReducerFinder??!!
    532     struct CTailTerm
    533     {
    534       const poly m_tailterm;
    535 
    536       const CReducerFinder m_reducers; // positions are labels (in m_idLeads)...
    537       // compl - to be computed if needed?
    538 
    539       CTailTerm(const poly tt, const CReducerFinder reds): m_tailterm(tt), m_reducers(reds) {}
    540     };
    541 
    542     typedef std::vector<const CTailTerm*> TTail;
    543     typedef std::vector<TTail> TTailTerms;
    544 
    545     TTailTerms m_idTailTerms;
    546     */
    547 
    548483    mutable TCache m_cache; // cacher comp + poly -> poly! // mutable???
    549 
    550 /// TODO: look into m_idTailTerms!!!!!!!!!!!!!!!!!!!!!!!! map? heaps???
    551     // NOTE/TODO: the following globally shared buckets violate reentrance - they should rather belong to TLS!
    552484
    553485    /// used for simple summing up
  • Singular/links/pipeLink.cc

    r0756df r058832  
    9090  if (d!=NULL)
    9191  {
    92     if (d->f_read!=NULL) fclose(d->f_read);
    93     if (d->f_write!=NULL) fclose(d->f_write);
    94     if (d->pid!=0) { kill(d->pid,15); kill(d->pid,9); }
    95   }
    96   SI_LINK_SET_CLOSE_P(l);
     92    BOOLEAN unidirectional=TRUE;
     93    if ( (d->f_read!=NULL) &&  (d->f_write!=NULL))
     94      unidirectional=FALSE;
     95
     96    if (d->f_read!=NULL)
     97    {
     98      fclose(d->f_read);
     99      d->f_read=NULL;
     100      SI_LINK_SET_CLOSE_P(l);
     101      SI_LINK_SET_R_OPEN_P(l);
     102    }
     103    if (unidirectional && (d->f_write!=NULL))
     104    {
     105      fclose(d->f_write);
     106      d->f_write=NULL;
     107      SI_LINK_SET_CLOSE_P(l);
     108    }
     109    if (unidirectional && (d->pid!=0))
     110    { kill(d->pid,15); kill(d->pid,9); }
     111  }
     112  else SI_LINK_SET_CLOSE_P(l);
    97113  return FALSE;
    98114}
  • Tst/Manual/minres_BR_PLURAL_BR.res.gz.uu

    r0756df r058832  
    11begin 640 minres_BR_PLURAL_BR.res.gz
    2 M'XL("#4J<DX``VUI;G)E<U]"4E]03%5204Q?0E(N<F5S`+U438O;,!"]ZU<,
    3 MH0>[CK.VW,^X%F0IAH6DE-WF5()Q&CD659P2:2GMK^_8EF0[A>VAM#I8SYIY
    4 M3]+,0P^?WM]]`("8P?KN%F9:Z844^UD*B`K1".WY*6EG8`Q.HKEP5=S>%Q_7
    5 MV_O5&M&BX=\72I>:/!@I:J2:+Z4\]F(NEC`X\`I6D,&I_,JW2M)6WX9?,%!<
    6 M7T1SA%4*-S>@:Z$`9?C^4@+"K:=D07U'>,E`''@I061\7LWK0>H51C*E#YX8
    7 MZ;]F@.<_RT<MS@WD67L;3\PC/X4\)1!#-Y+)9!;)"MZ%(<#51$@T2:,3+AGM
    8 MUIQU6S]Q$C_Y`7YP3=RQWC"00FF0.=8E3W%.R>=XMR08*Q!D=8_H+JMZE.PR
    9 M3O!_2*F>'WGCQ7Y8=X#Z(37`<?DT)?$#:L`@:LF5B80]A6!PV,L)528]L(KN
    10 M2F\9?,,^:F_/M1:>S/TYS#H\PW[`,*)1]?KB)21\<G3L:#GBA:.:QW]BZ[,N
    11 MY9@=3=CV!G$T\<HFSWKS>SF:!7__B5W<YK%UQ,9:8G/MB6KHZ]0)(;=>""KK
    12 M@8#6=HT:X.@AMTL!OVKHV$5/.\"=G%XU?O,?.F^^73A>_A:@?V4,RW8WQ#>L
    13 4?1O;-^]180W29^07E+[_F$8%````
     2M'XL("$;+<5H"`VUI;G)E<U]"4E]03%5204Q?0E(N<F5S`+U476O;,!1]UZ^X
     3MA#W8<Y3:\M9N\2Q(&89",D;;/)5@G$6.Q11G1"IC^_63;4G^&'0/A>G!]UA7
     4MYTBZ]Z"'Q\]W7P`@HK"^NX69DFHA^'Z6@$8YK[GR_`0U$2B%$Z\O3.:W]_G7
     5M]?9^M=9H4;.?"ZD*A1Z,%#%2];="'#LQEXLI'%@)*TCA5'QG6RE(HV_3[RA(
     6MIBZ\/L(J@:LK4!67H&78_E*`AEM/BISXCO">`C^P0@!/V;R<5[W4M<ZD4AT\
     7M/M"_H:#/?Q;/BI]KR-+F-AZ?AWX"68(@@G;$HV`FT0H^80PP"0B%HV5DQ$6#
     8MW>JS:NK'3_PW.\`OII`[U@<*@DL%(M-UR1(=$_04[99(YW(-TJI#9)>6'8IW
     9M*4/ZOU]2OCVRVHM\7+6`^)@8X+ALO"3V`V)`+VK)I<G@CH)TLM_+"95F>6`5
     10MW94^4OBA^ZB\/5.*>R+SYS!K\4SW`_H1#JK7%2]&^,71LL/E@(<'-8_^Q59G
     11M58@A.QRQ[0VB<.25399VYO<R;1;]V]N%C,*K[.(VCZPC-M82FZDGRKZO8R=@
     12M9KT0E-8#`:GL'#'`T3&S4P&;-'3HHI<=X$Y.)HW?_(?.FV^;CI9_)<BKC$&F
     138QM!O6/,V-F_>L]0U2-Z@/[GAZK5&!0``
    1414`
    1515end
  • Tst/Manual/minres_BR_PLURAL_BR.stat

    r0756df r058832  
    1 1 >> tst_memory_0 :: 1316104113:3132- exportiert :3-1-3:ix86-Linux:mamawutz:228916
    2 1 >> tst_memory_1 :: 1316104113:3132- exportiert :3-1-3:ix86-Linux:mamawutz:666332
    3 1 >> tst_memory_2 :: 1316104113:3132- exportiert :3-1-3:ix86-Linux:mamawutz:699116
    4 1 >> tst_timer_1 :: 1316104113:3132- exportiert :3-1-3:ix86-Linux:mamawutz:18
     11 >> tst_memory_0 :: 1517407046:4104, 64 bit:4.1.0:x86_64-Linux:nepomuck:179040
     21 >> tst_memory_1 :: 1517407046:4104, 64 bit:4.1.0:x86_64-Linux:nepomuck:2215936
     31 >> tst_memory_2 :: 1517407046:4104, 64 bit:4.1.0:x86_64-Linux:nepomuck:2215936
     41 >> tst_timer_1 :: 1517407046:4104, 64 bit:4.1.0:x86_64-Linux:nepomuck:5
  • Tst/Short/ok_s.lst

    r0756df r058832  
    1212bug_newstruct3
    1313bug_normalize
     14bug_printres
    1415bug_qring2
    1516bug_ring
    1617bug_ringlist
     18bug_sca
    1719bug_solve
    1820bug_ssi_algring
  • doc/COPYING.texi

    r0756df r058832  
    125125@uref{http://www.4ti2.de/}
    126126@item gfan (used by tropical.lib, @pxref{tropical_lib})
    127 @uref{http://www.math.tu-berlin.de/~jensen/software/gfan/gfan.html}
     127@uref{http://home.imf.au.dk/jensen/software/gfan/gfan.html}
    128128@item graphviz (used by resgraph.lib, @pxref{resgraph_lib})
    129129@uref{http://www.graphviz.org/}
     
    133133@item polymake (used by polymake.lib, @pxref{polymake_lib})
    134134@copyright{} Ewgenij Gawrilow and Michael Joswig
    135 @* @uref{http://www.polymake.de/}
     135@* @uref{http://polymake.org/}
    136136@item surf (used by surf.lib, @pxref{surf_lib})
    137137@copyright{} Stephan Endrass
     
    141141@item surfex (used by surfex.lib, @pxref{surfex_lib})
    142142@copyright{} Oliver Labs (2001-2008), Stephan Holzer (2004-2005)
    143 @* @uref{http://surfex.AlgebraicSurface.net}
     143@* @uref{https://github.com/Singular/Sources/tree/spielwiese/Singular/LIB/surfex}
    144144@item TOPCOM (used by polymake.lib, @pxref{polymake_lib})
    145145@copyright{} J@"org Rambau
     
    317317to the @sc{Singular} project.
    318318
     319@sc{Singular} is supported by Project B5 of SFB-TRR 195 'Symbolic Tools in
     320Mathematics and their Application'.
     321
  • kernel/GBEngine/syz1.cc

    r0756df r058832  
    23972397  if (syzstr->minres==NULL)
    23982398  {
     2399    if (syzstr->resolution!=NULL)
     2400    {
     2401      // need to clear syzstr->resolution, as we are
     2402      // now displaying the minres instead of fullres
     2403      delete syzstr->resolution;
     2404      syzstr->resolution=NULL;
     2405    }
    23992406    if (syzstr->resPairs!=NULL)
    24002407    {
  • libpolys/coeffs/ffields.cc

    r683958 r058832  
    807807  if (n==n_GF) {
    808808    GFInfo* p = (GFInfo *)(parameter);
    809     int c = pow (p->GFChar, p->GFDegree);
     809    int c = std::pow (p->GFChar, p->GFDegree);
    810810    if ((c == r->m_nfCharQ) && (strcmp(n_ParameterNames(r)[0], p->GFPar_name) == 0))
    811811      return TRUE;
     
    928928  }
    929929
    930   int c = pow (p->GFChar, p->GFDegree);
     930  int c = std::pow (p->GFChar, p->GFDegree);
    931931
    932932  nfReadTable(c, r);
  • libpolys/polys/monomials/p_polys.h

    r0756df r058832  
    14711471  ev[0] = p_GetComp(p, r);
    14721472}
     1473// p_GetExpVL is used in Singular,jl
    14731474static inline void p_GetExpVL(poly p, int64 *ev, const ring r)
    14741475{
     
    14861487  p_Setm(p, r);
    14871488}
     1489// p_SetExpVL is used in Singular,jl
    14881490static inline void p_SetExpVL(poly p, int64 *ev, const ring r)
    14891491{
  • libpolys/polys/nc/sca.cc

    r0756df r058832  
    10831083  // to be within quotient ideal.
    10841084
    1085   bool bSCA = true;
    1086 
    10871085  int b = N+1;
    10881086  int e = -1;
     
    10981096  }
    10991097
    1100   for ( int i = iAltVarStart; (i <= iAltVarEnd) && bSCA; i++ )
     1098  for ( int i = iAltVarStart; (i <= iAltVarEnd); i++ )
    11011099    if( (i < b) || (i > e) ) // otherwise it's ok since rG is an SCA!
    11021100    {
     
    11121110      {
    11131111        p_Delete(&square, rG);
    1114         bSCA = false;
    1115         break;
     1112        return false;
    11161113      }
    11171114    }
Note: See TracChangeset for help on using the changeset viewer.