My Project
Loading...
Searching...
No Matches
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.

1361{
1362 if (id == NULL) return true; // zero ideal
1363
1364 const int iSize = IDELEMS(id);
1365
1366 if (iSize == 0) return true;
1367
1368 bool b = true;
1369 int x, y;
1370
1371 for(int i = iSize - 1; (i >= 0 ) && b; i--)
1372 b = p_IsBiHomogeneous(id->m[i], wx, wy, wCx, wCy, x, y, r);
1373
1374 return b;
1375}
int i
Definition cfEzgcd.cc:132
Variable x
Definition cfModGcd.cc:4090
CanonicalForm b
Definition cfModGcd.cc:4111
const CanonicalForm int const CFList const Variable & y
Definition facAbsFact.cc:53
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
#define NULL
Definition omList.c:12
#define IDELEMS(i)

◆ 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!
122
123 bool homog = id_IsBiHomogeneous( id, wx, wy, wCx, wCy, r );
124
125 delete wx;
126 delete wy;
127
128 return homog;
129}
intvec * ivGetSCAXVarWeights(const ring r)
Definition sca.cc:1381
intvec * ivGetSCAYVarWeights(const ring r)
Definition sca.cc:1409
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

◆ 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.

1521{
1522 if (id == NULL) return id; // zero ideal
1523
1524 assume( (iFirstAltVar >= 1) && (iLastAltVar <= rVar(r)) && (iFirstAltVar <= iLastAltVar) );
1525
1526 const int iSize = IDELEMS(id);
1527
1528 if (iSize == 0) return id;
1529
1530 ideal temp = idInit(iSize, id->rank);
1531
1532#if 0
1533 PrintS("<id_KillSquares>\n");
1534 {
1535 PrintS("ideal id: \n");
1536 for (unsigned int i = 0; i < IDELEMS(id); i++)
1537 {
1538 Print("; id[%d] = ", i+1);
1539 p_Write(id->m[i], r);
1540 }
1541 PrintS(";\n");
1542 PrintLn();
1543 }
1544#endif
1545
1546
1547 for (int j = 0; j < iSize; j++)
1548 temp->m[j] = p_KillSquares(id->m[j], iFirstAltVar, iLastAltVar, r);
1549
1550 if( bSkipZeroes )
1551 idSkipZeroes(temp);
1552
1553#if 0
1554 PrintS("<id_KillSquares>\n");
1555 {
1556 PrintS("ideal temp: \n");
1557 for (int i = 0; i < IDELEMS(temp); i++)
1558 {
1559 Print("; temp[%d] = ", i+1);
1560 p_Write(temp->m[i], r);
1561 }
1562 PrintS(";\n");
1563 PrintLn();
1564 }
1565 PrintS("</id_KillSquares>\n");
1566#endif
1567
1568// temp->rank = idRankFreeModule(temp, r);
1569
1570 return temp;
1571}
#define Print
Definition emacs.cc:80
int j
Definition facHensel.cc:110
poly p_KillSquares(const poly p, const short iFirstAltVar, const short iLastAltVar, const ring r)
Definition sca.cc:1463
#define assume(x)
Definition mod2.h:389
void p_Write(poly p, ring lmRing, ring tailRing)
Definition polys0.cc:342
void PrintS(const char *s)
Definition reporter.cc:284
void PrintLn()
Definition reporter.cc:310
static short rVar(const ring r)
#define rVar(r) (r->N)
Definition ring.h:598
ideal idInit(int idsize, int rank)
initialise an ideal / module
void idSkipZeroes(ideal ide)
gives an ideal/module the minimal possible size

◆ ivGetSCAXVarWeights()

intvec * ivGetSCAXVarWeights ( const ring r)

Definition at line 1381 of file sca.cc.

1382{
1383 const unsigned int N = r->N;
1384
1385 const int CommutativeVariable = 0; // bug correction!
1386 const int AntiCommutativeVariable = 0;
1387
1388 intvec* w = new intvec(N, 1, CommutativeVariable);
1389
1390 if(AntiCommutativeVariable != CommutativeVariable)
1391 if( rIsSCA(r) )
1392 {
1393 const unsigned int m_iFirstAltVar = scaFirstAltVar(r);
1394 const unsigned int m_iLastAltVar = scaLastAltVar(r);
1395
1396 for (unsigned int i = m_iFirstAltVar; i<= m_iLastAltVar; i++)
1397 {
1398 (*w)[i-1] = AntiCommutativeVariable;
1399 }
1400 }
1401
1402 return w;
1403}
const CanonicalForm CFMap CFMap & N
Definition cfEzgcd.cc:56
const CanonicalForm & w
Definition facAbsFact.cc:51
static bool rIsSCA(const ring r)
Definition nc.h:190
static short scaLastAltVar(ring r)
Definition sca.h:25
static short scaFirstAltVar(ring r)
Definition sca.h:18

