Macros | Functions | Variables
singular.cc File Reference
#include "kernel/mod2.h"
#include "Singular/mod_lib.h"
#include "Singular/ipid.h"
#include "Singular/number2.h"
#include <coeffs/numbers.h>
#include <coeffs/coeffs.h>
#include "Singular/blackbox.h"
#include "nforder.h"
#include "nforder_elt.h"
#include "nforder_ideal.h"
#include <coeffs/bigintmat.h>

Go to the source code of this file.

Macros

#define returnNumber(_res, _n, _R)
 

Functions

static void nforder_Register ()
 
static void * nforder_ideal_Init (blackbox *)
 
static char * nforder_ideal_String (blackbox *b, void *d)
 
static void * nforder_ideal_Copy (blackbox *, void *d)
 
static BOOLEAN nforder_ideal_Assign (leftv l, leftv r)
 
static void nforder_ideal_destroy (blackbox *, void *d)
 
BOOLEAN checkArgumentIsOrder (leftv arg, nforder *cmp, nforder **result)
 
BOOLEAN checkArgumentIsBigintmat (leftv arg, coeffs r, bigintmat **result)
 
BOOLEAN checkArgumentIsNumber2 (leftv arg, coeffs r, number2 *result)
 
BOOLEAN checkArgumentIsNFOrderIdeal (leftv arg, coeffs r, nforder_ideal **result)
 
BOOLEAN checkArgumentIsInt (leftv arg, int *result)
 
BOOLEAN checkArgumentIsBigint (leftv arg, number *result)
 
static BOOLEAN nforder_ideal_Op2 (int op, leftv l, leftv r1, leftv r2)
 
static BOOLEAN nforder_ideal_bb_setup ()
 
BOOLEAN checkBigintmatDim (bigintmat *b, int r, int c)
 
static BOOLEAN build_ring (leftv result, leftv arg)
 
static BOOLEAN ideal_from_mat (leftv result, leftv arg)
 
static BOOLEAN elt_from_mat (leftv result, leftv arg)
 
static BOOLEAN discriminant (leftv result, leftv arg)
 
static BOOLEAN pMaximalOrder (leftv result, leftv arg)
 
static BOOLEAN oneStep (leftv result, leftv arg)
 
static BOOLEAN nforder_simplify (leftv result, leftv arg)
 
static BOOLEAN eltTrace (leftv result, leftv arg)
 
static BOOLEAN eltNorm (leftv result, leftv arg)
 
static BOOLEAN eltRepMat (leftv result, leftv arg)
 
static BOOLEAN smithtest (leftv result, leftv arg)
 
int SI_MOD_INIT() Order (SModulFunctions *psModulFunctions)
 

Variables

static int nforder_type_id =0
 
n_coeffType nforder_type =n_unknown
 
static coeffs nforder_AE =NULL
 

Macro Definition Documentation

#define returnNumber (   _res,
  _n,
  _R 
)
Value:
do { \
number2 _r = (number2)omAlloc(sizeof(struct snumber2)); \
_r->n = _n; \
_r->cf = _R; \
_res->rtyp = CNUMBER_CMD; \
_res->data = _r; \
} while (0)
#define omAlloc(size)
Definition: omAllocDecl.h:210

Definition at line 223 of file singular.cc.

Function Documentation

static BOOLEAN build_ring ( leftv  result,
leftv  arg 
)
static

Definition at line 233 of file singular.cc.

234 {
235  nforder *o;
236  if (arg->Typ() == LIST_CMD) {
237  lists L = (lists)arg->Data();
238  int n = lSize(L)+1;
239  bigintmat **multtable = (bigintmat**)omAlloc(n*sizeof(bigintmat*));
240  for(int i=0; i<n; i++) {
241  multtable[i] = (bigintmat*)(L->m[i].Data());
242  }
243  o = new nforder(n, multtable, nInitChar(n_Z, 0));
244  omFree(multtable);
245  } else {
246  assume(arg->Typ() == INT_CMD);
247  int dimension = (int)(long)arg->Data();
248 
249  bigintmat **multtable = (bigintmat**)omAlloc(dimension*sizeof(bigintmat*));
250  arg = arg->next;
251  for (int i=0; i<dimension; i++) {
252  multtable[i] = new bigintmat((bigintmat*)arg->Data());
253  arg = arg->next;
254  }
255  o = new nforder(dimension, multtable, nInitChar(n_Z, 0));
256  for (int i=0; i<dimension; i++) {
257  delete multtable[i];
258  }
259  omFree(multtable);
260  }
261  result->rtyp=CRING_CMD; // set the result type
262  result->data=(char*)nInitChar(nforder_type, o);// set the result data
263 
264  return FALSE;
265 }
sleftv * m
Definition: lists.h:45
Definition: tok.h:85
Definition: lists.h:22
#define FALSE
Definition: auxiliary.h:140
Matrices of numbers.
Definition: bigintmat.h:32
const CanonicalForm CFMap CFMap int &both_non_zero int n
Definition: cfEzgcd.cc:52
int Typ()
Definition: subexpr.cc:955
#define omAlloc(size)
Definition: omAllocDecl.h:210
void * data
Definition: subexpr.h:89
Definition: tok.h:56
#define omFree(addr)
Definition: omAllocDecl.h:261
#define assume(x)
Definition: mod2.h:405
only used if HAVE_RINGS is defined: ?
Definition: coeffs.h:42
int i
Definition: cfEzgcd.cc:123
n_coeffType nforder_type
Definition: singular.cc:16
int lSize(lists L)
Definition: lists.cc:25
leftv next
Definition: subexpr.h:87
BOOLEAN dimension(leftv res, leftv args)
Definition: bbcone.cc:699
slists * lists
Definition: mpr_numeric.h:146
int rtyp
Definition: subexpr.h:92
void * Data()
Definition: subexpr.cc:1097
Definition: tok.h:96
coeffs nInitChar(n_coeffType t, void *parameter)
one-time initialisations for new coeffs in case of an error return NULL
Definition: numbers.cc:327
BOOLEAN checkArgumentIsBigint ( leftv  arg,
number *  result 
)

