Loading...
Searching...
No Matches
nforder Class Reference

`#include <nforder.h>`

## Public Member Functions

void | calcdisc ()
int | ref_count_incref ()
int | ref_count_decref ()
int | ref_count ()
| nforder (int dim, bigintmat **m, const coeffs q)
| 0 Konstruktoren/Destruktoren ///
| nforder (nforder *o, bigintmat *base, number div, const coeffs q)
| nforder (nforder *o, int)
| ~nforder ()
void | Write ()
char * | String ()
void | Print ()
nforder * | simplify ()
number | getDisc ()
number | viewDisc ()
int | getDim ()
coeffs | basecoeffs () const
number | getDiv ()
bool | getMult (bigintmat **m)
nforder * | getBase ()
bigintmat * | getBasis ()
bigintmat * | viewBasis ()
bool | oneIsOne ()
void | setOneIsOne ()
bool | isMaximalKnown ()
bool | isMaximal ()
void | setIsMaximal (bool is)
void | elAdd (bigintmat *a, bigintmat *b)
void | elSub (bigintmat *a, bigintmat *b)
void | elMult (bigintmat *a, bigintmat *b)
number | elTrace (bigintmat *a)
number | elNorm (bigintmat *a)
bigintmat * | elRepMat (bigintmat *a)
void | multmap (bigintmat *a, bigintmat *m)
bigintmat * | traceMatrix ()
void | createmulttable (bigintmat **a)

## Private Member Functions

void | init ()

## Private Attributes

int | rc
number | discriminant
int | dimension
coeffs | m_coeffs
bigintmat ** | multtable
nforder * | baseorder
bigintmat * | basis
number | divisor
bigintmat * | inv_basis
number | inv_divisor
int | flags

## Detailed Description

Definition at line 23 of file nforder.h.

## Constructor & Destructor Documentation

## nforder() [1/3]

nforder::nforder | ( | int | dim,
|  | bigintmat ** | m,
|  | const coeffs | q )

0 Konstruktoren/Destruktoren ///

Definition at line 30 of file nforder.cpp.

{
init();
m_coeffs = q;
dimension = dim;
multtable = (bigintmat**)(omAlloc(dim*sizeof(bigintmat*)));
for (int i=0; i<dim; i++) {
multtable[i] = new bigintmat(m[i]);
}
basis = NULL;
inv_basis = NULL;
}
m
int m
Definition cfEzgcd.cc:128
i
int i
Definition cfEzgcd.cc:132
nforder::m_coeffs
coeffs m_coeffs
Definition nforder.h:32
nforder::dimension
int dimension
Definition nforder.h:31
nforder::basis
bigintmat * basis
Definition nforder.h:35
nforder::inv_basis
bigintmat * inv_basis
Definition nforder.h:38
nforder::multtable
bigintmat ** multtable
Definition nforder.h:33
nforder::init
void init()
Definition nforder.cpp:16
omAlloc
#define omAlloc(size)
Definition omAllocDecl.h:210
NULL
#define NULL
Definition omList.c:12
dim
int dim(ideal I, ring r)
Definition tropicalStrategy.cc:23

## nforder() [2/3]

nforder::nforder | ( | nforder * | o,
|  | bigintmat * | base,
|  | number | div,
|  | const coeffs | q )

Definition at line 42 of file nforder.cpp.