◆ ivGetSCAYVarWeights()

intvec * ivGetSCAYVarWeights ( const ring r)

Definition at line 1409 of file sca.cc.

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

1323{
1324 if( p == NULL )
1325 {
1326 dx = 0;
1327 dy = 0;
1328 return true;
1329 }
1330
1331 poly q = p;
1332
1333
1334 int ddx, ddy;
1335
1336 m_GetBiDegree( q, wx, wy, wCx, wCy, ddx, ddy, r); // get bi degree of lm(p)
1337
1338 pIter(q);
1339
1340 for(; q != NULL; pIter(q) )
1341 {
1342 int x, y;
1343
1344 m_GetBiDegree( q, wx, wy, wCx, wCy, x, y, r); // get bi degree of q
1345
1346 if ( (x != ddx) || (y != ddy) ) return false;
1347 }
1348
1349 dx = ddx;
1350 dy = ddy;
1351
1352 return true;
1353}
int p
Definition cfModGcd.cc:4086
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
#define pIter(p)
Definition monomials.h:37

◆ 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!
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}
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_KillSquares()

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

Definition at line 1463 of file sca.cc.

1466{
1467#ifdef PDEBUG
1468 p_Test(p, r);
1469
1470 assume( (iFirstAltVar >= 1) && (iLastAltVar <= r->N) && (iFirstAltVar <= iLastAltVar) );
1471
1472#if 0
1473 PrintS("p_KillSquares, p = "); // !
1474 p_Write(p, r);
1475#endif
1476#endif
1477
1478
1479 if( p == NULL )
1480 return NULL;
1481
1482 poly pResult = NULL;
1483 poly* ppPrev = &pResult;
1484
1485 for( poly q = p; q!= NULL; pIter(q) )
1486 {
1487#ifdef PDEBUG
1488 p_Test(q, r);
1489#endif
1490
1491 // terms will be in the same order because of quasi-ordering!
1492 poly v = m_KillSquares(q, iFirstAltVar, iLastAltVar, r);
1493
1494 if( v != NULL )
1495 {
1496 *ppPrev = v;
1497 ppPrev = &pNext(v);
1498 }
1499
1500 }
1501
1502#ifdef PDEBUG
1503 p_Test(pResult, r);
1504#if 0
1505 PrintS("p_KillSquares => "); // !
1506 p_Write(pResult, r);
1507#endif
1508#endif
1509
1510 return(pResult);
1511}
const Variable & v
< [in] a sqrfree bivariate poly
Definition facBivar.h:39
static poly m_KillSquares(const poly m, const short iFirstAltVar, const short iLastAltVar, const ring r)
Definition sca.cc:1437
#define pNext(p)
Definition monomials.h:36
#define p_Test(p, r)
Definition p_polys.h:161

◆ sca_Force()

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

Definition at line 1159 of file sca.cc.

1160{
1161 assume(rGR != NULL);
1162 assume(rIsPluralRing(rGR));
1163 assume(!rIsSCA(rGR));
1164
1165 const int N = rGR->N;
1166
1167// ring rSaveRing = currRing;
1168// if(rSaveRing != rGR)
1169// rChangeCurrRing(rGR);
1170
1171 const ideal idQuotient = rGR->qideal;
1172
1173 ideal tempQ = idQuotient;
1174
1175 if( b <= N && e >= 1 )
1176 tempQ = id_KillSquares(idQuotient, b, e, rGR);
1177
1178 idSkipZeroes( tempQ );
1179
1180 ncRingType( rGR, nc_exterior );
1181
1182 if( idIs0(tempQ) )
1183 rGR->GetNC()->SCAQuotient() = NULL;
1184 else
1185 rGR->GetNC()->SCAQuotient() = tempQ;
1186
1187
1188 scaFirstAltVar( rGR, b );
1189 scaLastAltVar( rGR, e );
1190
1191
1192 nc_p_ProcsSet(rGR, rGR->p_Procs);
1193
1194// if(rSaveRing != rGR)
1195// rChangeCurrRing(rSaveRing);
1196
1197 return true;
1198}
BOOLEAN idIs0(ideal h)
returns true if h is the zero ideal
void nc_p_ProcsSet(ring rGR, p_Procs_s *p_Procs)
@ nc_exterior
Definition nc.h:21
static nc_type & ncRingType(nc_struct *p)
Definition nc.h:159
ideal id_KillSquares(const ideal id, const short iFirstAltVar, const short iLastAltVar, const ring r, const bool bSkipZeroes)
Definition sca.cc:1518
static BOOLEAN rIsPluralRing(const ring r)
we must always have this test!
Definition ring.h:406

