#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");
void ForEachControlProlong(jList *x)
void DestroyTree(NodeM *G)
int ValidatePoly(Poly *x, TreeM *)
void ControlProlong(Poly *x)
void InsertInList(jList *x, Poly *y)
void ForEachPNF(jList *x, int i)
void NFL(Poly *p, TreeM *F)
STATIC_VAR int degree_compatible
void PNF(Poly *p, TreeM *F)
Poly * FindMinList(jList *L)
STATIC_VAR int(* ListGreatMove)(jList *, jList *, poly)
void insert_(TreeM **tree, Poly *item)
void DestroyPoly(Poly *x)
#define pIsConstant(p)
like above, except that Comp must be 0
◆ 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.
STATIC_VAR NodeM * FreeNodes
◆ CreateListNode()
◆ Define()
void Define |
( |
TreeM ** |
G | ) |
|
◆ DestroyFreeNodes()
void DestroyFreeNodes |
( |
| ) |
|
◆ DestroyList()
void DestroyList |
( |
jList * |
x | ) |
|
◆ DestroyListNode()
◆ 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 | ) |
|
◆ 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);
int sp_div(poly m1, poly m2, int from)
void div_l(poly item, NodeM *x, int from)
◆ FindMinList()
Definition at line 517 of file janet.cc.
526 while ((*
min) && ((*min)->info->root ==
NULL))
536 if ((*l)->info->root !=
NULL)
static int min(int a, int b)
int ProlCompare(Poly *item1, Poly *item2)
◆ ForEachControlProlong()
void ForEachControlProlong |
( |
jList * |
x | ) |
|
◆ ForEachPNF()
void ForEachPNF |
( |
jList * |
x, |
|
|
int |
i |
|
) |
| |
◆ 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
◆ Initialization()
void Initialization |
( |
char * |
Ord | ) |
|
Definition at line 952 of file janet.cc.
955 if (strstr(Ord,
"dp\0") || strstr(Ord,
"Dp\0"))
int ListGreatMoveOrder(jList *A, jList *B, poly x)
int ListGreatMoveDegree(jList *A, jList *B, poly x)
long p_Deg(poly a, const ring r)
static long p_Totaldegree(poly p, const ring r)
VAR ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
◆ InitLead()
void InitLead |
( |
Poly * |
p | ) |
|
◆ 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++)
942 if (!curr->right) curr->right=
create();
void SetMult(Poly *x, int i)
#define pGetExp(p, i)
Exponent.
◆ InsertInCount()
Definition at line 571 of file janet.cc.
ListNode * CreateListNode(Poly *x)
◆ InsertInList()
Definition at line 552 of file janet.cc.
559 if (
pLmCmp(
y->lead,(*ix)->info->lead) == -1)
#define pLmCmp(p, q)
returns 0|1|-1 if p=q|p>q|p<q w.r.t monomial ordering
◆ 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;
Poly * is_div_upper(poly item, NodeM *x, int from)
◆ is_div_upper()
Poly* is_div_upper |
( |
poly |
item, |
|
|
NodeM * |
x, |
|
|
int |
from |
|
) |
| |
◆ is_present()
◆ 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)
void InsertInCount(jList *x, Poly *y)
◆ ListGreatMoveOrder()
int ListGreatMoveOrder |
( |
jList * |
A, |
|
|
jList * |
B, |
|
|
poly |
x |
|
) |
| |
◆ NewPoly()
Definition at line 361 of file janet.cc.
void ClearProl(Poly *x, int i)
◆ NFL()
Definition at line 187 of file janet.cc.
194 int pX=
pow_(
p->lead);
195 int phX=
pow_(
p->history);
199 int phF=
pow_(
f->history);
233 int pF=
pow_(
f->lead);
235 if ((pX == pF) && (pF == phF))
238 if (
p->history!=
NULL)
void InitHistory(Poly *p)
int ReducePolyLead(Poly *x, Poly *y)
Poly * is_div_(TreeM *tree, poly item)
void kBucketClear(kBucket_pt bucket, poly *p, int *length)
void kBucketDestroy(kBucket_pt *bucket_pt)
void kBucketInit(kBucket_pt bucket, poly lm, int length)
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy
void p_SimpleContent(poly ph, int smax, const ring r)
void p_ContentForGB(poly ph, const ring r)
static poly p_Copy_noCheck(poly p, const ring r)
returns a copy of p (without any additional testing)
int status int void size_t count
◆ 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)
◆ PNF()
Definition at line 143 of file janet.cc.
145 if (
p->root==
NULL)
return;
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)
◆ ProlVar()
void ProlVar |
( |
Poly * |
temp, |
|
|
int |
i |
|
) |
| |
Definition at line 480 of file janet.cc.
int GetProl(Poly *x, int i)
void SetProl(Poly *x, int i)
◆ ReducePoly()
int ReducePoly |
( |
Poly * |
x, |
|
|
poly |
from, |
|
|
Poly * |
y |
|
) |
| |
Definition at line 119 of file janet.cc.
121 if (!
x->root || !
y->root)
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.
76 if (!
x->root || !
y->root)
KINLINE poly ksOldSpolyRed(poly p1, poly p2, poly spNoether)
kBucket_pt kBucketCreate(const ring bucket_ring)
Creation/Destruction of buckets.
number kBucketPolyRed(kBucket_pt bucket, poly p1, int l1, poly spNoether)
const poly kBucketGetLm(kBucket_pt bucket)
static unsigned pLength(poly a)
◆ 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 |
|
) |
| |
◆ T2G()
◆ 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