{
init();
m_coeffs = q;
basis = new bigintmat(base);
//neue Ordnung erzeugen und übergebene Daten kopieren
baseorder = o;
o->ref_count_incref();
//Gibt es eine Baseorder, brauchen wir keine Multtable. Könnte aber evtl. generiert werden
multtable = NULL;
divisor = n_Copy(div,basecoeffs());
basis->simplifyContentDen(&divisor);
dimension = o->getDim();
discriminant = NULL;
inv_basis = new bigintmat(base->rows(), base->rows(), q);
inv_divisor = basis->pseudoinv(inv_basis);
inv_basis->skalmult(divisor, q);
inv_basis->simplifyContentDen(&inv_divisor);
}
div
CF_NO_INLINE FACTORY_PUBLIC CanonicalForm div(const CanonicalForm &, const CanonicalForm &)
nforder::discriminant
number discriminant
Definition nforder.h:30
nforder::baseorder
nforder * baseorder
Definition nforder.h:34
nforder::basecoeffs
coeffs basecoeffs() const
Definition nforder.h:76
nforder::inv_divisor
number inv_divisor
Definition nforder.h:39
nforder::ref_count_incref
int ref_count_incref()
Definition nforder.h:50
nforder::divisor
number divisor
Definition nforder.h:36
nforder::getDim
int getDim()
Definition nforder.cpp:235
n_Copy
static FORCE_INLINE number n_Copy(number n, const coeffs r)
return a copy of 'n'
Definition coeffs.h:457
CxxTest::base
char N base
Definition ValueTraits.h:144

## nforder() [3/3]

nforder::nforder | ( | nforder * | o,
|  | int | )

Definition at line 62 of file nforder.cpp.

{
init();
m_coeffs = o->basecoeffs();
::Print("copy called: %lx\n", (long unsigned int) m_coeffs);
// Kopiert die Daten der übergebenen Ordnung auf die erzeugte
if (o->discriminant)
discriminant = n_Copy(o->discriminant, basecoeffs());
// get-Funktionen liefern immer nur Kopien der Attribute zurück
dimension = o->getDim();
multtable = (bigintmat **)omAlloc(dimension*sizeof(bigintmat*));
if (!o->getMult(multtable)) {
omFree(multtable);
multtable = NULL;
}
baseorder = o->getBase();
if (baseorder) baseorder->ref_count_incref();
basis = o->getBasis();
if (o->divisor)
divisor = n_Copy(o->divisor, basecoeffs());
if (o->inv_basis) {
inv_basis = new bigintmat(o->inv_basis);
inv_divisor = n_Copy(o->inv_divisor, basecoeffs());
}
}
nforder::Print
void Print()
Definition nforder.cpp:126
nforder::getBase
nforder * getBase()
Definition nforder.cpp:268
nforder::getBasis
bigintmat * getBasis()
Definition nforder.cpp:239
nforder::getMult
bool getMult(bigintmat **m)
Definition nforder.cpp:251
omFree
#define omFree(addr)
Definition omAllocDecl.h:261

## ~nforder()

nforder::~nforder | ( |  | ) |

Definition at line 139 of file nforder.cpp.

{
if (multtable != NULL) {
for (int i=0; i<dimension; i++)
delete multtable[i];
omFree(multtable);
}
else
{
// andernfalls werden baseorder und basis gelöscht
nforder_delete (baseorder);
delete basis;
if (divisor) n_Delete(&divisor, basecoeffs());
if (inv_basis) delete inv_basis;
if (inv_divisor) n_Delete(&inv_divisor, basecoeffs());
}
if (discriminant) n_Delete(&discriminant, basecoeffs());
}
n_Delete
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete 'p'
Definition coeffs.h:461
nforder_delete
void nforder_delete(nforder *o)
Definition nforder.cpp:132

## Member Function Documentation

## basecoeffs()

coeffs nforder::basecoeffs | ( |  | ) | const

inline

Definition at line 76 of file nforder.h.

{ return m_coeffs; }

## calcdisc()

void nforder::calcdisc | ( |  | ) |

Definition at line 162 of file nforder.cpp.

