Changeset 8f761ae in git

Timestamp:

Aug 28, 2013, 4:56:50 PM (10 years ago)

Author:

Oleksandr Motsak <motsak@…>

Branches:

(u'jengelh-datetime', 'ceac47cbc86fe4a15902392bdbb9bd2ae0ea02c6')(u'spielwiese', 'f875bbaccd0831e36aaed09ff6adeb3eb45aeb94')

Children:

79502e381504b0ec8fe16939b38060226ecebf6f

Parents:

be561246e7064a6d59d9b79c1eff7305b7d7aa00

git-author:

Oleksandr Motsak <motsak@mathematik.uni-kl.de>2013-08-28 16:56:50+02:00

git-committer:

Oleksandr Motsak <motsak@mathematik.uni-kl.de>2013-08-28 17:05:28+02:00

Message:

Update of MATHICGB according to the PullRequest #351

Files:

• Singular/singmathic.cc (modified) (8 diffs, 1 prop)
• m4/mathic-check.m4 (modified) (3 diffs)

Singular/singmathic.cc

@@ -20 +20 @@
 #include <mathicgb.h>
 
-typedef mgb::GroebnerConfiguration::Coefficient Coefficient;
-typedef mgb::GroebnerConfiguration::VarIndex VarIndex;
-typedef mgb::GroebnerConfiguration::Exponent Exponent;
-typedef mgb::GroebnerConfiguration::BaseOrder BaseOrder;
-
 // Constructs a Singular ideal.
 class MathicToSingStream {
 public:
+  typedef mgb::GroebnerConfiguration::Coefficient Coefficient;
+  typedef mgb::GroebnerConfiguration::VarIndex VarIndex;
+  typedef mgb::GroebnerConfiguration::Exponent Exponent;
+
   MathicToSingStream(Coefficient modulus, VarIndex varCount):
     mModulus(modulus),
     mVarCount(varCount),
-    mPolyCount(0),
+    polyCount(0),
     mTerm(0),
     mIdeal(0)
@@ -46 +45 @@
     deleteIdeal();
     mIdeal = idInit(polyCount);
-    mPolyCount = 0;
+    polyCount = 0;
   }
 
@@ -53 +52 @@
   void appendTermBegin() {
     if (mTerm == 0)
-      mTerm = mIdeal->m[mPolyCount] = pInit();
+      mTerm = mIdeal->m[polyCount] = pInit();
     else
       mTerm = mTerm->next = pInit();
@@ -68 +67 @@
 
   void appendPolynomialDone() {
-    ++mPolyCount;
+    ++polyCount;
     mTerm = 0;
   }
@@ -93 +92 @@
   const Coefficient mModulus;
   const VarIndex mVarCount;
-  size_t mPolyCount;
+  size_t polyCount;
   poly mTerm;
   ::ideal mIdeal;
 };
 