Definition at line 111 of file singular.cc.

112 {
113  switch (arg->Typ()) {
114  case BIGINT_CMD:
115  *result = (number)arg->Data();
116  return TRUE;
117  break;
118  case NUMBER_CMD:
119  if (currRing->cf == coeffs_BIGINT &&
121  *result = (number)arg->Data();
122  return TRUE;
123  } else
124  return FALSE;
125  break;
126  case CNUMBER_CMD:
127  {
128  number2 n = (number2)arg->Data();
129  if (getCoeffType(n->cf) == n_Z) {
130  *result = n->n;
131  return TRUE;
132  }
133  return FALSE;
134  break;
135  }
136  default:
137  return FALSE;
138  }
139 }
#define FALSE
Definition: auxiliary.h:140
Definition: tok.h:42
const CanonicalForm CFMap CFMap int &both_non_zero int n
Definition: cfEzgcd.cc:52
#define TRUE
Definition: auxiliary.h:144
coeffs coeffs_BIGINT
Definition: ipid.cc:53
int Typ()
Definition: subexpr.cc:955
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:12
only used if HAVE_RINGS is defined: ?
Definition: coeffs.h:42
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
Definition: coeffs.h:422
void * Data()
Definition: subexpr.cc:1097
return result
Definition: facAbsBiFact.cc:76
BOOLEAN checkArgumentIsBigintmat ( leftv  arg,
coeffs  r,
bigintmat **  result 
)

Definition at line 77 of file singular.cc.

78 {
79  if (arg->Typ() != BIGINTMAT_CMD) return FALSE;
80  bigintmat * b = (bigintmat*) arg->Data();
81  if (r && b->basecoeffs() != r) return FALSE;
82  *result = b;
83  return TRUE;
84 }
#define FALSE
Definition: auxiliary.h:140
Matrices of numbers.
Definition: bigintmat.h:32
#define TRUE
Definition: auxiliary.h:144
int Typ()
Definition: subexpr.cc:955
const ring r
Definition: syzextra.cc:208
coeffs basecoeffs() const
Definition: bigintmat.h:130
void * Data()
Definition: subexpr.cc:1097
const poly b
Definition: syzextra.cc:213
BOOLEAN checkArgumentIsInt ( leftv  arg,
int *  result 
)

Definition at line 104 of file singular.cc.

105 {
106  if (arg->Typ() != INT_CMD) return FALSE;
107  *result = (long) arg->Data();
108  return TRUE;
109 }
Definition: tok.h:85
#define FALSE
Definition: auxiliary.h:140
#define TRUE
Definition: auxiliary.h:144
int Typ()
Definition: subexpr.cc:955
void * Data()
Definition: subexpr.cc:1097
return result
Definition: facAbsBiFact.cc:76
BOOLEAN checkArgumentIsNFOrderIdeal ( leftv  arg,
coeffs  r,
nforder_ideal **  result 
)

Definition at line 96 of file singular.cc.

97 {
98  if (arg->Typ() != nforder_type_id) return FALSE;
99  *result = (nforder_ideal *) arg->Data();
100  if (r && (*result)->order() != r) return FALSE;
101  return TRUE;
102 }
#define FALSE
Definition: auxiliary.h:140
#define TRUE
Definition: auxiliary.h:144
int Typ()
Definition: subexpr.cc:955
const ring r
Definition: syzextra.cc:208
static int nforder_type_id
Definition: singular.cc:15
void * Data()
Definition: subexpr.cc:1097
BOOLEAN checkArgumentIsNumber2 ( leftv  arg,
coeffs  r,
number2 *  result 
)

Definition at line 86 of file singular.cc.