{
// Determinante von Spurmatrix ist die Discriminante
if (discriminant) return;
if (baseorder == NULL) {
bigintmat *m = traceMatrix();
discriminant = m->det();
assume(discriminant);
delete m;
}
else
{
number prod = n_Init(1, basecoeffs());
number tmp, tmp2; //assumes that the basis is triangular!
for (int i=1; i<=dimension; i++) {
tmp2 = basis->view(i, i);
tmp = n_Mult(prod, tmp2, basecoeffs());
n_Delete(&prod, basecoeffs());
prod = tmp;
}
baseorder->calcdisc();
number disc = baseorder->viewDisc();
assume(disc);
number detquad = n_Mult(prod, prod, basis->basecoeffs());
discriminant = n_Mult(disc, detquad, basecoeffs());
for (int i=1; i<=2*dimension; i++) {
tmp = n_Div(discriminant, divisor, basecoeffs());
n_Delete(&discriminant, basecoeffs());
discriminant = tmp;
}
n_Delete(&detquad, basis->basecoeffs());
}
}
nforder::traceMatrix
bigintmat * traceMatrix()
Definition nforder.cpp:196
n_Mult
static FORCE_INLINE number n_Mult(number a, number b, const coeffs r)
return the product of 'a' and 'b', i.e., a*b
Definition coeffs.h:639
n_Div
static FORCE_INLINE number n_Div(number a, number b, const coeffs r)
return the quotient of 'a' and 'b', i.e., a/b; raises an error if 'b' is not invertible in r exceptio...
Definition coeffs.h:618
n_Init
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:541
tmp2
CFList tmp2
Definition facFqBivar.cc:75
prod
fq_nmod_poly_t prod
Definition facHensel.cc:100
assume
#define assume(x)
Definition mod2.h:389

## createmulttable()

void nforder::createmulttable | ( | bigintmat ** | a | ) |

Definition at line 677 of file nforder.cpp.

{
// Falls es eine Multtable gibt, liefere eine Kopie davon zurück
if (multtable != NULL) {
for (int i=0; i<dimension; i++) {
a[i] = new bigintmat(multtable[i]);
}
}
else {
// Sonst berechne sie auf kanonische Art und Weise
bigintmat *bas = new bigintmat(1, dimension, basecoeffs());
for (int i=0; i<dimension; i++) {
basis_elt(bas, i+1);
a[i] = new bigintmat(dimension, dimension, basecoeffs());
multmap(bas, a[i]);
}
}
}
nforder::multmap
void multmap(bigintmat *a, bigintmat *m)
Definition nforder.cpp:404
basis_elt
void basis_elt(bigintmat *m, int i)
Definition nforder.cpp:422

## elAdd()

void nforder::elAdd | ( | bigintmat * | a,
|  | bigintmat * | b )

Definition at line 301 of file nforder.cpp.

{
if ((a->cols() != 1) || (a->rows() != dimension) || (b->cols() != 1) || (b->rows() != dimension)) {
Werror("Error in elSub");
}
else {
a->add(b);
}
}
b
CanonicalForm b
Definition cfModGcd.cc:4111
bigintmat::cols
int cols() const
Definition bigintmat.h:144
bigintmat::add
bool add(bigintmat *b)
Addiert zur Matrix die Matrix b dazu. Return false => an error occurred.
Definition bigintmat.cc:889
bigintmat::rows
int rows() const
Definition bigintmat.h:145
Werror
void Werror(const char *fmt,...)
Definition reporter.cc:189

## elMult()

void nforder::elMult | ( | bigintmat * | a,
|  | bigintmat * | b )

Definition at line 321 of file nforder.cpp.