-#include <iostream>
-
-bool setOrder(ring r, mgb::GroebnerConfiguration& conf) {
-  const VarIndex varCount = conf.varCount();
-
-  bool didSetComponentBefore = false;
-  mgb::GroebnerConfiguration::BaseOrder baseOrder =
-    mgb::GroebnerConfiguration::RevLexDescendingBaseOrder;
-
-  std::vector<Exponent> gradings;
-  for (int block = 0; r->order[block] != ringorder_no; ++block) {
-    // *** ringorder_no
-
-    const rRingOrder_t type = static_cast<rRingOrder_t>(r->order[block]);
-    if (r->block0[block] < 0 || r->block1[block] < 0) {
-      WerrorS("Unexpected negative block0/block1 in ring.");
-      return false;
-    }
-    const VarIndex block0 = static_cast<VarIndex>(r->block0[block]);
-    const VarIndex block1 = static_cast<VarIndex>(r->block1[block]);
-    const int* const weights = r->wvhdl[block];
-    if (block0 > block1) {
-      WerrorS("Unexpected block0 > block1 in ring.");
-      return false;
-    }
-
-    // *** ringorder_c and ringorder_C
-    if (type == ringorder_c || type == ringorder_C) {
-      if (block0 != 0 || block1 != 0 || weights != 0) {
-        WerrorS("Unexpected non-zero fields on c/C block in ring.");
-        return false;
-      }
-      if (didSetComponentBefore) {
-        WerrorS("Unexpected two c/C blocks in ring.");
-        return false;
-      }
-      didSetComponentBefore = true;
-      if (r->order[block + 1] == ringorder_no) {
-        conf.setComponentBefore
-          (mgb::GroebnerConfiguration::ComponentAfterBaseOrder);
-      } else
-        conf.setComponentBefore(gradings.size() / varCount);
-      conf.setComponentsAscending(type == ringorder_C);
-      continue;
-    }
-    if (block0 == 0 || block1 == 0) {
-      WerrorS("Expected block0 != 0 and block1 != 0 in ring.");
-      return false;
-    }
-    if (block1 > varCount) {
-      // todo: first handle any block types where this is not true
-      WerrorS("Expected block1 <= #vars in ring.");
-      return false;
-    }
-
-    // dim is how many variables this block concerns.
-    const size_t dim = static_cast<size_t>(block1 - block0 + 1);
-
-    // *** single-graded/ungraded lex/revlex orders
-    // a(w): w-graded and that's it
-    // a64(w): w-graded with 64-bit weights (not supported here)
-    //    lp:               lex from  left (descending)
-    //    Dp:  1-graded,    lex from  left (descending)
-    //    Ds: -1-graded,    lex from  left (descending)
-    // Wp(w):  w-graded,    lex from  left (descending)
-    // Ws(w): -w-graded,    lex from  left (descending)
-    //    rp:               lex from right (ascending)
-    //    rs:            revlex from right (descending)
-    //    dp:  1-graded, revlex from right (descending)
-    //    ds: -1-graded, revlex from right (descending)
-    // wp(w):  w-graded, revlex from right (descending)
-    // ws(w): -w-graded, revlex from right (descending)
-    //    ls:            revlex from  left (ascending)
-
-    if (type == ringorder_a64) {
-      WerrorS("Block type a64 not supported for MathicGB interface.");
-      return false;
-    }
-
-    // * handle the single-grading part
-    const bool oneGrading = (type == ringorder_Dp || type == ringorder_dp);
-    const bool minusOneGrading = (type == ringorder_Ds || type == ringorder_ds);
-    const bool wGrading =
-      (type == ringorder_a || type == ringorder_Wp || type == ringorder_wp);
-    const bool minusWGrading = (type == ringorder_ws || type == ringorder_Ws);
-    if (oneGrading || minusOneGrading || wGrading || minusWGrading) {
-      const VarIndex begin = gradings.size();
-      gradings.resize(begin + varCount);
-      if (oneGrading || minusOneGrading) {
-        if (weights != 0) {
-          WerrorS("Expect wvhdl == 0 in Dp/dp/Ds/ds-block in ring.");
-          return false;
-        }
-        const Exponent value = oneGrading ? 1 : -1;
-        for (int var = block0 - 1; var < block1; ++var)
-          gradings[begin + var] = value;
-      } else {
-        if (weights == 0) {
-          WerrorS("Expect wvhdl != 0 in a/Wp/wp/ws/Ws-block in ring.");
-          return false;
-        }
-        if (wGrading) {
-          for (int var = 0; var < dim; ++var)
-            gradings[begin + (block0 - 1) + var] = weights[var];
-        } else {
-          for (int var = 0; var < dim; ++var)
-            gradings[begin + (block0 - 1) + var] = -weights[var];
-        }
-      }
-    }
-    if (type == ringorder_a)
-      continue; // a has only the grading, so we are done already
-
-    // * handle the lex/revlex part
-    const bool lexFromLeft =
-      type == ringorder_lp ||
-      type == ringorder_Dp ||
-      type == ringorder_Ds ||
-      type == ringorder_Wp ||
-      type == ringorder_Ws;
-    const bool lexFromRight = type == ringorder_rp;
-    const bool revlexFromLeft = type == ringorder_ls;
-    const bool revlexFromRight =
-      type == ringorder_rs ||
-      type == ringorder_dp ||
-      type == ringorder_ds ||
-      type == ringorder_wp ||
-      type == ringorder_ws;
-    if (lexFromLeft || lexFromRight || revlexFromLeft || revlexFromRight) {
-      const int next = r->order[block + 1];
-      bool final = next == ringorder_no;
-      if (!final && r->order[block + 2] == ringorder_no)
-        final = next == ringorder_c || next == ringorder_C;
-      if (final) {
-        if (lexFromRight)
-          baseOrder = mgb::GroebnerConfiguration::LexAscendingBaseOrder;
-        else if (revlexFromRight)
-          baseOrder = mgb::GroebnerConfiguration::RevLexDescendingBaseOrder;
-        else if (lexFromLeft)
-          baseOrder = mgb::GroebnerConfiguration::LexDescendingBaseOrder;
-        else
-          baseOrder = mgb::GroebnerConfiguration::RevLexAscendingBaseOrder;
-        continue;
-      }
-
-      const size_t begin = gradings.size();
-      gradings.resize(begin + dim * varCount);
-      const Exponent value = (lexFromLeft || lexFromRight) ? 1 : -1;
-      if (lexFromLeft || revlexFromLeft) {
-        for (size_t row = 0; row < dim; ++row)
-          gradings[begin + row * varCount + (block0 - 1) + row] = value;
-      } else {
-        for (size_t row = 0; row < dim; ++row)
-          gradings[begin + row * varCount + (block1 - 1) - row] = value;
-      }
-      continue;
-    }
-
-    // *** ringorder_M: a square invertible matrix
-    if (type == ringorder_M) {
-      if (weights == 0) {
-        WerrorS("Expected wvhdl != 0 in M-block in ring.");
-        return false;
-      }
-      const size_t begin = gradings.size();
-      gradings.resize(begin + dim * varCount);
-      for (size_t row = 0; row < dim; ++row)
-        for (size_t col = block0 - 1; col < block1; ++col)
-          gradings[begin + row * varCount + col] = weights[row * dim + col];
-      continue;
-    }
-
-    // *** Miscellaneous unsupported or invalid block types
-    if (
-      type == ringorder_s ||
-      type == ringorder_S ||
-      type == ringorder_IS
-    ) {
-      // todo: Consider supporting this later.
-      WerrorS("Schreyer order s/S/IS not supported in MathicGB interface.");
-      return false;
-    }
-    if (type == ringorder_am) {
-      // This block is a Schreyer-like ordering only used in Spielwiese.
-      // todo: Consider supporting it later.
-      WerrorS("Block type am not supported in MathicGB interface");
-      return false;
-    }
-    if (type == ringorder_L) {
-      WerrorS("Invalid L-block found in order of ring.");
-      return false;
-    }
-    if (type == ringorder_aa) {
-      // I don't know what an aa block is supposed to do.
-      WerrorS("aa ordering not supported by the MathicGB interface.");
-      return false;
-    }
-    if (type == ringorder_unspec) {
-      WerrorS("Invalid unspec-block found in order of ring.");
-      return false;
-    }
-    WerrorS("Unknown block type found in order of ring.");
-    return false;
-  }
-
-  if (!didSetComponentBefore) {
-    WerrorS("Expected to find a c/C block in ring.");
-    return false;
-  }
-
-  if (!conf.setMonomialOrder(baseOrder, gradings)) {
-    WerrorS("MathicGB does not support non-global orders.");
-    return false;
-  }
-  return true;
-}
-
-bool prOrderMatrix(ring r) {
-  const int varCount = r->N;
-  mgb::GroebnerConfiguration conf(101, varCount);
-  if (!setOrder(r, conf))
-    return false;
-  const std::vector<Exponent>& gradings = conf.monomialOrder().second;
-  if (gradings.size() % varCount != 0) {
-    WerrorS("Expected matrix to be a multiple of varCount.");
-    return false;
-  }
-  const size_t rowCount = gradings.size() / varCount;
-  std::cout << "Order matrix:\n";
-  for (size_t row = 0; row < rowCount; ++row) {
-    for (size_t col = 0; col < varCount; ++col)
-      std::cerr << ' ' << gradings[row * varCount + col];
-    std::cerr << '\n';
-  }
-  std::cerr
-    << "Base order: "
-    << mgb::GroebnerConfiguration::baseOrderName(conf.monomialOrder().first)
-    << '\n';
-  std::cerr << "Component before: " << conf.componentBefore() << '\n';
-  std::cerr << "Components ascending: " << conf.componentsAscending() << '\n';
-  std::cerr << "Schreyering: " << conf.schreyering() << '\n';
-}
-
-void prOrder(ring r) {
-  std::cout << "Printing order of ring.\n";
-  for (int block = 0; ; ++block) {
-    switch (r->order[block]) {
-    case ringorder_no: // end of blocks
-      return;
-
-    case ringorder_a:
-      std::cout << "a";
-      break;
-
-    case ringorder_a64: ///< for int64 weights
-      std::cout << "a64";
-      break;
-
-    case ringorder_c:
-      std::cout << "c";
-      break;
-
-    case ringorder_C:
-      std::cout << "C";
-      break;
-
-    case ringorder_M:
-      std::cout << "M";
-      break;
-      
-    case ringorder_S: ///< S?
-      std::cout << "S";
-      break;
-      
-    case ringorder_s: ///< s?
-      std::cout << "s";
-      break;
-
-    case ringorder_lp:
-      std::cout << "lp";
-      break;
-      
-    case ringorder_dp:
-      std::cout << "dp";
-      break;
-
-    case ringorder_rp:
-      std::cout << "rp";
-      break;
-
-    case ringorder_Dp:
-      std::cout << "Dp";
-      break;
-
-    case ringorder_wp:
-      std::cout << "wp";
-      break;
-
-    case ringorder_Wp:
-      std::cout << "Wp";
-      break;
-
-    case ringorder_ls:
-      std::cout << "ls"; // not global
-      break;
-
-    case ringorder_ds:
-      std::cout << "ds"; // not global
-      break;
-
-    case ringorder_Ds:
-      std::cout << "Ds"; // not global
-      break;
-
-    case ringorder_ws:
-      std::cout << "ws"; // not global
-      break;
-
-    case ringorder_Ws:
-      std::cout << "Ws"; // not global
-      break;
-
-    case ringorder_am:
-      std::cout << "am";
-      break;
-
-    case ringorder_L:
-      std::cout << "L";
-      break;
-
-    // the following are only used internally
-    case ringorder_aa: ///< for idElimination, like a, except pFDeg, pWeigths ignore it
-      std::cout << "aa";
-      break;
-
-    case ringorder_rs: ///< opposite of ls
-      std::cout << "rs";
-      break;
-
-    case ringorder_IS: ///< Induced (Schreyer) ordering
-      std::cout << "IS";
-      break;
-
-    case ringorder_unspec:
-      std::cout << "unspec";
-      break;
-    }
-    const int b0 = r->block0[block];
-    const int b1 = r->block1[block];
-    std::cout << ' ' << b0 << ':' << b1 << " (" << r->wvhdl[block] << ")" << std::flush;
-    if (r->wvhdl[block] != 0 && b0 != 0) {
-      for (int v = 0; v <= b1 - b0; ++v)
-        std::cout << ' ' << r->wvhdl[block][v];
-    } else
-      std::cout << " null";
-    std::cout << '\n';
-  }
-}
-
-BOOLEAN prOrderX(leftv result, leftv arg) {
-  if (currRing == 0) {
-    WerrorS("There is no current ring.");
-    return TRUE;
-  }
-  prOrder(currRing);
-  prOrderMatrix(currRing);
-  result->rtyp=NONE;
-  return FALSE;
-}
-
-BOOLEAN setRingGlobal(leftv result, leftv arg) {
-  currRing->OrdSgn = 1;
-  result->rtyp=NONE;
-  return FALSE;
-}
-
 BOOLEAN mathicgb(leftv result, leftv arg)
 {
-  result->rtyp=NONE;
-
   if (arg == NULL || arg->next != NULL || arg->Typ() != IDEAL_CMD) {
     WerrorS("Syntax: mathicgb(<ideal>)");
@@ -490 +111 @@
   const int varCount = currRing->N;
   mgb::GroebnerConfiguration conf(characteristic, varCount);
-  if (!setOrder(currRing, conf))
-    return TRUE;
-  if (TEST_OPT_PROT)
-    conf.setLogging("all");
-
   mgb::GroebnerInputIdealStream toMathic(conf);
 
@@ -511 +127 @@
       for (int i = 1; i <= currRing->N; ++i)
         toMathic.appendExponent(i - 1, pGetExp(p, i));
-      const long coefLong = reinterpret_cast<long>(pGetCoeff(p));
-      toMathic.appendTermDone(static_cast<int>(coefLong));
+      toMathic.appendTermDone(reinterpret_cast<int>(pGetCoeff(p)));
     }
     toMathic.appendPolynomialDone();
@@ -538 +153 @@
     mathicgb
   );