87 {
88  if (arg->Typ() != CNUMBER_CMD) return FALSE;
89  number2 b = (number2) arg->Data();
90  if (r && b->cf != r) return FALSE;
91  *result = b;
92  return TRUE;
93 }
#define FALSE
Definition: auxiliary.h:140
#define TRUE
Definition: auxiliary.h:144
int Typ()
Definition: subexpr.cc:955
void * Data()
Definition: subexpr.cc:1097
const poly b
Definition: syzextra.cc:213
return result
Definition: facAbsBiFact.cc:76
BOOLEAN checkArgumentIsOrder ( leftv  arg,
nforder cmp,
nforder **  result 
)

Definition at line 66 of file singular.cc.

67 {
68  if (arg->Typ() != CRING_CMD) return FALSE;
69  coeffs R = (coeffs) arg->Data();
70  if (getCoeffType(R) != nforder_type) return FALSE;
71  nforder * O = (nforder*) R->data;
72  if (cmp && cmp != O) return FALSE;
73  *result = O;
74  return TRUE;
75 }
#define FALSE
Definition: auxiliary.h:140
#define TRUE
Definition: auxiliary.h:144
int Typ()
Definition: subexpr.cc:955
int int kStrategy strat if(h==NULL) return NULL
Definition: tok.h:56
The main handler for Singular numbers which are suitable for Singular polynomials.
n_coeffType nforder_type
Definition: singular.cc:16
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
Definition: coeffs.h:422
#define R
Definition: sirandom.c:26
void * Data()
Definition: subexpr.cc:1097
BOOLEAN checkBigintmatDim ( bigintmat b,
int  r,
int  c 
)

Definition at line 216 of file singular.cc.

217 {
218  if (b->rows() != r) return FALSE;
219  if (b->cols() != c) return FALSE;
220  return TRUE;
221 }
#define FALSE
Definition: auxiliary.h:140
#define TRUE
Definition: auxiliary.h:144
const ring r
Definition: syzextra.cc:208
int cols() const
Definition: bigintmat.h:128
int rows() const
Definition: bigintmat.h:129
static BOOLEAN discriminant ( leftv  result,
leftv  arg 
)
static

Definition at line 303 of file singular.cc.

304 {
305  nforder * O;
306  if (!checkArgumentIsOrder(arg, NULL, &O)) {
307  WerrorS("usage: Discriminant(order)");
308  return TRUE;
309  }
310  O->calcdisc();
311 
312  returnNumber(result, O->getDisc(), O->basecoeffs());
313  return FALSE;
314 }
#define FALSE
Definition: auxiliary.h:140
void calcdisc()
Definition: nforder.cpp:162
#define TRUE
Definition: auxiliary.h:144
void WerrorS(const char *s)
Definition: feFopen.cc:23
number getDisc()
Definition: nforder.cpp:227
#define returnNumber(_res, _n, _R)
Definition: singular.cc:223
BOOLEAN checkArgumentIsOrder(leftv arg, nforder *cmp, nforder **result)
Definition: singular.cc:66
coeffs basecoeffs() const
Definition: nforder.h:76
#define NULL
Definition: omList.c:10
static BOOLEAN elt_from_mat ( leftv  result,
leftv  arg 
)
static

Definition at line 286 of file singular.cc.

287 {
288  nforder * O;
289  if (!checkArgumentIsOrder(arg, NULL, &O)) {
290  WerrorS("usage: EltFromMat(order, matrix)");
291  return TRUE;
292  }
293  arg = arg->next;
294  bigintmat *b;
295  if (!checkArgumentIsBigintmat(arg, O->basecoeffs(), &b)) {
296  WerrorS("2:usage: EltFromMat(order, matrix)");
297  return TRUE;
298  }
299  returnNumber(result, (number)EltCreateMat(O, b), nInitChar(nforder_type, O));
300  return FALSE;
301 }
#define FALSE
Definition: auxiliary.h:140
Matrices of numbers.
Definition: bigintmat.h:32
BOOLEAN checkArgumentIsBigintmat(leftv arg, coeffs r, bigintmat **result)
Definition: singular.cc:77
number EltCreateMat(nforder *a, bigintmat *b)
Definition: nforder_elt.cc:34
#define TRUE
Definition: auxiliary.h:144
void WerrorS(const char *s)
Definition: feFopen.cc:23
#define returnNumber(_res, _n, _R)
Definition: singular.cc:223
BOOLEAN checkArgumentIsOrder(leftv arg, nforder *cmp, nforder **result)
Definition: singular.cc:66
n_coeffType nforder_type
Definition: singular.cc:16
leftv next
Definition: subexpr.h:87
coeffs basecoeffs() const
Definition: nforder.h:76
#define NULL
Definition: omList.c:10
const poly b
Definition: syzextra.cc:213
coeffs nInitChar(n_coeffType t, void *parameter)
one-time initialisations for new coeffs in case of an error return NULL
Definition: numbers.cc:327
static BOOLEAN eltNorm ( leftv  result,
leftv  arg 
)
static

Definition at line 388 of file singular.cc.