{
if ((a->cols() != 1) || (a->rows() != dimension) || (b->cols() != 1) || (b->rows() != dimension)) {
// Kein Zeilenvektor der korrekten Größe
Werror("Error in elMult");
}
coeffs C = a->basecoeffs();
assume(C == b->basecoeffs());
assume(C == this->basecoeffs());
if (multtable != NULL) {
// Multiplikation mit Hilfe von Multiplikationstabelle
// Zu Grunde liegende Formel: Basis w_i; Für alpha = sum a_i*w_i und beta = sum b_i*w_i gilt:
// alpha*beta = sum sum a_i*b_j*w_i*w_j
bigintmat *sum = new bigintmat(dimension, 1, C);
bigintmat *tmp = new bigintmat(dimension, 1, C);
number ntmp;
for (int i=1; i<=dimension; i++) {
// Laufe mit i durch Basiselemente
for (int j=1; j<=dimension; j++) {
// Laufe mit j durch Basiselemente
// Speichere Produkt von Basiselem. i mit Basiselem. j als Koeff.vektor in tmp
multtable[i-1]->getcol(j, tmp);
// Multipliziere ihn mit a[i] und b[j]
ntmp = n_Mult(a->view(i, 1), b->view(j, 1), C);
tmp->skalmult(ntmp, C);
n_Delete(&ntmp, C);
// und addiere alles auf
sum->add(tmp);
}
}
delete tmp;
// Am Ende überschreibe a mit dem Ergebnis
for (int i=0; i<dimension; i++)
a->set(i+1, 1, sum->get(i+1, 1));
delete sum;
} else {
// Multiplikation mit hilfe von baseorder:
bigintmat *sumb = new bigintmat(dimension, 1, C);
// Produkt von a (b) mit basis liefert Koeff-Vektor von a*divisor (b*divisor) in baseorder
bimMult(basis, a, a);
bimMult(basis, b, sumb);
// Multipliziere Elemente in baseorder (und speichere in suma)
baseorder->elMult(a, sumb);
delete sumb;
a->skaldiv(divisor);
bimMult(inv_basis, a, a);
a->skaldiv(inv_divisor);
a->skaldiv(divisor);
}
}
bimMult
bigintmat * bimMult(bigintmat *a, bigintmat *b)
Definition bigintmat.cc:253
bigintmat::skalmult
bool skalmult(number b, coeffs c)
Multipliziert zur Matrix den Skalar b hinzu.
Definition bigintmat.cc:933
bigintmat::skaldiv
void skaldiv(number b)
Macht Ganzzahldivision aller Matrixeinträge mit b.
Definition bigintmat.cc:1851
bigintmat::get
number get(int i, int j) const
get a copy of an entry. NOTE: starts at [1,1]
Definition bigintmat.cc:117
bigintmat::view
number view(int i, int j) const
view an entry an entry. NOTE: starts at [1,1]
Definition bigintmat.cc:125
bigintmat::basecoeffs
coeffs basecoeffs() const
Definition bigintmat.h:146
bigintmat::set
void set(int i, int j, number n, const coeffs C=NULL)
replace an entry with a copy (delete old + copy new!). NOTE: starts at [1,1]
Definition bigintmat.cc:93
j
int j
Definition facHensel.cc:110

## elNorm()

number nforder::elNorm | ( | bigintmat * | a | ) |

Definition at line 387 of file nforder.cpp.

{
bigintmat * rep_mat = elRepMat(a);
number n = rep_mat->det();
delete rep_mat;
return n;
}
bigintmat::det
number det()
det (via LaPlace in general, hnf for euc. rings)
Definition bigintmat.cc:1507
nforder::elRepMat
bigintmat * elRepMat(bigintmat *a)
Definition nforder.cpp:395

## elRepMat()

bigintmat * nforder::elRepMat | ( | bigintmat * | a | ) |

Definition at line 395 of file nforder.cpp.

{
bigintmat *b=new bigintmat(dimension, dimension, basecoeffs());
multmap(a, b);
return b;
}

## elSub()

void nforder::elSub | ( | bigintmat * | a,
|  | bigintmat * | b )

Definition at line 311 of file nforder.cpp.

{
if ((a->cols() != 1) || (a->rows() != dimension) || (b->cols() != 1) || (b->rows() != dimension)) {
// Kein Zeilenvektor der korrekten Größe
Werror("Error in elSub");
}
else {
a->sub(b);
}
}
bigintmat::sub
bool sub(bigintmat *b)
Subtrahiert ...
Definition bigintmat.cc:911

## elTrace()

number nforder::elTrace | ( | bigintmat * | a | ) |

Definition at line 379 of file nforder.cpp.