◆ sca_p_ProcsSet()

void sca_p_ProcsSet ( ring rGR,
p_Procs_s * p_Procs )

Definition at line 1223 of file sca.cc.

1224{
1225
1226 // "commutative" procedures:
1227 rGR->p_Procs->p_Mult_mm = sca_p_Mult_mm;
1228 rGR->p_Procs->pp_Mult_mm = sca_pp_Mult_mm;
1229
1230 p_Procs->p_Mult_mm = sca_p_Mult_mm;
1231 p_Procs->pp_Mult_mm = sca_pp_Mult_mm;
1232
1233 // non-commutaitve
1234 p_Procs->p_mm_Mult = sca_p_mm_Mult;
1235 p_Procs->pp_mm_Mult = sca_pp_mm_Mult;
1236
1237// rGR->GetNC()->p_Procs.SPoly = sca_SPoly;
1238// rGR->GetNC()->p_Procs.ReduceSPoly = sca_ReduceSpoly;
1239
1240#if 0
1241
1242 // Multiplication procedures:
1243
1244 p_Procs->p_Mult_mm = sca_p_Mult_mm;
1245 _p_procs->p_Mult_mm = sca_p_Mult_mm;
1246
1247 p_Procs->pp_Mult_mm = sca_pp_Mult_mm;
1248 _p_procs->pp_Mult_mm = sca_pp_Mult_mm;
1249
1250 r->GetNC()->mmMultP() = sca_mm_Mult_p;
1251 r->GetNC()->mmMultPP() = sca_mm_Mult_pp;
1252
1253/*
1254 // ??????????????????????????????????????? coefficients swell...
1255 r->GetNC()->SPoly() = sca_SPoly;
1256 r->GetNC()->ReduceSPoly() = sca_ReduceSpoly;
1257*/
1258// r->GetNC()->BucketPolyRed() = gnc_kBucketPolyRed;
1259// r->GetNC()->BucketPolyRed_Z()= gnc_kBucketPolyRed_Z;
1260#endif
1261
1262 // local ordering => Mora, otherwise - Buchberger!
1263 if (rHasLocalOrMixedOrdering(rGR))
1264 rGR->GetNC()->p_Procs.GB = cast_A_to_vptr(sca_mora);
1265 else
1266 rGR->GetNC()->p_Procs.GB = cast_A_to_vptr(sca_bba); // sca_gr_bba?
1267}
void * cast_A_to_vptr(A a)
Definition auxiliary.h:386
EXTERN_VAR BBA_Proc sca_mora
Definition gb_hack.h:10
EXTERN_VAR BBA_Proc sca_bba
Definition gb_hack.h:10
static poly sca_p_mm_Mult(poly pPoly, const poly pMonom, const ring rRing)
Definition sca.cc:635
poly sca_pp_Mult_mm(const poly pPoly, const poly pMonom, const ring rRing, poly &)
poly sca_p_Mult_mm(poly pPoly, const poly pMonom, const ring rRing)
Definition sca.cc:371
static poly sca_pp_mm_Mult(const poly pPoly, const poly pMonom, const ring rRing)
Definition sca.cc:567
STATIC_VAR p_Procs_s * _p_procs
static BOOLEAN rHasLocalOrMixedOrdering(const ring r)
Definition ring.h:769

◆ 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.

1202{
1203 assume(1 <= i);
1204 assume(i <= rVar(rRing));
1205
1206 if(rIsSCA(rRing))
1207 return sca_xi_Mult_pp(i, pPoly, rRing);
1208
1209
1210
1211 poly xi = p_One( rRing);
1212 p_SetExp(xi, i, 1, rRing);
1213 p_Setm(xi, rRing);
1214
1215 poly pResult = pp_Mult_qq(xi, pPoly, rRing);
1216
1217 p_Delete( &xi, rRing);
1218
1219 return pResult;
1220
1221}
static poly sca_xi_Mult_pp(short i, const poly pPoly, const ring rRing)
Definition sca.cc:523
poly p_One(const ring r)
Definition p_polys.cc:1314
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:490
static void p_Setm(poly p, const ring r)
Definition p_polys.h:235
static void p_Delete(poly *p, const ring r)
Definition p_polys.h:903
static poly pp_Mult_qq(poly p, poly q, const ring r)
Definition p_polys.h:1162