389 {
390  number2 a;
391  if (!checkArgumentIsNumber2(arg, NULL, &a)) {
392  WerrorS("EltNorm(elt)");
393  return TRUE;
394  }
395  coeffs c = a->cf;
396  if (getCoeffType(c) != nforder_type) {
397  WerrorS("EltNorm(elt in order)");
398  return TRUE;
399  }
400  bigintmat * aa = (bigintmat*)a->n;
401  nforder * o = (nforder*)c->data;
402  number t = o->elNorm(aa);
403  returnNumber(result, t, o->basecoeffs());
404  return FALSE;
405 }
const poly a
Definition: syzextra.cc:212
#define FALSE
Definition: auxiliary.h:140
Matrices of numbers.
Definition: bigintmat.h:32
#define TRUE
Definition: auxiliary.h:144
void WerrorS(const char *s)
Definition: feFopen.cc:23
#define returnNumber(_res, _n, _R)
Definition: singular.cc:223
BOOLEAN checkArgumentIsNumber2(leftv arg, coeffs r, number2 *result)
Definition: singular.cc:86
The main handler for Singular numbers which are suitable for Singular polynomials.
n_coeffType nforder_type
Definition: singular.cc:16
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
Definition: coeffs.h:422
#define NULL
Definition: omList.c:10
static BOOLEAN eltRepMat ( leftv  result,
leftv  arg 
)
static

Definition at line 407 of file singular.cc.

408 {
409  assume (arg->Typ()==CNUMBER_CMD);
410  number2 a = (number2) arg->Data();
411  coeffs c = a->cf;
412  bigintmat * aa = (bigintmat*)a->n;
413  assume (c->type == nforder_type);
414  nforder * o = (nforder*)c->data;
415  bigintmat* t = o->elRepMat(aa);
416  result->rtyp = BIGINTMAT_CMD;
417  result->data = t;
418  return FALSE;
419 }
const poly a
Definition: syzextra.cc:212
#define FALSE
Definition: auxiliary.h:140
Matrices of numbers.
Definition: bigintmat.h:32
int Typ()
Definition: subexpr.cc:955
void * data
Definition: subexpr.h:89
bigintmat * elRepMat(bigintmat *a)
Definition: nforder.cpp:395
#define assume(x)
Definition: mod2.h:405
The main handler for Singular numbers which are suitable for Singular polynomials.
n_coeffType nforder_type
Definition: singular.cc:16
int rtyp
Definition: subexpr.h:92
void * Data()
Definition: subexpr.cc:1097
static BOOLEAN eltTrace ( leftv  result,
leftv  arg 
)
static

Definition at line 369 of file singular.cc.

370 {
371  number2 a;
372  if (!checkArgumentIsNumber2(arg, NULL, &a)) {
373  WerrorS("EltTrace(elt)");
374  return TRUE;
375  }
376  coeffs c = a->cf;
377  if (getCoeffType(c) != nforder_type) {
378  WerrorS("EltTrace(elt in order)");
379  return TRUE;
380  }
381  bigintmat * aa = (bigintmat*)a->n;
382  nforder * o = (nforder*)c->data;
383  number t = o->elTrace(aa);
384  returnNumber(result, t, o->basecoeffs());
385  return FALSE;
386 }
const poly a
Definition: syzextra.cc:212
#define FALSE
Definition: auxiliary.h:140
Matrices of numbers.
Definition: bigintmat.h:32
#define TRUE
Definition: auxiliary.h:144
void WerrorS(const char *s)
Definition: feFopen.cc:23
#define returnNumber(_res, _n, _R)
Definition: singular.cc:223
BOOLEAN checkArgumentIsNumber2(leftv arg, coeffs r, number2 *result)
Definition: singular.cc:86
The main handler for Singular numbers which are suitable for Singular polynomials.
n_coeffType nforder_type
Definition: singular.cc:16
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
Definition: coeffs.h:422
#define NULL
Definition: omList.c:10
static BOOLEAN ideal_from_mat ( leftv  result,
leftv  arg 
)
static

Definition at line 267 of file singular.cc.

268 {
269  nforder * O;
270  if (!checkArgumentIsOrder(arg, NULL, &O)) {
271  WerrorS("usage: IdealFromMat(order, basis matrix)");
272  return TRUE;
273  }
274  arg = arg->next;
275  bigintmat *b;
276  if (!checkArgumentIsBigintmat(arg, O->basecoeffs(), &b)) {
277  WerrorS("3:usage: IdealFromMat(order, basis matrix)");
278  return TRUE;
279  }
280  result->rtyp = nforder_type_id;
281  result->data = new nforder_ideal(b, nInitChar(nforder_type, O));
282  return FALSE;
283 }
#define FALSE
Definition: auxiliary.h:140
Matrices of numbers.
Definition: bigintmat.h:32
BOOLEAN checkArgumentIsBigintmat(leftv arg, coeffs r, bigintmat **result)
Definition: singular.cc:77
#define TRUE
Definition: auxiliary.h:144
void WerrorS(const char *s)
Definition: feFopen.cc:23
void * data
Definition: subexpr.h:89
static int nforder_type_id
Definition: singular.cc:15
BOOLEAN checkArgumentIsOrder(leftv arg, nforder *cmp, nforder **result)
Definition: singular.cc:66
n_coeffType nforder_type
Definition: singular.cc:16
leftv next
Definition: subexpr.h:87
coeffs basecoeffs() const
Definition: nforder.h:76
#define NULL
Definition: omList.c:10
int rtyp
Definition: subexpr.h:92
const poly b
Definition: syzextra.cc:213
coeffs nInitChar(n_coeffType t, void *parameter)
one-time initialisations for new coeffs in case of an error return NULL
Definition: numbers.cc:327
static BOOLEAN nforder_ideal_Assign ( leftv  l,
leftv  r 
)
static