{
bigintmat * rep_mat = elRepMat(a);
number t = rep_mat->trace();
delete rep_mat;
return t;
}
bigintmat::trace
number trace()
the trace ....
Definition bigintmat.cc:1493

## getBase()

nforder * nforder::getBase | ( |  | ) |

Definition at line 268 of file nforder.cpp.

{
// returns the baseorder, if present. Does not incref the ref count.
if (baseorder == NULL)
return NULL;
return baseorder;
}

## getBasis()

bigintmat * nforder::getBasis | ( |  | ) |

Definition at line 239 of file nforder.cpp.

{
// Falls basis ein NULL-Pointer ist, liefere NULL zurück, andernfalls liefere eine Kopie von basis
if (basis == NULL)
return NULL;
bigintmat *m = new bigintmat(basis); //wenn Fehler dann hier
return m;
}

## getDim()

int nforder::getDim | ( |  | ) |

Definition at line 235 of file nforder.cpp.

{
return dimension;
}

## getDisc()

number nforder::getDisc | ( |  | ) |

Definition at line 227 of file nforder.cpp.

{
// Falls Discriminante bisher noch nicht berechnet wurde, berechne diese
if (!discriminant || n_IsZero(discriminant, basecoeffs())) {
calcdisc();
}
return n_Copy(discriminant, basecoeffs());
}
nforder::calcdisc
void calcdisc()
Definition nforder.cpp:162
n_IsZero
static FORCE_INLINE BOOLEAN n_IsZero(number n, const coeffs r)
TRUE iff 'n' represents the zero element.
Definition coeffs.h:470

## getDiv()

number nforder::getDiv | ( |  | ) |

Definition at line 264 of file nforder.cpp.

{
return n_Copy(divisor, basecoeffs());
}

## getMult()

bool nforder::getMult | ( | bigintmat ** | m | ) |

Definition at line 251 of file nforder.cpp.

{
// Falls multtable ein NULL-Pointer ist, liefere NULL zurück, andernfalls erzeuge neues Array of Matrix, kopiere die Matrizen aus multtable dort hinein, und gib es zurück
if (multtable == NULL) {
return false;
}
for (int i=0; i<dimension; i++)
{
m[i] = new bigintmat(multtable[i]);
}
return true;
}

## init()

void nforder::init | ( |  | ) |

private

Definition at line 16 of file nforder.cpp.

{
rc = 1;
// Gibt es eine Multtable, so gibt es keine Baseorder
baseorder = NULL;
basis = NULL;
// Discriminante wird erst berechnet, wenn sie benötigt wird
discriminant = NULL;
divisor = NULL;
flags = 0;
multtable = NULL;
m_coeffs = NULL;
setOneIsOne();
}
nforder::flags
int flags
Definition nforder.h:40
nforder::rc
int rc
Definition nforder.h:29
nforder::setOneIsOne
void setOneIsOne()
Definition nforder.h:85

## isMaximal()

bool nforder::isMaximal | ( |  | ) |

inline

Definition at line 88 of file nforder.h.

{return isMaximalKnown() && (flags & (1<<is_maximal_known));};
nforder::isMaximalKnown
bool isMaximalKnown()
Definition nforder.h:87
is_maximal_known
@ is_maximal_known
Definition nforder.h:19

## isMaximalKnown()

bool nforder::isMaximalKnown | ( |  | ) |

inline

Definition at line 87 of file nforder.h.

{return (flags & (1<<is_maximal_known)) != 0;};

## multmap()

void nforder::multmap | ( | bigintmat * | a,
|  | bigintmat * | m )

Definition at line 404 of file nforder.cpp.

