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 /// More...
	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;
}

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);
}

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()

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());
}

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());
  }
}

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]);
    }
  }
}

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);
  }
}

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);
  }
}

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

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);
  }
}

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

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());
}

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();
}

isMaximal()

bool nforder::isMaximal ( )

inline

Definition at line 88 of file nforder.h.

{return isMaximalKnown() && (flags & (1<<is_maximal_known));};

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

oneIsOne()

bool nforder::oneIsOne ( )

inline

Definition at line 84 of file nforder.h.

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

Print()

void nforder::Print

(

)

Definition at line 126 of file nforder.cpp.

                    {
  char * s = String();
  PrintS(s);
  PrintS("\n");
  omFree(s);
}

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));};

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

String()

char * nforder::String

(

)

Definition at line 121 of file nforder.cpp.

                       {
  StringSetS("");
  Write();
  return StringEndS();
}

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

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);
}

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