My Project  debian-1:4.1.1-p2+ds-4
Functions
sca.h File Reference
#include "polys/nc/nc.h"
#include "misc/intvec.h"

Go to the source code of this file.

Functions

ideal SCAQuotient (const ring r)
 
static short scaFirstAltVar (ring r)
 
static short scaLastAltVar (ring r)
 
static void scaFirstAltVar (ring r, short n)
 
static void scaLastAltVar (ring r, short n)
 
poly sca_pp_Mult_xi_pp (short i, const poly pPoly, const ring rRing)
 
bool p_IsBiHomogeneous (const poly p, const intvec *wx, const intvec *wy, const intvec *wCx, const intvec *wCy, int &dx, int &dy, const ring r)
 
bool id_IsBiHomogeneous (const ideal id, const intvec *wx, const intvec *wy, const intvec *wCx, const intvec *wCy, const ring r)
 
intvecivGetSCAXVarWeights (const ring r)
 
intvecivGetSCAYVarWeights (const ring r)
 
static bool p_IsSCAHomogeneous (const poly p, const intvec *wCx, const intvec *wCy, const ring r)
 
static bool id_IsSCAHomogeneous (const ideal id, const intvec *wCx, const intvec *wCy, const ring r)
 
poly p_KillSquares (const poly p, const short iFirstAltVar, const short iLastAltVar, const ring r)
 
ideal id_KillSquares (const ideal id, const short iFirstAltVar, const short iLastAltVar, const ring r, const bool bSkipZeroes=false)
 
bool sca_Force (ring rGR, int b, int e)
 
void sca_p_ProcsSet (ring rGR, p_Procs_s *p_Procs)
 
bool sca_SetupQuotient (ring rGR, ring rG, bool bCopy)
 

Function Documentation

◆ id_IsBiHomogeneous()

bool id_IsBiHomogeneous ( const ideal  id,
const intvec wx,
const intvec wy,
const intvec wCx,
const intvec wCy,
const ring  r 
)

Definition at line 1357 of file sca.cc.