{
if ((m->cols() != dimension) || (m->rows() != dimension)) {
Werror("Error in multmap");
return;
}
bigintmat *bas = new bigintmat(dimension, 1, basecoeffs());
for (int i=1; i<=dimension; i++) {
// Durchläuft alle Basiselemente
// Multipliziert i-tes Basiselement mit a
basis_elt(bas, i);
elMult(bas, a);
// Schreibt Ergebnis in i-te Zeile der Matrix m. Am Ende ist m dann die Abbildungsmatrix der Multiplikation mit a
m->setcol(i, bas);
}
delete bas;
}
nforder::elMult
void elMult(bigintmat *a, bigintmat *b)
Definition nforder.cpp:321

## oneIsOne()

bool nforder::oneIsOne | ( |  | ) |

inline

Definition at line 84 of file nforder.h.

{return (flags & (1<<one_is_one)) != 0;}
one_is_one
@ one_is_one
Definition nforder.h:18

## Print()

void nforder::Print | ( |  | ) |

Definition at line 126 of file nforder.cpp.

{
char * s = String();
PrintS(s);
PrintS("\n");
omFree(s);
}
nforder::String
char * String()
Definition nforder.cpp:121
s
const CanonicalForm int s
Definition facAbsFact.cc:51
PrintS
void PrintS(const char *s)
Definition reporter.cc:288

## ref_count()

int nforder::ref_count | ( |  | ) |

inline

Definition at line 52 of file nforder.h.

{return rc;};

## ref_count_decref()

int nforder::ref_count_decref | ( |  | ) |

inline

Definition at line 51 of file nforder.h.

{return rc--;};

## ref_count_incref()

int nforder::ref_count_incref | ( |  | ) |

inline

Definition at line 50 of file nforder.h.

{return rc++;};

## setIsMaximal()

void nforder::setIsMaximal | ( | bool | is | ) |

inline

Definition at line 89 of file nforder.h.

{flags = (flags & (~((1<<is_maximal_known) + (1<<is_maximal)))) | (1<<is_maximal_known) | (is*(1<<is_maximal));};
is_maximal
@ is_maximal
Definition nforder.h:20

## setOneIsOne()

void nforder::setOneIsOne | ( |  | ) |

inline

Definition at line 85 of file nforder.h.

{flags |= (1<<one_is_one);}

## simplify()

nforder * nforder::simplify | ( |  | ) |

Definition at line 275 of file nforder.cpp.

{
coeffs c = basecoeffs();
if (!baseorder || !baseorder->baseorder) {
ref_count_incref();
return this;
}
nforder * O = baseorder;
number den = n_Copy(divisor, c);
bigintmat *bas = getBasis();
while (O->baseorder) {
bigintmat * b = bimMult(bas, O->viewBasis());
n_InpMult(den, O->divisor, c);
O = O->baseorder;
delete bas;
bas = b;
}
nforder * res = new nforder(O, bas, den, c);
if (discriminant)
res->discriminant = n_Copy(discriminant, c);
//TODO: copy multtable if we have it
delete bas;
n_Delete(&den, c);
return res;
}
den
CanonicalForm den(const CanonicalForm &f)
Definition canonicalform.h:340
nforder::viewBasis
bigintmat * viewBasis()
Definition nforder.cpp:246
nforder::nforder
nforder(int dim, bigintmat **m, const coeffs q)
0 Konstruktoren/Destruktoren ///
Definition nforder.cpp:30
n_InpMult
static FORCE_INLINE void n_InpMult(number &a, number b, const coeffs r)
multiplication of 'a' and 'b'; replacement of 'a' by the product a*b
Definition coeffs.h:644
res
CanonicalForm res
Definition facAbsFact.cc:60

## String()

char * nforder::String | ( |  | ) |

Definition at line 121 of file nforder.cpp.

{
StringSetS("");
Write();
return StringEndS();
}
nforder::Write
void Write()
Definition nforder.cpp:87
StringSetS
void StringSetS(const char *st)
Definition reporter.cc:128
StringEndS
char * StringEndS()
Definition reporter.cc:151

## traceMatrix()

bigintmat * nforder::traceMatrix | ( |  | ) |

Definition at line 196 of file nforder.cpp.