Definition at line 42 of file singular.cc.

43 {
44  if (l->Typ()==r->Typ())
45  {
46  if (l->rtyp==IDHDL)
47  {
48  IDDATA((idhdl)l->data)=(char *)nforder_ideal_Copy((blackbox*)NULL, r->data);
49  }
50  else
51  {
52  l->data=(char *)nforder_ideal_Copy((blackbox*)NULL, r->data);
53  }
54  return FALSE;
55  }
56  return TRUE;
57 }
#define FALSE
Definition: auxiliary.h:140
static void * nforder_ideal_Copy(blackbox *, void *d)
Definition: singular.cc:39
#define TRUE
Definition: auxiliary.h:144
int Typ()
Definition: subexpr.cc:955
Definition: idrec.h:34
#define IDHDL
Definition: tok.h:35
void * data
Definition: subexpr.h:89
#define NULL
Definition: omList.c:10
int rtyp
Definition: subexpr.h:92
#define IDDATA(a)
Definition: ipid.h:125
static BOOLEAN nforder_ideal_bb_setup ( )
static

Definition at line 192 of file singular.cc.

193 {
194  blackbox *b=(blackbox*)omAlloc0(sizeof(blackbox));
195  // all undefined entries will be set to default in setBlackboxStuff
196  // the default Print is quite useful,
197  // all other are simply error messages
198  b->blackbox_destroy=nforder_ideal_destroy;
199  b->blackbox_String=nforder_ideal_String;
200  //b->blackbox_Print=blackbox_default_Print;
201  b->blackbox_Init=nforder_ideal_Init;
202  b->blackbox_Copy=nforder_ideal_Copy;
203  b->blackbox_Assign=nforder_ideal_Assign;
204  //b->blackbox_Op1=blackbox_default_Op1;
205  b->blackbox_Op2=nforder_ideal_Op2;
206  //b->blackbox_Op3=blackbox_default_Op3;
207  //b->blackbox_OpM=blackbox_default_OpM;
208  nforder_type_id = setBlackboxStuff(b,"NFOrderIdeal");
209  Print("setup: created a blackbox type [%d] '%s'",nforder_type_id, getBlackboxName(nforder_type_id));
210  PrintLn();
211  return FALSE; // ok, TRUE = error!
212 }
static BOOLEAN nforder_ideal_Assign(leftv l, leftv r)
Definition: singular.cc:42
static void * nforder_ideal_Init(blackbox *)
Definition: singular.cc:27
void PrintLn()
Definition: reporter.cc:322
#define Print
Definition: emacs.cc:83
static char * nforder_ideal_String(blackbox *b, void *d)
Definition: singular.cc:32
#define FALSE
Definition: auxiliary.h:140
static void * nforder_ideal_Copy(blackbox *, void *d)
Definition: singular.cc:39
static BOOLEAN nforder_ideal_Op2(int op, leftv l, leftv r1, leftv r2)
Definition: singular.cc:141
static int nforder_type_id
Definition: singular.cc:15
static void nforder_ideal_destroy(blackbox *, void *d)
Definition: singular.cc:58
const char * getBlackboxName(const int t)
return the name to the type given by t (r/o)
Definition: blackbox.cc:187
int setBlackboxStuff(blackbox *bb, const char *n)
define a new type
Definition: blackbox.cc:128
const poly b
Definition: syzextra.cc:213
#define omAlloc0(size)
Definition: omAllocDecl.h:211
static void* nforder_ideal_Copy ( blackbox *  ,
void *  d 
)
static

Definition at line 39 of file singular.cc.

40 { return new nforder_ideal((nforder_ideal*)d, 1);}
static void nforder_ideal_destroy ( blackbox *  ,
void *  d 
)
static

Definition at line 58 of file singular.cc.

59 {
60  if (d!=NULL)
61  {
62  delete (nforder_ideal*)d;
63  }
64 }
#define NULL
Definition: omList.c:10
static void* nforder_ideal_Init ( blackbox *  )
static

Definition at line 27 of file singular.cc.

28 {
29  nforder_AE->ref++;
30  return nforder_AE;
31 }
static coeffs nforder_AE
Definition: singular.cc:19
static BOOLEAN nforder_ideal_Op2 ( int  op,
leftv  l,
leftv  r1,
leftv  r2 
)
static

Definition at line 141 of file singular.cc.

