1 //////////////////////////////////////////
2 //////////////////////////////////////////
3 ////     Einfache Ordnungs-Klasse     ////
4 //////////////////////////////////////////
5 // Kira Kraft, Jan Albert, Marco Sieben //
6 /////// Praktikum bei Herrn Fieker ///////
7 //////////////////////////////////////////
8 //////////////////////////////////////////
9 /*
10  * - Einer Ordnung liegt entweder eine Multiplikationstabelle zu Grunde, oder sie wird durch eine O-Basis erzeugt, wobei O eine andere Ordnung ist
11  * - Ordnungselemente werden als Koeffizientenvektoren (Klasse matrix, Zeilenvektoren!) dargestellt und können addiert/subtrahiert/multipliziert werden
12  * - Die Diskriminante kann von selbst berechnet werden
13 */
14 #ifndef NFORDER_HPP
15 #define NFORDER_HPP
16 
17 enum order_flags_log {
18   one_is_one, //if 1 is the first basis element
19   is_maximal_known,
20   is_maximal
21 };
22 
23 class nforder
24 {
25 private:
26   ////////////////////////////////////
27   ////////// Membervariablen /////////
28   ////////////////////////////////////
29   int rc;
30   number discriminant;
31   int dimension;
32   coeffs m_coeffs;
33   bigintmat **multtable; // Multiplikationstabelle als Array von Matrizen ...
34   nforder *baseorder; // ... oder zu Grunde liegende Ordnung
35   bigintmat *basis; // Lin.Komb. der Basiselemente von baseorder zu Basiselementen der Ordnung (Eine Zeile ^= ein Basiselement)
36   number divisor; // Hauptnenner der Linearkombination der Basiselemente
37     // Entweder multtable oder baseorder zeigt auf NULL - je nachdem, wie die Ordnung konstruiert wurde
38   bigintmat *inv_basis; // (inv_basis/inv_divisor) = (basis/divisor)^-1
39   number inv_divisor; //
40   int flags;
41 
42   ////////////////////////////////////
43   /////// -1 Memberfunktionen ////////
44   ////////////////////////////////////
45   // Genauere Beschreibung aller Funktionen in der Funktionen.odt
46 
47   void init(); //basic initialisation
48 public:
49   void calcdisc(); // Berechnet Diskriminante
ref_count_incref()50   inline int ref_count_incref(){return rc++;};
ref_count_decref()51   inline int ref_count_decref(){return rc--;};
ref_count()52   inline int ref_count(){return rc;};
53 
54 
55   ////////////////////////////////////
56   /// 0 Konstruktoren/Destruktoren ///
57   ////////////////////////////////////
58    //Lädt entweder Multiplikationstabelle von location, oder legt Ordnung o zu Grunde (mit Basis base und Hauptnenner div)
59   nforder(int dim, bigintmat **m, const coeffs q); // (keine Übergabe von const char *, sondern von bigintmat *, diese wird kopiert und als multtable verwendet)
60   nforder(nforder *o, bigintmat *base, number div, const coeffs q);
61   nforder(nforder *o, int);
62 
63   ~nforder();
64   void Write();
65   char* String();
66   void Print();
67   nforder *simplify(); //collapses a tower: multipy all bases together
68 
69   ////////////////////////////////////
70   // +1 Zugriff auf Membervariablen //
71   ////////////////////////////////////
72 
73   number getDisc();
viewDisc()74   inline number viewDisc(){return discriminant;};
75   int getDim();
basecoeffs()76   inline coeffs basecoeffs() const { return m_coeffs; }
77   number getDiv();
78   // Liefert Zeiger auf Kopier der Objekte zurück
79   bool getMult(bigintmat **m);
80   nforder *getBase();
81   bigintmat *getBasis();
82   bigintmat *viewBasis();
83 
oneIsOne()84   inline bool oneIsOne() {return (flags & (1<<one_is_one)) != 0;}
setOneIsOne()85   inline void setOneIsOne() {flags |= (1<<one_is_one);}
86 
isMaximalKnown()87   inline bool isMaximalKnown() {return (flags & (1<<is_maximal_known)) != 0;};
isMaximal()88   inline bool isMaximal() {return isMaximalKnown() && (flags & (1<<is_maximal_known));};
setIsMaximal(bool is)89   inline void setIsMaximal(bool is) {flags = (flags & (~((1<<is_maximal_known) + (1<<is_maximal)))) | (1<<is_maximal_known) | (is*(1<<is_maximal));};
90 
91 
92 
93   ////////////////////////////////////
94   ////// +2 Elementoperationen ///////
95   ////////////////////////////////////
96   // Addiert/Subtrahiert/Multipliziert zu a das Element b hinzu
97   void elAdd(bigintmat *a, bigintmat *b);
98   void elSub(bigintmat *a, bigintmat *b);
99   void elMult(bigintmat *a, bigintmat *b);
100   number elTrace(bigintmat *a);
101   number elNorm(bigintmat *a);
102   bigintmat * elRepMat(bigintmat *a);
103 
104   ////////////////////////////////////
105   //// +3 Funktionen für Round 2 /////
106   ////////////////////////////////////
107   // long long int getsmallestsqprime();
108   /* Liefert kleinste Primzahl >= p, die die Diskriminante quadratisch teilt  */
109   void multmap(bigintmat *a, bigintmat *m);
110   bigintmat *traceMatrix();
111 
112   void createmulttable(bigintmat **a);
113 
114 };
115 
116 ////////////////////////////////////
117 ////// 1 Komfortfunktionen /////////
118 ////////////////////////////////////
119 /* Setzt Vektor m auf (0,...,0,1,0,...,0) (i-ten Basisvektor)  */
120 void basis_elt(bigintmat *m, int i);
121 
122 ////////////////////////////////////
123 //////////// 2 Round 2 /////////////
124 ////////////////////////////////////
125 /* Liefert bzgl. Primzahl p um eines größere Ordnung von o zurück */
126 nforder *onestep(nforder *o, number p, coeffs c);
127 /* Macht liefert p-maximale Ordnung von o zurück  */
128 nforder *pmaximal(nforder *o, number p);
129 /* Liefert Maximalordnung, ausgehend von o, zurück  */
130 nforder *round2(nforder *o); // Benötigt Faktorisierung der Diskriminanten
131 /* Liefert Basis von I_p(O)/pI_p(O)  */
132 bigintmat *radicalmodpbase(nforder *o, number p, coeffs c);
133 /* Berechnet die Basis mit Hilfe der langen Matrix  */
134 number multring(bigintmat* nbase, nforder *o, number p);
135 void nforder_delete(nforder *o);
136 
137 #endif
138