#include "kernel/mod2.h"
#include "coeffs/numbers.h"
#include "polys/monomials/ring.h"
#include "polys/monomials/p_polys.h"
#include "polys/kbuckets.h"
#include "kernel/ideals.h"
#include "kernel/polys.h"
#include "kernel/GBEngine/kutil.h"
#include "kernel/GBEngine/janet.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include <time.h>
Go to the source code of this file.
|
int | ReducePolyLead (Poly *x, Poly *y) |
|
int | ReducePoly (Poly *x, poly from, Poly *y) |
|
void | PNF (Poly *p, TreeM *F) |
|
void | NFL (Poly *p, TreeM *F) |
|
int | ValidatePoly (Poly *x, TreeM *) |
|
Poly * | NewPoly (poly p) |
|
void | DestroyPoly (Poly *x) |
|
void | ControlProlong (Poly *x) |
|
void | InitHistory (Poly *p) |
|
void | InitLead (Poly *p) |
|
void | InitProl (Poly *p) |
|
int | GetMult (Poly *x, int i) |
|
void | SetMult (Poly *x, int i) |
|
void | ClearMult (Poly *x, int i) |
|
int | GetProl (Poly *x, int i) |
|
void | SetProl (Poly *x, int i) |
|
void | ClearProl (Poly *x, int i) |
|
int | LengthCompare (poly p1, poly p2) |
|
int | ProlCompare (Poly *item1, Poly *item2) |
|
void | ProlVar (Poly *temp, int i) |
|
void | DestroyListNode (ListNode *x) |
|
ListNode * | CreateListNode (Poly *x) |
|
Poly * | FindMinList (jList *L) |
|
void | InsertInList (jList *x, Poly *y) |
|
void | InsertInCount (jList *x, Poly *y) |
|
int | ListGreatMoveOrder (jList *A, jList *B, poly x) |
|
int | ListGreatMoveDegree (jList *A, jList *B, poly x) |
|
int | CountList (jList *Q) |
|
void | NFListQ () |
|
void | ForEachPNF (jList *x, int i) |
|
void | ForEachControlProlong (jList *x) |
|
void | DestroyList (jList *x) |
|
Poly * | is_present (jList *F, poly x) |
|
int | GB_length () |
|
NodeM * | create () |
|
void | DestroyFreeNodes () |
|
void | DestroyTree (NodeM *G) |
|
void | Define (TreeM **G) |
|
int | sp_div (poly m1, poly m2, int from) |
|
void | div_l (poly item, NodeM *x, int from) |
|
Poly * | is_div_upper (poly item, NodeM *x, int from) |
|
Poly * | is_div_ (TreeM *tree, poly item) |
|
static void | ClearMultiplicative (NodeM *xx, int i) |
|
void | insert_ (TreeM **tree, Poly *item) |
|
void | Initialization (char *Ord) |
|
void | T2G () |
|
int | ComputeBasis (jList *_lT, jList *_lQ) |
|
◆ pow_
◆ ClearMult()
void ClearMult |
( |
Poly * |
x, |
|
|
int |
i |
|
) |
| |
◆ ClearMultiplicative()
static void ClearMultiplicative |
( |
NodeM * |
xx, |
|
|
int |
i |
|
) |
| |
|
static |
Definition at line 894 of file janet.cc.
903 if ((xx->ended) && (
GetMult(xx->ended,
i)))
static void ClearMultiplicative(NodeM *xx, int i)
void ClearMult(Poly *x, int i)
void ProlVar(Poly *temp, int i)
int GetMult(Poly *x, int i)
◆ ClearProl()
void ClearProl |
( |
Poly * |
x, |
|
|
int |
i |
|
) |
| |
◆ ComputeBasis()
Definition at line 1000 of file janet.cc.
1036 WarnS(
"Constant in basis\n");
STATIC_VAR int degree_compatible
void insert_(TreeM **tree, Poly *item)
Poly * FindMinList(jList *L)
void ControlProlong(Poly *x)
int ValidatePoly(Poly *x, TreeM *)
void DestroyPoly(Poly *x)
#define pIsConstant(p)
like above, except that Comp must be 0
void InsertInList(jList *x, Poly *y)
void ForEachPNF(jList *x, int i)
void ForEachControlProlong(jList *x)
void DestroyTree(NodeM *G)
STATIC_VAR int(* ListGreatMove)(jList *, jList *, poly)
void PNF(Poly *p, TreeM *F)
void NFL(Poly *p, TreeM *F)
◆ ControlProlong()
void ControlProlong |
( |
Poly * |
x | ) |
|
◆ CountList()
int CountList |
( |
jList * |
Q | ) |
|
Definition at line 617 of file janet.cc.
const CanonicalForm int const CFList const Variable & y
◆ create()
Definition at line 757 of file janet.cc.
771 y->left=y->right=
NULL;
const CanonicalForm int const CFList const Variable & y
STATIC_VAR NodeM * FreeNodes
◆ CreateListNode()
◆ Define()
void Define |
( |
TreeM ** |
G | ) |
|
◆ DestroyFreeNodes()
void DestroyFreeNodes |
( |
| ) |
|
Definition at line 776 of file janet.cc.
const CanonicalForm int const CFList const Variable & y
STATIC_VAR NodeM * FreeNodes
◆ DestroyList()
void DestroyList |
( |
jList * |
x | ) |
|
Definition at line 714 of file janet.cc.
const CanonicalForm int const CFList const Variable & y
void DestroyPoly(Poly *x)
◆ DestroyListNode()
Definition at line 502 of file janet.cc.
void DestroyPoly(Poly *x)
◆ DestroyPoly()
void DestroyPoly |
( |
Poly * |
x | ) |
|
Definition at line 383 of file janet.cc.
static void pLmFree(poly p)
frees the space of the monomial m, assumes m != NULL coef is not freed, m is not advanced ...
◆ DestroyTree()
void DestroyTree |
( |
NodeM * |
G | ) |
|
Definition at line 804 of file janet.cc.
STATIC_VAR NodeM * FreeNodes
void DestroyTree(NodeM *G)
◆ div_l()
void div_l |
( |
poly |
item, |
|
|
NodeM * |
x, |
|
|
int |
from |
|
) |
| |
Definition at line 832 of file janet.cc.
837 if ((
x->ended) &&
sp_div(item,
x->ended->root,from))
842 div_l(item,
x->right,from);
void div_l(poly item, NodeM *x, int from)
int sp_div(poly m1, poly m2, int from)
◆ FindMinList()
Definition at line 517 of file janet.cc.
526 while ((*min) && ((*min)->info->root ==
NULL))
530 if (!(*min))
return NULL;
536 if ((*l)->info->root !=
NULL)
STATIC_VAR int degree_compatible
static int min(int a, int b)
int ProlCompare(Poly *item1, Poly *item2)
◆ ForEachControlProlong()
void ForEachControlProlong |
( |
jList * |
x | ) |
|
Definition at line 703 of file janet.cc.
const CanonicalForm int const CFList const Variable & y
void ControlProlong(Poly *x)
◆ ForEachPNF()
void ForEachPNF |
( |
jList * |
x, |
|
|
int |
i |
|
) |
| |
Definition at line 692 of file janet.cc.
698 if (
pow_(y->info->root) ==
i)
PNF(y->info,
G);
const CanonicalForm int const CFList const Variable & y
void PNF(Poly *p, TreeM *F)
◆ GB_length()
Definition at line 740 of file janet.cc.
747 if (
pow_(iT->info->lead) ==
pow_(iT->info->history))
◆ GetMult()
int GetMult |
( |
Poly * |
x, |
|
|
int |
i |
|
) |
| |
◆ GetProl()
int GetProl |
( |
Poly * |
x, |
|
|
int |
i |
|
) |
| |
◆ InitHistory()
void InitHistory |
( |
Poly * |
p | ) |
|
Definition at line 402 of file janet.cc.
#define pLmInit(p)
like pInit, except that expvector is initialized to that of p, p must be != NULL
static void pLmFree(poly p)
frees the space of the monomial m, assumes m != NULL coef is not freed, m is not advanced ...
◆ Initialization()
void Initialization |
( |
char * |
Ord | ) |
|
Definition at line 952 of file janet.cc.
955 if (strstr(Ord,
"dp\0") || strstr(Ord,
"Dp\0"))
STATIC_VAR int degree_compatible
int ListGreatMoveDegree(jList *A, jList *B, poly x)
static long p_Totaldegree(poly p, const ring r)
int ListGreatMoveOrder(jList *A, jList *B, poly x)
VAR ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
long p_Deg(poly a, const ring r)
STATIC_VAR int(* ListGreatMove)(jList *, jList *, poly)
◆ InitLead()
void InitLead |
( |
Poly * |
p | ) |
|
Definition at line 409 of file janet.cc.
#define pLmInit(p)
like pInit, except that expvector is initialized to that of p, p must be != NULL
static void pLmFree(poly p)
frees the space of the monomial m, assumes m != NULL coef is not freed, m is not advanced ...
◆ InitProl()
void InitProl |
( |
Poly * |
p | ) |
|
◆ insert_()
Definition at line 912 of file janet.cc.
915 NodeM *curr=(*tree)->root;
917 for ( ; (i_con>=0) && !
pGetExp(item->
root,i_con+1) ; i_con--)
920 for (i = 0; i<= i_con; i++)
941 if (!curr->left)
SetMult(item,i);
942 if (!curr->right) curr->right=
create();
static void ClearMultiplicative(NodeM *xx, int i)
void ClearMult(Poly *x, int i)
void ProlVar(Poly *temp, int i)
VAR ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
#define pGetExp(p, i)
Exponent.
void SetMult(Poly *x, int i)
◆ InsertInCount()
Definition at line 571 of file janet.cc.
ListNode * CreateListNode(Poly *x)
◆ InsertInList()
Definition at line 552 of file janet.cc.
#define pLmCmp(p, q)
returns 0|1|-1 if p=q|p>q|p<q w.r.t monomial ordering
ListNode * CreateListNode(Poly *x)
◆ is_div_()
Definition at line 853 of file janet.cc.
856 NodeM *curr=tree->root;
858 if (!curr)
return NULL;
861 for ( ; i_con>=0 && !
pGetExp(item,i_con+1) ; i_con--)
864 for (i=0; i <= i_con ; i++)
870 if (curr->ended)
return curr->ended;
883 if (curr->ended)
return curr->ended;
885 if (!curr->right)
return NULL;
890 if (curr->ended)
return curr->ended;
VAR ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
#define pGetExp(p, i)
Exponent.
Poly * is_div_upper(poly item, NodeM *x, int from)
◆ is_div_upper()
Poly* is_div_upper |
( |
poly |
item, |
|
|
NodeM * |
x, |
|
|
int |
from |
|
) |
| |
Definition at line 846 of file janet.cc.
void div_l(poly item, NodeM *x, int from)
◆ is_present()
Definition at line 729 of file janet.cc.
733 if (
pLmCmp(iF->info->root,
x) == 0)
#define pLmCmp(p, q)
returns 0|1|-1 if p=q|p>q|p<q w.r.t monomial ordering
◆ LengthCompare()
int LengthCompare |
( |
poly |
p1, |
|
|
poly |
p2 |
|
) |
| |
Definition at line 451 of file janet.cc.
455 if (p1 ==
NULL)
return 1;
456 if (p2 ==
NULL)
return 0;
◆ ListGreatMoveDegree()
int ListGreatMoveDegree |
( |
jList * |
A, |
|
|
jList * |
B, |
|
|
poly |
x |
|
) |
| |
Definition at line 599 of file janet.cc.
604 if (!y ||
pow_(y->info->lead) <= pow_x)
return 0;
606 while(y &&
pow_(y->info->lead) > pow_x)
const CanonicalForm int const CFList const Variable & y
void InsertInCount(jList *x, Poly *y)
◆ ListGreatMoveOrder()
int ListGreatMoveOrder |
( |
jList * |
A, |
|
|
jList * |
B, |
|
|
poly |
x |
|
) |
| |
Definition at line 582 of file janet.cc.
586 if (!y ||
pLmCmp(y->info->lead,
x) < 0)
return 0;
588 while(y &&
pLmCmp(y->info->lead,
x) >= 0)
const CanonicalForm int const CFList const Variable & y
#define pLmCmp(p, q)
returns 0|1|-1 if p=q|p>q|p<q w.r.t monomial ordering
void InsertInCount(jList *x, Poly *y)
◆ NewPoly()
Definition at line 361 of file janet.cc.
void ClearMult(Poly *x, int i)
VAR ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
void ClearProl(Poly *x, int i)
◆ NFL()
Definition at line 187 of file janet.cc.
235 if ((pX == pF) && (pF == phF))
int status int void size_t count
void kBucketClear(kBucket_pt bucket, poly *p, int *length)
void kBucketInit(kBucket_pt bucket, poly lm, int length)
void p_ContentForGB(poly ph, const ring r)
int ReducePolyLead(Poly *x, Poly *y)
void p_SimpleContent(poly ph, int smax, const ring r)
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy ...
Poly * is_div_(TreeM *tree, poly item)
static poly p_Copy_noCheck(poly p, const ring r)
returns a copy of p (without any additional testing)
VAR ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
void kBucketDestroy(kBucket_pt *bucket_pt)
void InitHistory(Poly *p)
static void pLmFree(poly p)
frees the space of the monomial m, assumes m != NULL coef is not freed, m is not advanced ...
◆ NFListQ()
Definition at line 631 of file janet.cc.
647 int ploc=
pow_(ll->info->lead);
648 if (ploc < p) p=ploc;
659 int ploc=
pow_((*l)->info->lead);
671 (*l)->info->changed=0;
675 if (!(*l)->info->root)
void DestroyListNode(ListNode *x)
int ValidatePoly(Poly *x, TreeM *)
void NFL(Poly *p, TreeM *F)
◆ PNF()
Definition at line 143 of file janet.cc.
int status int void size_t count
void p_ContentForGB(poly ph, const ring r)
void p_SimpleContent(poly ph, int smax, const ring r)
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy ...
Poly * is_div_(TreeM *tree, poly item)
VAR ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
int ReducePoly(Poly *x, poly from, Poly *y)
◆ ProlCompare()
int ProlCompare |
( |
Poly * |
item1, |
|
|
Poly * |
item2 |
|
) |
| |
Definition at line 463 of file janet.cc.
int LengthCompare(poly p1, poly p2)
#define pLmCmp(p, q)
returns 0|1|-1 if p=q|p>q|p<q w.r.t monomial ordering
◆ ProlVar()
void ProlVar |
( |
Poly * |
temp, |
|
|
int |
i |
|
) |
| |
Definition at line 480 of file janet.cc.
void SetProl(Poly *x, int i)
int GetMult(Poly *x, int i)
#define pLmInit(p)
like pInit, except that expvector is initialized to that of p, p must be != NULL
void InsertInCount(jList *x, Poly *y)
int GetProl(Poly *x, int i)
◆ ReducePoly()
int ReducePoly |
( |
Poly * |
x, |
|
|
poly |
from, |
|
|
Poly * |
y |
|
) |
| |
Definition at line 119 of file janet.cc.
VAR ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
void ksOldSpolyTail(poly p1, poly q, poly q2, poly spNoether, ring r)
◆ ReducePolyLead()
int ReducePolyLead |
( |
Poly * |
x, |
|
|
Poly * |
y |
|
) |
| |
Definition at line 74 of file janet.cc.
void kBucketInit(kBucket_pt bucket, poly lm, int length)
number kBucketPolyRed(kBucket_pt bucket, poly p1, int l1, poly spNoether)
const poly kBucketGetLm(kBucket_pt bucket)
VAR ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
void kBucketDestroy(kBucket_pt *bucket_pt)
static unsigned pLength(poly a)
KINLINE poly ksOldSpolyRed(poly p1, poly p2, poly spNoether)
kBucket_pt kBucketCreate(const ring bucket_ring)
Creation/Destruction of buckets.
◆ SetMult()
void SetMult |
( |
Poly * |
x, |
|
|
int |
i |
|
) |
| |
◆ SetProl()
void SetProl |
( |
Poly * |
x, |
|
|
int |
i |
|
) |
| |
◆ sp_div()
int sp_div |
( |
poly |
m1, |
|
|
poly |
m2, |
|
|
int |
from |
|
) |
| |
Definition at line 821 of file janet.cc.
824 if (
pow_(m2) == 0 &&
pow_(m1))
return 0;
VAR ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
#define pGetExp(p, i)
Exponent.
◆ T2G()
Definition at line 1085 of file janet.cc.
void insert_(TreeM **tree, Poly *item)
◆ ValidatePoly()
Definition at line 299 of file janet.cc.
304 if (x->
root)
return 1;
Poly * is_present(jList *F, poly x)
#define pCopy(p)
return a copy of the poly
◆ degree_compatible
◆ FreeNodes
◆ jDeg
◆ ListGreatMove
◆ Mask
STATIC_VAR int Mask[8] ={0x80,0x40,0x20,0x10,0x8,0x4,0x2,0x1} |
◆ offset
◆ temp_l