142 {
143  Print("Types are %d %d\n", r1->Typ(), r2->Typ());
144  number2 e;
145  int f;
146  nforder_ideal *I, *J, *H;
147  switch (op) {
148  case '+':
149  {
150  if (!checkArgumentIsNFOrderIdeal(r1, NULL, &I))
151  return TRUE;
152  if (!checkArgumentIsNFOrderIdeal(r2, I->order(), &J))
153  return TRUE;
154  H = nf_idAdd(I, J);
155  break;
156  }
157  case '*':
158  {
159  if (!checkArgumentIsNFOrderIdeal(r1, NULL, &I)) {
160  leftv r = r1;
161  r1 = r2;
162  r2 = r; //at least ONE argument has to be an ideal
163  }
164  if (!checkArgumentIsNFOrderIdeal(r1, NULL, &I))
165  return TRUE;
166  if (checkArgumentIsNFOrderIdeal(r2, I->order(), &J)) {
167  H = nf_idMult(I, J);
168  } else if (checkArgumentIsNumber2(r2, I->order(), &e)) {
169  H = nf_idMult(I, e->n);
170  } else if (checkArgumentIsInt(r2, &f)) {
171  H = nf_idMult(I, f);
172  } else
173  return TRUE;
174  break;
175  }
176  case '^':
177  {
178  if (!checkArgumentIsNFOrderIdeal(r1, NULL, &I))
179  return TRUE;
180  if (!checkArgumentIsInt(r2, &f))
181  return TRUE;
182  H = nf_idPower(I, f);
183  break;
184  }
185  default:
186  return TRUE;
187  }
188  l->rtyp = nforder_type_id;
189  l->data = (void*)H;
190  return FALSE;
191 }
Class used for (list of) interpreter objects.
Definition: subexpr.h:83
#define Print
Definition: emacs.cc:83
#define FALSE
Definition: auxiliary.h:140
nforder_ideal * nf_idMult(nforder_ideal *A, nforder_ideal *B)
coeffs order() const
Definition: nforder_ideal.h:45
#define TRUE
Definition: auxiliary.h:144
int Typ()
Definition: subexpr.cc:955
void * data
Definition: subexpr.h:89
nforder_ideal * nf_idPower(nforder_ideal *A, int i)
const ring r
Definition: syzextra.cc:208
BOOLEAN checkArgumentIsNumber2(leftv arg, coeffs r, number2 *result)
Definition: singular.cc:86
BOOLEAN checkArgumentIsNFOrderIdeal(leftv arg, coeffs r, nforder_ideal **result)
Definition: singular.cc:96
static int nforder_type_id
Definition: singular.cc:15
FILE * f
Definition: checklibs.c:7
CanonicalForm H
Definition: facAbsFact.cc:64
#define NULL
Definition: omList.c:10
BOOLEAN checkArgumentIsInt(leftv arg, int *result)
Definition: singular.cc:104
int rtyp
Definition: subexpr.h:92
nforder_ideal * nf_idAdd(nforder_ideal *A, nforder_ideal *B)
static char* nforder_ideal_String ( blackbox *  b,
void *  d 
)
static

Definition at line 32 of file singular.cc.

33 {
34  StringSetS("");
35  if (d) ((nforder_ideal *)d)->Write();
36  else StringAppendS("o not defined o");
37  return StringEndS();
38 }
char * StringEndS()
Definition: reporter.cc:151
void StringSetS(const char *st)
Definition: reporter.cc:128
void StringAppendS(const char *st)
Definition: reporter.cc:107
static void nforder_Register ( )
static

Definition at line 20 of file singular.cc.

21 {
22  puts("nforder_Register called");
25 }
BOOLEAN n_nfOrderInit(coeffs r, void *parameter)
Definition: nforder_elt.cc:227
n_coeffType nRegister(n_coeffType n, cfInitCharProc p)
Definition: numbers.cc:518
n_coeffType nforder_type
Definition: singular.cc:16
static coeffs nforder_AE
Definition: singular.cc:19
#define NULL
Definition: omList.c:10
coeffs nInitChar(n_coeffType t, void *parameter)
one-time initialisations for new coeffs in case of an error return NULL
Definition: numbers.cc:327
static BOOLEAN nforder_simplify ( leftv  result,
leftv  arg 
)
static

Definition at line 354 of file singular.cc.

355 {
356  nforder * o;
357  if (!checkArgumentIsOrder(arg, NULL, &o)) {
358  WerrorS("usage: NFOrderSimplify(order)");
359  return TRUE;
360  }
361  nforder *op = o->simplify();
362 
363  result->rtyp=CRING_CMD; // set the result type
364  result->data=(char*)nInitChar(nforder_type, op);// set the result data
365 
366  return FALSE;
367 }
nforder * simplify()
Definition: nforder.cpp:275
#define FALSE
Definition: auxiliary.h:140
#define TRUE
Definition: auxiliary.h:144
void WerrorS(const char *s)
Definition: feFopen.cc:23
void * data
Definition: subexpr.h:89
Definition: tok.h:56
BOOLEAN checkArgumentIsOrder(leftv arg, nforder *cmp, nforder **result)
Definition: singular.cc:66
n_coeffType nforder_type
Definition: singular.cc:16
#define NULL
Definition: omList.c:10
int rtyp
Definition: subexpr.h:92
coeffs nInitChar(n_coeffType t, void *parameter)
one-time initialisations for new coeffs in case of an error return NULL
Definition: numbers.cc:327
static BOOLEAN oneStep ( leftv  result,
leftv  arg 
)
static