-  psModulFunctions->iiAddCproc(
-    (currPack->libname ? currPack->libname : ""),
-    "mathicgb_prOrder",
-    FALSE,
-    prOrderX
-  );
-  psModulFunctions->iiAddCproc(
-    (currPack->libname ? currPack->libname : ""),
-    "mathicgb_setRingGlobal",
-    FALSE,
-    setRingGlobal
-  );
   return 1;
 }

m4/mathic-check.m4

@@ -3 +3 @@
 #
  AC_ARG_WITH(mathicgb,
-   [ 
-    AS_HELP_STRING( 
+   [AS_HELP_STRING( 
      [--with-mathicgb=yes|no], 
      [Use the MathicGB library. Default is no.] 
-    )
-   ],
+   )],
    [], 
    [with_mathicgb="no"] 
@@ -18 +16 @@
  AS_IF( [test "x$with_mathicgb" = xyes], 
  [
-  AC_CHECK_LIB([tbb], [TBB_runtime_interface_version], [], [])
+  AC_LANG_PUSH([C++])
   AC_CHECK_LIB(memtailor, libmemtailorIsPresent, [],
     [AC_MSG_ERROR([Cannot find libmemtailor, which is required for MathicGB.])])
@@ -24 +22 @@
     [AC_MSG_ERROR([Cannot find libmathic, which is required for MathicGB.])])
   AC_CHECK_LIB(mathicgb, libmathicgbIsPresent, [],
-    [AC_MSG_ERROR([Cannot find the MathicGB library.])], [-lstdc++])
+    [AC_MSG_ERROR([Cannot find the MathicGB library.])])
   AC_CHECK_HEADER([mathicgb.h])
+  AC_LANG_POP([C++])
   AC_DEFINE(HAVE_MATHICGB,1,[Define if mathicgb is to be used])
+#  AC_SUBST(HAVE_MATHICGB_VALUE, 1)  
  ])
  #