1363 {
1364  if (id == NULL) return true; // zero ideal
1365 
1366  const int iSize = IDELEMS(id);
1367 
1368  if (iSize == 0) return true;
1369 
1370  bool b = true;
1371  int x, y;
1372 
1373  for(int i = iSize - 1; (i >= 0 ) && b; i--)
1374  b = p_IsBiHomogeneous(id->m[i], wx, wy, wCx, wCy, x, y, r);
1375 

◆ id_IsSCAHomogeneous()

static bool id_IsSCAHomogeneous ( const ideal  id,
const intvec wCx,
const intvec wCy,
const ring  r 
)
inlinestatic

Definition at line 115 of file sca.h.

118 {
119  // inefficient! don't use it in time-critical code!
120  intvec *wx = ivGetSCAXVarWeights(r);
121  intvec *wy = ivGetSCAYVarWeights(r);
122 
123  bool homog = id_IsBiHomogeneous( id, wx, wy, wCx, wCy, r );
124 
125  delete wx;
126  delete wy;
127 
128  return homog;
129 }

◆ id_KillSquares()

ideal id_KillSquares ( const ideal  id,
const short  iFirstAltVar,
const short  iLastAltVar,
const ring  r,
const bool  bSkipZeroes = false 
)

Definition at line 1518 of file sca.cc.

1523 {
1524  if (id == NULL) return id; // zero ideal
1525 
1526  assume( (iFirstAltVar >= 1) && (iLastAltVar <= rVar(r)) && (iFirstAltVar <= iLastAltVar) );
1527 
1528  const int iSize = IDELEMS(id);
1529 
1530  if (iSize == 0) return id;
1531 
1532  ideal temp = idInit(iSize, id->rank);
1533 
1534 #if 0
1535  PrintS("<id_KillSquares>\n");
1536  {
1537  PrintS("ideal id: \n");
1538  for (unsigned int i = 0; i < IDELEMS(id); i++)
1539  {
1540  Print("; id[%d] = ", i+1);
1541  p_Write(id->m[i], r);
1542  }
1543  PrintS(";\n");
1544  PrintLn();
1545  }
1546 #endif
1547 
1548 
1549  for (int j = 0; j < iSize; j++)
1550  temp->m[j] = p_KillSquares(id->m[j], iFirstAltVar, iLastAltVar, r);
1551 
1552  if( bSkipZeroes )
1553  idSkipZeroes(temp);
1554 
1555 #if 0
1556  PrintS("<id_KillSquares>\n");
1557  {
1558  PrintS("ideal temp: \n");
1559  for (int i = 0; i < IDELEMS(temp); i++)
1560  {
1561  Print("; temp[%d] = ", i+1);
1562  p_Write(temp->m[i], r);
1563  }
1564  PrintS(";\n");
1565  PrintLn();
1566  }
1567  PrintS("</id_KillSquares>\n");
1568 #endif
1569 
1570 // temp->rank = idRankFreeModule(temp, r);
1571 

◆ ivGetSCAXVarWeights()

intvec* ivGetSCAXVarWeights ( const ring  r)

Definition at line 1381 of file sca.cc.

1384 {
1385  const unsigned int N = r->N;
1386 
1387  const int CommutativeVariable = 0; // bug correction!
1388  const int AntiCommutativeVariable = 0;
1389 
1390  intvec* w = new intvec(N, 1, CommutativeVariable);
1391 
1392  if(AntiCommutativeVariable != CommutativeVariable)
1393  if( rIsSCA(r) )
1394  {
1395  const unsigned int m_iFirstAltVar = scaFirstAltVar(r);
1396  const unsigned int m_iLastAltVar = scaLastAltVar(r);
1397 
1398  for (unsigned int i = m_iFirstAltVar; i<= m_iLastAltVar; i++)
1399  {
1400  (*w)[i-1] = AntiCommutativeVariable;
1401  }
1402  }
1403 

◆ ivGetSCAYVarWeights()

intvec* ivGetSCAYVarWeights ( const ring  r)

Definition at line 1409 of file sca.cc.

1412 {
1413  const unsigned int N = r->N;
1414 
1415  const int CommutativeVariable = 0;
1416  const int AntiCommutativeVariable = 1;
1417 
1418  intvec* w = new intvec(N, 1, CommutativeVariable);
1419 
1420  if(AntiCommutativeVariable != CommutativeVariable)
1421  if( rIsSCA(r) )
1422  {
1423  const unsigned int m_iFirstAltVar = scaFirstAltVar(r);
1424  const unsigned int m_iLastAltVar = scaLastAltVar(r);
1425 
1426  for (unsigned int i = m_iFirstAltVar; i<= m_iLastAltVar; i++)
1427  {
1428  (*w)[i-1] = AntiCommutativeVariable;
1429  }
1430  }

◆ p_IsBiHomogeneous()

bool p_IsBiHomogeneous ( const poly  p,
const intvec wx,
const intvec wy,
const intvec wCx,
const intvec wCy,
int &  dx,
int &  dy,
const ring  r 
)

Definition at line 1318 of file sca.cc.

1325 {
1326  if( p == NULL )
1327  {
1328  dx = 0;
1329  dy = 0;
1330  return true;
1331  }
1332 
1333  poly q = p;
1334 
1335 
1336  int ddx, ddy;
1337 
1338  m_GetBiDegree( q, wx, wy, wCx, wCy, ddx, ddy, r); // get bi degree of lm(p)
1339 
1340  pIter(q);
1341 
1342  for(; q != NULL; pIter(q) )
1343  {
1344  int x, y;
1345 
1346  m_GetBiDegree( q, wx, wy, wCx, wCy, x, y, r); // get bi degree of q
1347 
1348  if ( (x != ddx) || (y != ddy) ) return false;
1349  }
1350 
1351  dx = ddx;
1352  dy = ddy;
1353 

◆ p_IsSCAHomogeneous()

static bool p_IsSCAHomogeneous ( const poly  p,
const intvec wCx,
const intvec wCy,
const ring  r 
)
inlinestatic

Definition at line 96 of file sca.h.

99 {
100  // inefficient! don't use it in time-critical code!
101  intvec *wx = ivGetSCAXVarWeights(r);
102  intvec *wy = ivGetSCAYVarWeights(r);
103 
104  int x,y;
105 
106  bool homog = p_IsBiHomogeneous( p, wx, wy, wCx, wCy, x, y, r );
107 
108  delete wx;
109  delete wy;
110 
111  return homog;
112 }

◆ p_KillSquares()

poly p_KillSquares ( const poly  p,
const short  iFirstAltVar,
const short  iLastAltVar,
const ring  r 
)

Definition at line 1463 of file sca.cc.

1468 {
1469 #ifdef PDEBUG
1470  p_Test(p, r);
1471 
1472  assume( (iFirstAltVar >= 1) && (iLastAltVar <= r->N) && (iFirstAltVar <= iLastAltVar) );
1473 
1474 #if 0
1475  PrintS("p_KillSquares, p = "); // !
1476  p_Write(p, r);
1477 #endif
1478 #endif
1479 
1480 
1481  if( p == NULL )
1482  return NULL;
1483 
1484  poly pResult = NULL;
1485  poly* ppPrev = &pResult;
1486 
1487  for( poly q = p; q!= NULL; pIter(q) )
1488  {
1489 #ifdef PDEBUG
1490  p_Test(q, r);
1491 #endif
1492 
1493  // terms will be in the same order because of quasi-ordering!
1494  poly v = m_KillSquares(q, iFirstAltVar, iLastAltVar, r);
1495 
1496  if( v != NULL )
1497  {
1498  *ppPrev = v;
1499  ppPrev = &pNext(v);
1500  }
1501 
1502  }
1503 
1504 #ifdef PDEBUG
1505  p_Test(pResult, r);
1506 #if 0
1507  PrintS("p_KillSquares => "); // !
1508  p_Write(pResult, r);
1509 #endif
1510 #endif
1511 

◆ sca_Force()

bool sca_Force ( ring  rGR,
int  b,
int  e 
)

Definition at line 1159 of file sca.cc.

1162 {
1163  assume(rGR != NULL);
1164  assume(rIsPluralRing(rGR));
1165  assume(!rIsSCA(rGR));
1166 
1167  const int N = rGR->N;
1168 
1169 // ring rSaveRing = currRing;
1170 // if(rSaveRing != rGR)
1171 // rChangeCurrRing(rGR);
1172 
1173  const ideal idQuotient = rGR->qideal;
1174 
1175  ideal tempQ = idQuotient;
1176 
1177  if( b <= N && e >= 1 )
1178  tempQ = id_KillSquares(idQuotient, b, e, rGR);
1179 
1180  idSkipZeroes( tempQ );
1181 
1182  ncRingType( rGR, nc_exterior );
1183 
1184  if( idIs0(tempQ) )
1185  rGR->GetNC()->SCAQuotient() = NULL;
1186  else
1187  rGR->GetNC()->SCAQuotient() = tempQ;
1188 
1189 
1190  scaFirstAltVar( rGR, b );
1191  scaLastAltVar( rGR, e );
1192 
1193 
1194  nc_p_ProcsSet(rGR, rGR->p_Procs);
1195 
1196 // if(rSaveRing != rGR)
1197 // rChangeCurrRing(rSaveRing);
1198 

◆ sca_p_ProcsSet()

void sca_p_ProcsSet ( ring  rGR,
p_Procs_s p_Procs 
)

Definition at line 1223 of file sca.cc.

1226 {
1227 
1228  // "commutative" procedures:
1229  rGR->p_Procs->p_Mult_mm = sca_p_Mult_mm;
1230  rGR->p_Procs->pp_Mult_mm = sca_pp_Mult_mm;
1231 
1232  p_Procs->p_Mult_mm = sca_p_Mult_mm;
1233  p_Procs->pp_Mult_mm = sca_pp_Mult_mm;
1234 
1235  // non-commutaitve
1236  rGR->GetNC()->p_Procs.mm_Mult_p = sca_mm_Mult_p;
1237  rGR->GetNC()->p_Procs.mm_Mult_pp = sca_mm_Mult_pp;
1238 
1239 // rGR->GetNC()->p_Procs.SPoly = sca_SPoly;
1240 // rGR->GetNC()->p_Procs.ReduceSPoly = sca_ReduceSpoly;
1241 
1242 #if 0
1243 
1244  // Multiplication procedures:
1245 
1246  p_Procs->p_Mult_mm = sca_p_Mult_mm;
1247  _p_procs->p_Mult_mm = sca_p_Mult_mm;
1248 
1249  p_Procs->pp_Mult_mm = sca_pp_Mult_mm;
1250  _p_procs->pp_Mult_mm = sca_pp_Mult_mm;
1251 
1252  r->GetNC()->mmMultP() = sca_mm_Mult_p;
1253  r->GetNC()->mmMultPP() = sca_mm_Mult_pp;
1254 
1255 /*
1256  // ??????????????????????????????????????? coefficients swell...
1257  r->GetNC()->SPoly() = sca_SPoly;
1258  r->GetNC()->ReduceSPoly() = sca_ReduceSpoly;
1259 */
1260 // r->GetNC()->BucketPolyRed() = gnc_kBucketPolyRed;
1261 // r->GetNC()->BucketPolyRed_Z()= gnc_kBucketPolyRed_Z;
1262 #endif
1263 
1264  // local ordering => Mora, otherwise - Buchberger!
1265  if (rHasLocalOrMixedOrdering(rGR))
1266  rGR->GetNC()->p_Procs.GB = cast_A_to_vptr(sca_mora);
1267  else

◆ sca_pp_Mult_xi_pp()

poly sca_pp_Mult_xi_pp ( short  i,
const poly  pPoly,
const ring  rRing 
)

Definition at line 1201 of file sca.cc.

1204 {
1205  assume(1 <= i);
1206  assume(i <= rVar(rRing));
1207 
1208  if(rIsSCA(rRing))
1209  return sca_xi_Mult_pp(i, pPoly, rRing);
1210 
1211 
1212 
1213  poly xi = p_One( rRing);
1214  p_SetExp(xi, i, 1, rRing);
1215  p_Setm(xi, rRing);
1216 
1217  poly pResult = pp_Mult_qq(xi, pPoly, rRing);
1218 
1219  p_Delete( &xi, rRing);
1220 
1221  return pResult;

◆ sca_SetupQuotient()

bool sca_SetupQuotient ( ring  rGR,
ring  rG,
bool  bCopy 
)

Definition at line 909 of file sca.cc.

912 {
913 
914  //////////////////////////////////////////////////////////////////////////
915  // checks...
916  //////////////////////////////////////////////////////////////////////////
917  if( rG == NULL )
918  rG = rGR;
919 
920  assume(rGR != NULL);
921  assume(rG != NULL);
922  assume(rIsPluralRing(rG));
923 
924 #if ((defined(PDEBUG) && OUTPUT) || MYTEST)
925  PrintS("sca_SetupQuotient(rGR, rG, bCopy)");
926 
927  {
928  PrintS("\nrG: \n"); rWrite(rG);
929  PrintS("\nrGR: \n"); rWrite(rGR);
930  PrintLn();
931  }
932 #endif
933 
934 
935  if(bCopy)
936  {
937  if(rIsSCA(rG) && (rG != rGR))
938  return sca_Force(rGR, scaFirstAltVar(rG), scaLastAltVar(rG));
939  else
940  return false;
941  }
942 
943  assume(!bCopy);
944 
945  const int N = rG->N;
946 
947  if(N < 2)
948  return false;
949 
950 
951 // if( (ncRingType(rG) != nc_skew) || (ncRingType(rG) != nc_comm) )
952 // return false;
953 
954 #if OUTPUT
955  PrintS("sca_SetupQuotient: qring?\n");
956 #endif
957 
958  if(rGR->qideal == NULL) // there should be a factor!
959  return false;
960 
961 #if OUTPUT
962  PrintS("sca_SetupQuotient: qideal!!!\n");
963 #endif
964 
965 // if((rG->qideal != NULL) && (rG != rGR) ) // we cannot change from factor to factor at the time, sorry!
966 // return false;
967 
968 
969  int iAltVarEnd = -1;
970  int iAltVarStart = N+1;
971 
972  const nc_struct* NC = rG->GetNC();
973  const ring rBase = rG; //NC->basering;
974  const matrix C = NC->C; // live in rBase!
975  const matrix D = NC->D; // live in rBase!
976 
977 #if OUTPUT
978  PrintS("sca_SetupQuotient: AltVars?!\n");
979 #endif
980 
981  for(int i = 1; i < N; i++)
982  {
983  for(int j = i + 1; j <= N; j++)
984  {
985  if( MATELEM(D,i,j) != NULL) // !!!???
986  {
987 #if ((defined(PDEBUG) && OUTPUT) || MYTEST)
988  Print("Nonzero D[%d, %d]\n", i, j);
989 #endif
990  return false;
991  }
992 
993 
994  assume(MATELEM(C,i,j) != NULL); // after CallPlural!
995  number c = p_GetCoeff(MATELEM(C,i,j), rBase);
996 
997  if( n_IsMOne(c, rBase->cf) ) // !!!???
998  {
999  if( i < iAltVarStart)
1000  iAltVarStart = i;
1001 
1002  if( j > iAltVarEnd)
1003  iAltVarEnd = j;
1004  } else
1005  {
1006  if( !n_IsOne(c, rBase->cf) )
1007  {
1008 #if ((defined(PDEBUG) && OUTPUT) || MYTEST)
1009  Print("Wrong Coeff at: [%d, %d]\n", i, j);
1010 #endif
1011  return false;
1012  }
1013  }
1014  }
1015  }
1016 
1017 #if ((defined(PDEBUG) && OUTPUT) || MYTEST)
1018  Print("AltVars?1: [%d, %d]\n", iAltVarStart, iAltVarEnd);
1019 #endif
1020 
1021 
1022  if( (iAltVarEnd == -1) || (iAltVarStart == (N+1)) )
1023  return false; // either no alternating varables, or a single one => we are in commutative case!
1024 
1025 
1026  for(int i = 1; i < N; i++)
1027  {
1028  for(int j = i + 1; j <= N; j++)
1029  {
1030  assume(MATELEM(C,i,j) != NULL); // after CallPlural!
1031  number c = p_GetCoeff(MATELEM(C,i,j), rBase);
1032 
1033  if( (iAltVarStart <= i) && (j <= iAltVarEnd) ) // S <= i < j <= E
1034  { // anticommutative part
1035  if( !n_IsMOne(c, rBase->cf) )
1036  {
1037 #if ((defined(PDEBUG) && OUTPUT) || MYTEST)
1038  Print("Wrong Coeff at: [%d, %d]\n", i, j);
1039 #endif
1040  return false;
1041  }
1042  }
1043  else
1044  { // should commute
1045  if( !n_IsOne(c, rBase->cf) )
1046  {
1047 #if ((defined(PDEBUG) && OUTPUT) || MYTEST)
1048  Print("Wrong Coeff at: [%d, %d]\n", i, j);
1049 #endif
1050  return false;
1051  }
1052  }
1053  }
1054  }
1055 
1056 #if ((defined(PDEBUG) && OUTPUT) || MYTEST)
1057  Print("AltVars!?: [%d, %d]\n", iAltVarStart, iAltVarEnd);
1058 #endif
1059 
1060  assume( 1 <= iAltVarStart );
1061  assume( iAltVarStart < iAltVarEnd );
1062  assume( iAltVarEnd <= N );
1063 
1064 
1065 // ring rSaveRing = assureCurrentRing(rG);
1066 
1067 
1068  assume(rGR->qideal != NULL);
1069  assume(rGR->N == rG->N);
1070 // assume(rG->qideal == NULL); // ?
1071 
1072  const ideal idQuotient = rGR->qideal;
1073 
1074 
1075 #if ((defined(PDEBUG) && OUTPUT) || MYTEST)
1076  PrintS("Analyzing quotient ideal:\n");
1077  idPrint(idQuotient); // in rG!!!
1078 #endif
1079 
1080 
1081  // check for
1082  // y_{iAltVarStart}^2, y_{iAltVarStart+1}^2, \ldots, y_{iAltVarEnd}^2 (iAltVarEnd > iAltVarStart)
1083  // to be within quotient ideal.
1084 
1085  int b = N+1;
1086  int e = -1;
1087 
1088  if(rIsSCA(rG))
1089  {
1090  b = si_min(b, scaFirstAltVar(rG));
1091  e = si_max(e, scaLastAltVar(rG));
1092 
1093 #if ((defined(PDEBUG) && OUTPUT) || MYTEST)
1094  Print("AltVars!?: [%d, %d]\n", b, e);
1095 #endif
1096  }
1097 
1098  for ( int i = iAltVarStart; (i <= iAltVarEnd); i++ )
1099  if( (i < b) || (i > e) ) // otherwise it's ok since rG is an SCA!
1100  {
1101  poly square = p_One( rG);
1102  p_SetExp(square, i, 2, rG); // square = var(i)^2.
1103  p_Setm(square, rG);
1104 
1105  // square = NF( var(i)^2 | Q )
1106  // NOTE: there is no better way to check this in general!
1107  square = nc_NF(idQuotient, NULL, square, 0, 1, rG); // must ran in currRing == rG!
1108 
1109  if( square != NULL ) // var(i)^2 is not in Q?
1110  {
1111  p_Delete(&square, rG);
1112  return false;
1113  }
1114  }
1115 
1116 #if ((defined(PDEBUG) && OUTPUT) || MYTEST)
1117  Print("ScaVars!: [%d, %d]\n", iAltVarStart, iAltVarEnd);
1118 #endif
1119 
1120 
1121  //////////////////////////////////////////////////////////////////////////
1122  // ok... here we go. let's setup it!!!
1123  //////////////////////////////////////////////////////////////////////////
1124  ideal tempQ = id_KillSquares(idQuotient, iAltVarStart, iAltVarEnd, rG); // in rG!!!
1125 
1126 
1127 #if ((defined(PDEBUG) && OUTPUT) || MYTEST)
1128  PrintS("Quotient: \n");
1129  iiWriteMatrix((matrix)idQuotient,"__",1, rG, 0);
1130  PrintS("tempSCAQuotient: \n");
1131  iiWriteMatrix((matrix)tempQ,"__",1, rG, 0);
1132 #endif
1133 
1134  idSkipZeroes( tempQ );
1135 
1136  ncRingType( rGR, nc_exterior );
1137 
1138  scaFirstAltVar( rGR, iAltVarStart );
1139  scaLastAltVar( rGR, iAltVarEnd );
1140 
1141  if( idIs0(tempQ) )
1142  rGR->GetNC()->SCAQuotient() = NULL;
1143  else
1144  rGR->GetNC()->SCAQuotient() = idrMoveR(tempQ, rG, rGR); // deletes tempQ!
1145 
1146  nc_p_ProcsSet(rGR, rGR->p_Procs); // !!!!!!!!!!!!!!!!!
1147 
1148 
1149 #if ((defined(PDEBUG) && OUTPUT) || MYTEST)
1150  PrintS("SCAQuotient: \n");
1151  if(tempQ != NULL)
1152  iiWriteMatrix((matrix)tempQ,"__",1, rGR, 0);
1153  else
1154  PrintS("(NULL)\n");
1155 #endif
1156 

◆ scaFirstAltVar() [1/2]

static short scaFirstAltVar ( ring  r)
inlinestatic

Definition at line 18 of file sca.h.

19 {
20  assume(rIsSCA(r));
21 
22  return (r->GetNC()->FirstAltVar());
23 }

◆ scaFirstAltVar() [2/2]

static void scaFirstAltVar ( ring  r,
short  n 
)
inlinestatic

Definition at line 34 of file sca.h.

35 {
36  assume(rIsSCA(r));
37 
38  r->GetNC()->FirstAltVar() = n;
39 }

◆ scaLastAltVar() [1/2]

static short scaLastAltVar ( ring  r)
inlinestatic

Definition at line 25 of file sca.h.

26 {
27  assume(rIsSCA(r));
28 
29  return (r->GetNC()->LastAltVar());
30 }

◆ scaLastAltVar() [2/2]

static void scaLastAltVar ( ring  r,
short  n 
)
inlinestatic

Definition at line 41 of file sca.h.

42 {
43  assume(rIsSCA(r));
44 
45  r->GetNC()->LastAltVar() = n;
46 }

◆ SCAQuotient()

ideal SCAQuotient ( const ring  r)
inline

Definition at line 10 of file sca.h.

11 {
12  assume(rIsSCA(r));
13  return r->GetNC()->SCAQuotient();
14 }
nc_struct
Definition: nc.h:75
si_min
static int si_min(const int a, const int b)
Definition: auxiliary.h:139
nc_struct::C
matrix C
Definition: nc.h:83
p_GetCoeff
#define p_GetCoeff(p, r)
Definition: monomials.h:54
ip_smatrix
Definition: matpol.h:13
j
int j
Definition: facHensel.cc:105
cast_A_to_vptr
void * cast_A_to_vptr(A a)
Definition: auxiliary.h:398
sca_mm_Mult_p
static poly sca_mm_Mult_p(const poly pMonom, poly pPoly, const ring rRing)
Definition: sca.cc:633
x
Variable x
Definition: cfModGcd.cc:4023
MATELEM
#define MATELEM(mat, i, j)
Definition: matpol.h:28
y
const CanonicalForm int const CFList const Variable & y
Definition: facAbsFact.cc:57
sca_p_Mult_mm
poly sca_p_Mult_mm(poly pPoly, const poly pMonom, const ring rRing)
Definition: sca.cc:369
ncRingType
static nc_type & ncRingType(nc_struct *p)
Definition: nc.h:167
nc_exterior
Definition: nc.h:21
p_IsBiHomogeneous
bool p_IsBiHomogeneous(const poly p, const intvec *wx, const intvec *wy, const intvec *wCx, const intvec *wCy, int &dx, int &dy, const ring r)
Definition: sca.cc:1318
p_Test
#define p_Test(p, r)
Definition: p_polys.h:155
N
const CanonicalForm CFMap CFMap & N
Definition: cfEzgcd.cc:48
n_IsOne
static FORCE_INLINE BOOLEAN n_IsOne(number n, const coeffs r)
TRUE iff 'n' represents the one element.
Definition: coeffs.h:468
idIs0
BOOLEAN idIs0(ideal h)
returns true if h is the zero ideal
Definition: simpleideals.cc:767
w
const CanonicalForm & w
Definition: facAbsFact.cc:55
b
CanonicalForm b
Definition: cfModGcd.cc:4044
iiWriteMatrix
void iiWriteMatrix(matrix im, const char *n, int dim, const ring r, int spaces)
set spaces to zero by default
Definition: matpol.cc:733
p_KillSquares
poly p_KillSquares(const poly p, const short iFirstAltVar, const short iLastAltVar, const ring r)
Definition: sca.cc:1463
p_SetExp
static unsigned long p_SetExp(poly p, const unsigned long e, const unsigned long iBitmask, const int VarOffset)
set a single variable exponent @Note: VarOffset encodes the position in p->exp
Definition: p_polys.h:476
rIsPluralRing
static BOOLEAN rIsPluralRing(const ring r)
we must always have this test!
Definition: ring.h:403
sca_Force
bool sca_Force(ring rGR, int b, int e)
Definition: sca.cc:1159
rVar
static short rVar(const ring r)
#define rVar(r) (r->N)
Definition: ring.h:582
i
int i
Definition: cfEzgcd.cc:125
rHasLocalOrMixedOrdering
BOOLEAN rHasLocalOrMixedOrdering(const ring r)
Definition: ring.h:751
idrMoveR
ideal idrMoveR(ideal &id, ring src_r, ring dest_r)
Definition: prCopy.cc:248
PrintS
void PrintS(const char *s)
Definition: reporter.cc:283
m_KillSquares
static poly m_KillSquares(const poly m, const short iFirstAltVar, const short iLastAltVar, const ring r)
Definition: sca.cc:1437
scaFirstAltVar
static short scaFirstAltVar(ring r)
Definition: sca.h:18
idSkipZeroes
void idSkipZeroes(ideal ide)
gives an ideal/module the minimal possible size
Definition: simpleideals.cc:171
D
#define D(A)
Definition: gentable.cc:128
pp_Mult_qq
static poly pp_Mult_qq(poly p, poly q, const ring r)
Definition: p_polys.h:1078
p_Write
void p_Write(poly p, ring lmRing, ring tailRing)
Definition: polys0.cc:203
intvec
Definition: intvec.h:16
sca_mm_Mult_pp
static poly sca_mm_Mult_pp(const poly pMonom, const poly pPoly, const ring rRing)
Definition: sca.cc:565
pIter
#define pIter(p)
Definition: monomials.h:41
nc_p_ProcsSet
void nc_p_ProcsSet(ring rGR, p_Procs_s *p_Procs)
Definition: old.gring.cc:3204
p_IsBiHomogeneous
bool p_IsBiHomogeneous(const poly p, const intvec *wx, const intvec *wy, const intvec *wCx, const intvec *wCy, int &dx, int &dy, const ring r)
Definition: sca.cc:1318
ivGetSCAXVarWeights
intvec * ivGetSCAXVarWeights(const ring r)
Definition: sca.cc:1381
p_Delete
static void p_Delete(poly *p, const ring r)
Definition: p_polys.h:842
p_One
poly p_One(const ring r)
Definition: p_polys.cc:1302
idPrint
#define idPrint(id)
Definition: ideals.h:45
rWrite
void rWrite(ring r, BOOLEAN details)
Definition: ring.cc:226
si_max
static int si_max(const int a, const int b)
Definition: auxiliary.h:138
nc_NF
NF_Proc nc_NF
Definition: old.gring.cc:66
sca_pp_Mult_mm
poly sca_pp_Mult_mm(const poly pPoly, const poly pMonom, const ring rRing, poly &)
Print
#define Print
Definition: emacs.cc:79
scaLastAltVar
static short scaLastAltVar(ring r)
Definition: sca.h:25
idInit
ideal idInit(int idsize, int rank)
initialise an ideal / module
Definition: simpleideals.cc:36
n_IsMOne
static FORCE_INLINE BOOLEAN n_IsMOne(number n, const coeffs r)
TRUE iff 'n' represents the additive inverse of the one element, i.e. -1.
Definition: coeffs.h:472
id_KillSquares
ideal id_KillSquares(const ideal id, const short iFirstAltVar, const short iLastAltVar, const ring r, const bool bSkipZeroes)
Definition: sca.cc:1518
id_IsBiHomogeneous
bool id_IsBiHomogeneous(const ideal id, const intvec *wx, const intvec *wy, const intvec *wCx, const intvec *wCy, const ring r)
Definition: sca.cc:1357
m_GetBiDegree
static void m_GetBiDegree(const poly m, const intvec *wx, const intvec *wy, const intvec *wCx, const intvec *wCy, int &dx, int &dy, const ring r)
Definition: sca.cc:1273
assume
#define assume(x)
Definition: mod2.h:384
nc_struct::D
matrix D
Definition: nc.h:84
NULL
#define NULL
Definition: omList.c:9
p_Setm
static void p_Setm(poly p, const ring r)
Definition: p_polys.h:224
v
const Variable & v
< [in] a sqrfree bivariate poly
Definition: facBivar.h:37
sca_mora
BBA_Proc sca_mora
Definition: old.gring.cc:70
p
int p
Definition: cfModGcd.cc:4019
IDELEMS
#define IDELEMS(i)
Definition: simpleideals.h:24
PrintLn
void PrintLn()
Definition: reporter.cc:309
rIsSCA
static bool rIsSCA(const ring r)
Definition: nc.h:198
_p_procs
static p_Procs_s * _p_procs
Definition: p_Procs_Set.h:111
pNext
#define pNext(p)
Definition: monomials.h:40
sca_xi_Mult_pp
static poly sca_xi_Mult_pp(short i, const poly pPoly, const ring rRing)
Definition: sca.cc:521
ivGetSCAYVarWeights
intvec * ivGetSCAYVarWeights(const ring r)
Definition: sca.cc:1409