{
bigintmat *m = new bigintmat(dimension, dimension, basecoeffs());
bigintmat *base1 = new bigintmat(dimension, 1, basecoeffs());
bigintmat *base2 = new bigintmat(dimension, 1, basecoeffs());
bigintmat *mm = new bigintmat(dimension, dimension, basecoeffs());
number sum;
for (int i=1; i<=dimension; i++) {
for (int j=i; j<=dimension; j++) {
// Berechnet Produkt von Basiselementen i und j und speichert es in base1
basis_elt(base1, i);
basis_elt(base2, j);
elMult(base1, base2);
// Schreibt Abbildungsmatrix der Multiplikation mit base1 in mm
sum = elTrace(base1);
m->set(i, j, sum, basecoeffs());
if (i!=j)
m->set(j, i, sum, basecoeffs());
n_Delete(&sum, basecoeffs());
}
}
delete base1;
delete base2;
delete mm;
return m;
}
nforder::elTrace
number elTrace(bigintmat *a)
Definition nforder.cpp:379

## viewBasis()

bigintmat * nforder::viewBasis | ( |  | ) |

Definition at line 246 of file nforder.cpp.

{
if (basis == NULL)
return NULL;
return basis;
}

## viewDisc()

number nforder::viewDisc | ( |  | ) |

inline

Definition at line 74 of file nforder.h.

{return discriminant;};

## Write()

void nforder::Write | ( |  | ) |

Definition at line 87 of file nforder.cpp.

{
StringAppend("Order:\nof dimension %d and rc: %d\n", dimension, ref_count());
if (discriminant && !n_IsZero(discriminant, m_coeffs)) {
StringAppend("and discriminant: ");
n_Write(discriminant, m_coeffs);
StringAppend("\n");
}
// coeffs
if (multtable) {
StringAppend("Multiplication table:\n");
for(int i=0; i<dimension; i++) {
StringAppend("%d: ", i);
multtable[i]->Write();
StringAppendS("\n");
}
}
if (baseorder) {
StringAppendS("as extension of:");
baseorder->Write();
StringAppendS("with basis:\n");
basis->Write();
StringAppendS("and denominator: ");
n_Write(divisor, m_coeffs);
StringAppendS("\nwith inv_basis:\n");
inv_basis->Write();
StringAppendS("and inv_denominator: ");
n_Write(inv_divisor, m_coeffs);
StringAppendS("\n");
}
StringAppend("Flags: %lx\n", flags);
}
nforder::ref_count
int ref_count()
Definition nforder.h:52
n_Write
static FORCE_INLINE void n_Write(number n, const coeffs r, const BOOLEAN bShortOut=TRUE)
Definition coeffs.h:594
StringAppend
#define StringAppend
Definition emacs.cc:79
StringAppendS
void StringAppendS(const char *st)
Definition reporter.cc:107

## Field Documentation

## baseorder

nforder* nforder::baseorder

private

Definition at line 34 of file nforder.h.

## basis

bigintmat* nforder::basis

private

Definition at line 35 of file nforder.h.

## dimension

int nforder::dimension

private

Definition at line 31 of file nforder.h.

## discriminant

number nforder::discriminant

private

Definition at line 30 of file nforder.h.

## divisor

number nforder::divisor

private

Definition at line 36 of file nforder.h.

## flags

int nforder::flags

private

Definition at line 40 of file nforder.h.

## inv_basis

bigintmat* nforder::inv_basis

private

Definition at line 38 of file nforder.h.

## inv_divisor

number nforder::inv_divisor

private

Definition at line 39 of file nforder.h.

## m_coeffs

coeffs nforder::m_coeffs

private

Definition at line 32 of file nforder.h.

## multtable

bigintmat** nforder::multtable

private

Definition at line 33 of file nforder.h.

## rc

int nforder::rc

private

Definition at line 29 of file nforder.h.

The documentation for this class was generated from the following files:

- Singular/dyn_modules/Order/nforder.h
- Singular/dyn_modules/Order/nforder.cpp