Definition at line 336 of file singular.cc.

337 {
338  assume (arg->Typ()==CRING_CMD);
339  coeffs c = (coeffs)arg->Data();
340  assume (c->type == nforder_type);
341  nforder * o = (nforder*)c->data;
342  arg = arg->next;
343  long p = (int)(long)arg->Data();
344  number P = n_Init(p, o->basecoeffs());
345 
346  nforder *op = onestep(o, P, o->basecoeffs());
347 
348  result->rtyp=CRING_CMD; // set the result type
349  result->data=(char*)nInitChar(nforder_type, op);// set the result data
350 
351  return FALSE;
352 }
#define FALSE
Definition: auxiliary.h:140
return P p
Definition: myNF.cc:203
static FORCE_INLINE number n_Init(long i, const coeffs r)
a number representing i in the given coeff field/ring r
Definition: coeffs.h:539
int Typ()
Definition: subexpr.cc:955
void * data
Definition: subexpr.h:89
nforder * onestep(nforder *o, number p, coeffs c)
Definition: nforder.cpp:608
Definition: tok.h:56
#define assume(x)
Definition: mod2.h:405
The main handler for Singular numbers which are suitable for Singular polynomials.
n_coeffType nforder_type
Definition: singular.cc:16
leftv next
Definition: subexpr.h:87
coeffs basecoeffs() const
Definition: nforder.h:76
int rtyp
Definition: subexpr.h:92
void * Data()
Definition: subexpr.cc:1097
kBucketDestroy & P
Definition: myNF.cc:191
coeffs nInitChar(n_coeffType t, void *parameter)
one-time initialisations for new coeffs in case of an error return NULL
Definition: numbers.cc:327
int SI_MOD_INIT() Order ( SModulFunctions psModulFunctions)

Definition at line 439 of file singular.cc.