◆ sca_SetupQuotient()

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

Definition at line 911 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);
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( (ncRingType(rG) != nc_skew) || (ncRingType(rG) != nc_comm) )
948// return false;
949
950#if OUTPUT
951 PrintS("sca_SetupQuotient: qring?\n");
952#endif
953
954 if(rGR->qideal == NULL) // there should be a factor!
955 return false;
956
957#if OUTPUT
958 PrintS("sca_SetupQuotient: qideal!!!\n");
959#endif
960
961// if((rG->qideal != NULL) && (rG != rGR) ) // we cannot change from factor to factor at the time, sorry!
962// return false;
963
964
965 int iAltVarEnd = -1;
966 int iAltVarStart = N+1;
967
968 const nc_struct* NC = rG->GetNC();
969 const ring rBase = rG; //NC->basering;
970 const matrix C = NC->C; // live in rBase!
971 const matrix D = NC->D; // live in rBase!
972
973#if OUTPUT
974 PrintS("sca_SetupQuotient: AltVars?!\n");
975#endif
976
977 for(int i = 1; i < N; i++)
978 {
979 for(int j = i + 1; j <= N; j++)
980 {
981 if( MATELEM(D,i,j) != NULL) // !!!???
982 {
983#if ((defined(PDEBUG) && OUTPUT) || MYTEST)
984 Print("Nonzero D[%d, %d]\n", i, j);
985#endif
986 return false;
987 }
988
989
990 assume(MATELEM(C,i,j) != NULL); // after CallPlural!
991 number c = p_GetCoeff(MATELEM(C,i,j), rBase);
992
993 if( n_IsMOne(c, rBase->cf) ) // !!!???
994 {
995 if( i < iAltVarStart)
996 iAltVarStart = i;
997
998 if( j > iAltVarEnd)
999 iAltVarEnd = j;
1000 } else
1001 {
1002 if( !n_IsOne(c, rBase->cf) )
1003 {
1004#if ((defined(PDEBUG) && OUTPUT) || MYTEST)
1005 Print("Wrong Coeff at: [%d, %d]\n", i, j);
1006#endif
1007 return false;
1008 }
1009 }
1010 }
1011 }
1012
1013#if ((defined(PDEBUG) && OUTPUT) || MYTEST)
1014 Print("AltVars?1: [%d, %d]\n", iAltVarStart, iAltVarEnd);
1015#endif
1016
1017
1018 if((iAltVarEnd == -1) || (iAltVarStart == (N+1)))
1019 {
1020 if (N>1) return false; // no alternating variables
1021 iAltVarEnd=iAltVarStart=1;
1022 }
1023
1024 for(int i = 1; i < N; i++)
1025 {
1026 for(int j = i + 1; j <= N; j++)
1027 {
1028 assume(MATELEM(C,i,j) != NULL); // after CallPlural!
1029 number c = p_GetCoeff(MATELEM(C,i,j), rBase);
1030
1031 if( (iAltVarStart <= i) && (j <= iAltVarEnd) ) // S <= i < j <= E
1032 { // anticommutative part
1033 if( !n_IsMOne(c, rBase->cf) )
1034 {
1035#if ((defined(PDEBUG) && OUTPUT) || MYTEST)
1036 Print("Wrong Coeff at: [%d, %d]\n", i, j);
1037#endif
1038 return false;
1039 }
1040 }
1041 else
1042 { // should commute
1043 if( !n_IsOne(c, rBase->cf) )
1044 {
1045#if ((defined(PDEBUG) && OUTPUT) || MYTEST)
1046 Print("Wrong Coeff at: [%d, %d]\n", i, j);
1047#endif
1048 return false;
1049 }
1050 }
1051 }
1052 }
1053
1054#if ((defined(PDEBUG) && OUTPUT) || MYTEST)
1055 Print("AltVars!?: [%d, %d]\n", iAltVarStart, iAltVarEnd);
1056#endif
1057
1058 assume( 1 <= iAltVarStart );
1059 assume( iAltVarStart <= iAltVarEnd );
1060 assume( iAltVarEnd <= N );
1061
1062
1063// ring rSaveRing = assureCurrentRing(rG);
1064
1065
1066 assume(rGR->qideal != NULL);
1067 assume(rGR->N == rG->N);
1068// assume(rG->qideal == NULL); // ?
1069
1070 const ideal idQuotient = rGR->qideal;
1071
1072
1073#if ((defined(PDEBUG) && OUTPUT) || MYTEST)
1074 PrintS("Analyzing quotient ideal:\n");
1075 idPrint(idQuotient); // in rG!!!
1076#endif
1077
1078
1079 // check for
1080 // y_{iAltVarStart}^2, y_{iAltVarStart+1}^2, \ldots, y_{iAltVarEnd}^2 (iAltVarEnd > iAltVarStart)
1081 // to be within quotient ideal.
1082
1083 int b = N+1;
1084 int e = -1;
1085
1086 if(rIsSCA(rG))
1087 {
1088 b = si_min(b, scaFirstAltVar(rG));
1089 e = si_max(e, scaLastAltVar(rG));
1090
1091#if ((defined(PDEBUG) && OUTPUT) || MYTEST)
1092 Print("AltVars!?: [%d, %d]\n", b, e);
1093#endif
1094 }
1095
1096 for ( int i = iAltVarStart; (i <= iAltVarEnd); i++ )
1097 if( (i < b) || (i > e) ) // otherwise it's ok since rG is an SCA!
1098 {
1099 poly square = p_One( rG);
1100 p_SetExp(square, i, 2, rG); // square = var(i)^2.
1101 p_Setm(square, rG);
1102
1103 // square = NF( var(i)^2 | Q )
1104 // NOTE: there is no better way to check this in general!
1105 square = nc_NF(idQuotient, NULL, square, 0, 1, rG); // must ran in currRing == rG!
1106
1107 if( square != NULL ) // var(i)^2 is not in Q?
1108 {
1109 p_Delete(&square, rG);
1110 return false;
1111 }
1112 }
1113
1114#if ((defined(PDEBUG) && OUTPUT) || MYTEST)
1115 Print("ScaVars!: [%d, %d]\n", iAltVarStart, iAltVarEnd);
1116#endif
1117
1118
1119 //////////////////////////////////////////////////////////////////////////
1120 // ok... here we go. let's setup it!!!
1121 //////////////////////////////////////////////////////////////////////////
1122 ideal tempQ = id_KillSquares(idQuotient, iAltVarStart, iAltVarEnd, rG); // in rG!!!
1123
1124
1125#if ((defined(PDEBUG) && OUTPUT) || MYTEST)
1126 PrintS("Quotient: \n");
1127 iiWriteMatrix((matrix)idQuotient,"__",1, rG, 0);
1128 PrintS("tempSCAQuotient: \n");
1129 iiWriteMatrix((matrix)tempQ,"__",1, rG, 0);
1130#endif
1131
1132 idSkipZeroes( tempQ );
1133
1134 ncRingType( rGR, nc_exterior );
1135
1136 scaFirstAltVar( rGR, iAltVarStart );
1137 scaLastAltVar( rGR, iAltVarEnd );
1138
1139 if( idIs0(tempQ) )
1140 rGR->GetNC()->SCAQuotient() = NULL;
1141 else
1142 rGR->GetNC()->SCAQuotient() = idrMoveR(tempQ, rG, rGR); // deletes tempQ!
1143
1144 nc_p_ProcsSet(rGR, rGR->p_Procs); // !!!!!!!!!!!!!!!!!
1145
1146
1147#if ((defined(PDEBUG) && OUTPUT) || MYTEST)
1148 PrintS("SCAQuotient: \n");
1149 if(tempQ != NULL)
1150 iiWriteMatrix((matrix)tempQ,"__",1, rGR, 0);
1151 else
1152 PrintS("(NULL)\n");
1153#endif
1154
1155 return true;
1156}
static int si_max(const int a, const int b)
Definition auxiliary.h:125
static int si_min(const int a, const int b)
Definition auxiliary.h:126
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:476
static FORCE_INLINE BOOLEAN n_IsOne(number n, const coeffs r)
TRUE iff 'n' represents the one element.
Definition coeffs.h:472
EXTERN_VAR NF_Proc nc_NF
Definition gb_hack.h:9
#define D(A)
Definition gentable.cc:128
#define idPrint(id)
Definition ideals.h:46
bool sca_Force(ring rGR, int b, int e)
Definition sca.cc:1159
void iiWriteMatrix(matrix im, const char *n, int dim, const ring r, int spaces)
set spaces to zero by default
Definition matpol.cc:828
#define MATELEM(mat, i, j)
1-based access to matrix
Definition matpol.h:29
ip_smatrix * matrix
Definition matpol.h:43
#define p_GetCoeff(p, r)
Definition monomials.h:50
ideal idrMoveR(ideal &id, ring src_r, ring dest_r)
Definition prCopy.cc:248
void rWrite(ring r, BOOLEAN details)
Definition ring.cc:227
Definition nc.h:68
matrix C
Definition nc.h:75
matrix D
Definition nc.h:76

◆ 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}