440 {
443  psModulFunctions->iiAddCproc(
444  (currPack->libname? currPack->libname: ""),// the library name,
445  "nfOrder",// the name for the singular interpreter
446  FALSE, // should not be static
447  build_ring); // the C/C++ routine
448 
449  psModulFunctions->iiAddCproc(
450  (currPack->libname? currPack->libname: ""),// the library name,
451  "pMaximalOrder",// the name for the singular interpreter
452  FALSE, // should not be static
453  pMaximalOrder); // the C/C++ routine
454 
455  psModulFunctions->iiAddCproc(
456  (currPack->libname? currPack->libname: ""),// the library name,
457  "oneStep",// the name for the singular interpreter
458  FALSE, // should not be static
459  oneStep); // the C/C++ routine
460 
461  psModulFunctions->iiAddCproc(
462  (currPack->libname? currPack->libname: ""),
463  "Discriminant",
464  FALSE,
465  discriminant);
466 
467  psModulFunctions->iiAddCproc(
468  (currPack->libname? currPack->libname: ""),
469  "EltFromMat",
470  FALSE,
471  elt_from_mat);
472 
473  psModulFunctions->iiAddCproc(
474  (currPack->libname? currPack->libname: ""),
475  "NFOrderSimplify",
476  FALSE,
478 
479  psModulFunctions->iiAddCproc(
480  (currPack->libname? currPack->libname: ""),
481  "EltNorm",
482  FALSE,
483  eltNorm);
484 
485  psModulFunctions->iiAddCproc(
486  (currPack->libname? currPack->libname: ""),
487  "EltTrace",
488  FALSE,
489  eltTrace);
490 
491  psModulFunctions->iiAddCproc(
492  (currPack->libname? currPack->libname: ""),
493  "EltRepMat",
494  FALSE,
495  eltRepMat);
496 
497  psModulFunctions->iiAddCproc(
498  (currPack->libname? currPack->libname: ""),
499  "SmithTest",
500  FALSE,
501  smithtest);
502 
503  psModulFunctions->iiAddCproc(
504  (currPack->libname? currPack->libname: ""),
505  "IdealFromMat",
506  FALSE,
508 
510  (currPack->libname? currPack->libname: "NFOrder"),// the library name,
511  "nforder: orders in number fields"); // the help string for the module
512  return MAX_TOK;
513 }
static BOOLEAN pMaximalOrder(leftv result, leftv arg)
Definition: singular.cc:316
static BOOLEAN oneStep(leftv result, leftv arg)
Definition: singular.cc:336
#define FALSE
Definition: auxiliary.h:140
static BOOLEAN build_ring(leftv result, leftv arg)
Definition: singular.cc:233
static BOOLEAN nforder_ideal_bb_setup()
Definition: singular.cc:192
Definition: tok.h:167
static BOOLEAN nforder_simplify(leftv result, leftv arg)
Definition: singular.cc:354
static BOOLEAN elt_from_mat(leftv result, leftv arg)
Definition: singular.cc:286
static void nforder_Register()
Definition: singular.cc:20
static BOOLEAN eltRepMat(leftv result, leftv arg)
Definition: singular.cc:407
static BOOLEAN ideal_from_mat(leftv result, leftv arg)
Definition: singular.cc:267
void module_help_main(const char *newlib, const char *help)
Definition: iplib.cc:1192
static BOOLEAN eltNorm(leftv result, leftv arg)
Definition: singular.cc:388
static BOOLEAN discriminant(leftv result, leftv arg)
Definition: singular.cc:303
package currPack
Definition: ipid.cc:62
int(* iiAddCproc)(const char *libname, const char *procname, BOOLEAN pstatic, BOOLEAN(*func)(leftv res, leftv v))
Definition: ipid.h:73
static BOOLEAN eltTrace(leftv result, leftv arg)
Definition: singular.cc:369
static BOOLEAN smithtest(leftv result, leftv arg)
Definition: singular.cc:421
static BOOLEAN pMaximalOrder ( leftv  result,
leftv  arg 
)
static

Definition at line 316 of file singular.cc.

317 {
318  nforder * o;
319  if (!checkArgumentIsOrder(arg, NULL, &o)) {
320  WerrorS("usage: pMaximalOrder(order, int)");
321  return TRUE;
322  }
323  arg = arg->next;
324  long p = (int)(long)arg->Data();
325  number P = n_Init(p, o->basecoeffs());
326 
327  nforder *op = pmaximal(o, P);
328 
329  result->rtyp=CRING_CMD; // set the result type
330  result->data=(char*)nInitChar(nforder_type, op);// set the result data
331  assume(result->data);
332 
333  return FALSE;
334 }
#define FALSE
Definition: auxiliary.h:140
return P p
Definition: myNF.cc:203
static FORCE_INLINE number n_Init(long i, const coeffs r)
a number representing i in the given coeff field/ring r
Definition: coeffs.h:539
#define TRUE
Definition: auxiliary.h:144
void WerrorS(const char *s)
Definition: feFopen.cc:23
nforder * pmaximal(nforder *o, number p)
Definition: nforder.cpp:632
void * data
Definition: subexpr.h:89
Definition: tok.h:56
#define assume(x)
Definition: mod2.h:405
BOOLEAN checkArgumentIsOrder(leftv arg, nforder *cmp, nforder **result)
Definition: singular.cc:66
n_coeffType nforder_type
Definition: singular.cc:16
leftv next
Definition: subexpr.h:87
coeffs basecoeffs() const
Definition: nforder.h:76
#define NULL
Definition: omList.c:10
int rtyp
Definition: subexpr.h:92
void * Data()
Definition: subexpr.cc:1097
kBucketDestroy & P
Definition: myNF.cc:191
coeffs nInitChar(n_coeffType t, void *parameter)
one-time initialisations for new coeffs in case of an error return NULL
Definition: numbers.cc:327
static BOOLEAN smithtest ( leftv  result,
leftv  arg 
)
static

Definition at line 421 of file singular.cc.

422 {
423  assume (arg->Typ()==BIGINTMAT_CMD);
424  bigintmat *a = (bigintmat *) arg->Data();
425  arg = arg->next;
426 
427  long p = (int)(long)arg->Data();
428  number P = n_Init(p, a->basecoeffs());
429 
430  bigintmat * A, *B;
431  diagonalForm(a, &A, &B);
432 
433 
434  result->rtyp = NONE;
435  return FALSE;
436 }
const poly a
Definition: syzextra.cc:212
#define FALSE
Definition: auxiliary.h:140
return P p
Definition: myNF.cc:203
Matrices of numbers.
Definition: bigintmat.h:32
static FORCE_INLINE number n_Init(long i, const coeffs r)
a number representing i in the given coeff field/ring r
Definition: coeffs.h:539
int Typ()
Definition: subexpr.cc:955
#define assume(x)
Definition: mod2.h:405
#define A
Definition: sirandom.c:23
void diagonalForm(bigintmat *A, bigintmat **S, bigintmat **T)
Definition: bigintmat.cc:2323
leftv next
Definition: subexpr.h:87
b *CanonicalForm B
Definition: facBivar.cc:51
int rtyp
Definition: subexpr.h:92
void * Data()
Definition: subexpr.cc:1097
kBucketDestroy & P
Definition: myNF.cc:191
#define NONE
Definition: tok.h:170

Variable Documentation

coeffs nforder_AE =NULL
static

Definition at line 19 of file singular.cc.

n_coeffType nforder_type =n_unknown

Definition at line 16 of file singular.cc.

int nforder_type_id =0
static

Definition at line 15 of file singular.cc.