Frobby 0.10.0
Loading...
Searching...
No Matches
RawSquareFreeIdeal.h
1/* Frobby: Software for monomial ideal computations.
2 Copyright (C) 2010 University of Aarhus
3 Contact Bjarke Hammersholt Roune for license information (www.broune.com)
4
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 2 of the License, or
8 (at your option) any later version.
9
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
14
15 You should have received a copy of the GNU General Public License
16 along with this program. If not, see http://www.gnu.org/licenses/.
17*/
18#ifndef RAW_SQUARE_FREE_IDEAL_GUARD
19#define RAW_SQUARE_FREE_IDEAL_GUARD
20
21#include <ostream>
22#include <vector>
23
24class Ideal;
25class BigIdeal;
26
37class RawSquareFreeIdeal {
38 public:
39 static RawSquareFreeIdeal* construct(void* buffer, size_t varCount = 0);
40 static RawSquareFreeIdeal* construct(void* buffer, const Ideal& ideal);
41 static RawSquareFreeIdeal* construct(void* buffer,
42 const RawSquareFreeIdeal& ideal);
43
52 static size_t getBytesOfMemoryFor(size_t varCount, size_t generatorCount);
53
55 RawSquareFreeIdeal& operator=(const RawSquareFreeIdeal& ideal)
56 {return *construct(this, ideal);}
57
72 void setToTransposeOf(const RawSquareFreeIdeal& ideal, Word* eraseVars = 0);
73
75 void transpose(Word* eraseVars = 0);
76
82 void compact(const Word* remove);
83
85 void print(FILE* file) const;
86
88 void print(ostream& out) const;
89
95 size_t insert(const Ideal& ideal);
96 size_t insert(const BigIdeal& ideal);
97
99 void insert(const RawSquareFreeIdeal& ideal);
100
101 void insert(const Word* term);
102 void insertIdentity();
103
105 bool insert(const std::vector<std::string>& term);
106 void minimize();
107 void colon(const Word* by);
108 void colon(size_t var);
109
111 void colonReminimize(const Word* colon);
112
115 void colonReminimize(size_t var);
116
118 void swap01Exponents();
119
122 void getLcm(Word* lcm) const;
123
124 size_t getGeneratorCount() const {return _genCount;}
125 size_t getVarCount() const {return _varCount;}
126 size_t getWordsPerTerm() const {return _wordsPerTerm;}
127
129 Word* getGenerator(size_t index);
130
132 const Word* getGenerator(size_t index) const;
133
137 Word* getGeneratorUnsafe(size_t index);
138
142 const Word* getGeneratorUnsafe(size_t index) const;
143
146 void getLcmOfNonMultiples(Word* lcm, size_t var) const;
147
150 void getGcdOfMultiples(Word* gcd, size_t var) const;
151
154 void getGcdOfMultiples(Word* gcd, const Word* div) const;
155
157 void getVarDividesCounts(vector<size_t>& counts) const;
158
161 size_t getMultiple(size_t var) const;
162
165 size_t getNonMultiple(size_t var) const;
166
169 size_t getMaxSupportGen() const;
170
173 size_t getMinSupportGen() const;
174
176 void removeGenerator(size_t index);
177
179 void insertNonMultiples(const Word* term, const RawSquareFreeIdeal& ideal);
180
182 void insertNonMultiples(size_t var, const RawSquareFreeIdeal& ideal);
183
187 size_t getNotRelativelyPrime(const Word* term);
188
193
196 bool hasFullSupport(const Word* ignore) const;
197
199 bool isMinimallyGenerated() const;
200
201 void swap(size_t a, size_t b);
202
206 bool operator==(const RawSquareFreeIdeal& ideal) const;
207 bool operator!=(const RawSquareFreeIdeal& ideal) const {
208 return !(*this == ideal);
209 }
210
211 Word* back() {iterator e = end(); --e; return *e;}
212 const Word* back() const {const_iterator e = end(); --e; return *e;}
213
215 void sortLexAscending();
216
219 class const_iterator {
220 public:
221 const_iterator(const Word* term, size_t wordsPerTerm):
222 _term(term), _wordsPerTerm(wordsPerTerm) {
223 }
224 const_iterator(const const_iterator&) = default;
225
226 const Word* operator*() const {return _term;}
227 const_iterator operator++() {_term += _wordsPerTerm; return *this;}
228 const_iterator operator--() {_term -= _wordsPerTerm; return *this;}
229
230 bool operator==(const const_iterator& it) const {
231 ASSERT(_wordsPerTerm == it._wordsPerTerm);
232 return _term == it._term;
233 }
234 bool operator!=(const const_iterator& it) const {
235 ASSERT(_wordsPerTerm == it._wordsPerTerm);
236 return _term != it._term;
237 }
238
239 ptrdiff_t operator-(const const_iterator& it) const {
240 ASSERT(_wordsPerTerm == it._wordsPerTerm);
241 return (_term - it._term) / _wordsPerTerm;
242 }
243 const_iterator operator+(ptrdiff_t i) const {
244 return const_iterator(_term + i * _wordsPerTerm, _wordsPerTerm);
245 }
246
247 const_iterator& operator=(const const_iterator& it) {
248 ASSERT(it._wordsPerTerm == _wordsPerTerm);
249 _term = it._term;
250 return *this;
251 }
252
253 private:
254 const Word* _term;
255 const size_t _wordsPerTerm;
256 };
257
260 class iterator {
261 public:
262 iterator(Word* term, size_t wordsPerTerm):
263 _term(term), _wordsPerTerm(wordsPerTerm) {
264 }
265 iterator(const iterator&) = default;
266
267 operator const_iterator() const {
268 return const_iterator(_term, _wordsPerTerm);
269 }
270
271 Word* operator*() const {return _term;}
272 iterator operator++() {_term += _wordsPerTerm; return *this;}
273 iterator operator--() {_term -= _wordsPerTerm; return *this;}
274
275 bool operator==(const iterator& it) const {
276 ASSERT(_wordsPerTerm == it._wordsPerTerm);
277 return _term == it._term;
278 }
279 bool operator!=(const iterator& it) const {
280 ASSERT(_wordsPerTerm == it._wordsPerTerm);
281 return _term != it._term;
282 }
283
284 ptrdiff_t operator-(const iterator& it) const {
285 ASSERT(_wordsPerTerm == it._wordsPerTerm);
286 return (_term - it._term) / _wordsPerTerm;
287 }
288 iterator operator+(ptrdiff_t i) const {
289 return iterator(_term + i * _wordsPerTerm, _wordsPerTerm);
290 }
291 iterator& operator=(const iterator& it) {
292 ASSERT(it._wordsPerTerm == _wordsPerTerm);
293 _term = it._term;
294 return *this;
295 }
296
297 private:
298 Word* _term;
299 const size_t _wordsPerTerm;
300 };
301
302 iterator begin()
303 {return iterator(_memory, getWordsPerTerm());}
304 const_iterator begin() const
305 {return const_iterator(_memory, getWordsPerTerm());}
306
307 iterator end()
308 {return iterator(_memoryEnd, getWordsPerTerm());}
309 const_iterator end() const
310 {return const_iterator(_memoryEnd, getWordsPerTerm());}
311
314 bool isValid() const;
315
316 private:
317 RawSquareFreeIdeal(); // Not available
318 RawSquareFreeIdeal(const RawSquareFreeIdeal&); // Not available
319
320 size_t _varCount;
321 size_t _wordsPerTerm;
322 size_t _genCount;
323 Word* _memoryEnd;
324 Word _memory[1]; // variable size array
325};
326
330RawSquareFreeIdeal* newRawSquareFreeIdeal(size_t varCount, size_t capacity);
331
333RawSquareFreeIdeal* newRawSquareFreeIdeal(const RawSquareFreeIdeal& ideal);
334
342RawSquareFreeIdeal* newRawSquareFreeIdealParse(const char* str);
343
345void deleteRawSquareFreeIdeal(RawSquareFreeIdeal* ideal);
346
347inline ostream& operator<<(ostream& out, const RawSquareFreeIdeal& ideal) {
348 ideal.print(out);
349 return out;
350}
351
353 ASSERT(index < getGeneratorCount());
354 return _memory + index * getWordsPerTerm();
355}
356
357inline const Word* RawSquareFreeIdeal::getGenerator(size_t index) const {
358 ASSERT(index < getGeneratorCount());
359 return _memory + index * getWordsPerTerm();
360}
361
363 // no assert to check index is valid as this method specifically
364 // allows out-of-bounds access.
365 return _memory + index * getWordsPerTerm();
366}
367
368inline const Word* RawSquareFreeIdeal::getGeneratorUnsafe(size_t index) const {
369 // no assert to check index is valid as this method specifically
370 // allows out-of-bounds access.
371 return _memory + index * getWordsPerTerm();
372}
373
374#endif
Definition BigIdeal.h:27
Represents a monomial ideal with int exponents.
Definition Ideal.h:27
Definition RawSquareFreeIdeal.h:219
Definition RawSquareFreeIdeal.h:260
Definition RawSquareFreeIdeal.h:37
void sortLexAscending()
Definition RawSquareFreeIdeal.cpp:623
size_t getNotRelativelyPrime(const Word *term)
Definition RawSquareFreeIdeal.cpp:513
bool isValid() const
Definition RawSquareFreeIdeal.cpp:774
bool hasFullSupport(const Word *ignore) const
Definition RawSquareFreeIdeal.cpp:545
void getGcdOfMultiples(Word *gcd, size_t var) const
Definition RawSquareFreeIdeal.cpp:455
bool operator==(const RawSquareFreeIdeal &ideal) const
Definition RawSquareFreeIdeal.cpp:597
size_t getExclusiveVarGenerator()
Definition RawSquareFreeIdeal.cpp:521
void getLcm(Word *lcm) const
Definition RawSquareFreeIdeal.cpp:765
size_t getMinSupportGen() const
Definition RawSquareFreeIdeal.cpp:435
void getVarDividesCounts(vector< size_t > &counts) const
Definition RawSquareFreeIdeal.cpp:366
void compact(const Word *remove)
Definition RawSquareFreeIdeal.cpp:264
void removeGenerator(size_t index)
Definition RawSquareFreeIdeal.cpp:480
void print(FILE *file) const
Definition RawSquareFreeIdeal.cpp:179
static size_t getBytesOfMemoryFor(size_t varCount, size_t generatorCount)
Definition RawSquareFreeIdeal.cpp:110
RawSquareFreeIdeal & operator=(const RawSquareFreeIdeal &ideal)
Definition RawSquareFreeIdeal.h:55
size_t getMaxSupportGen() const
Definition RawSquareFreeIdeal.cpp:415
Word * getGenerator(size_t index)
Definition RawSquareFreeIdeal.h:352
void colonReminimize(const Word *colon)
Definition RawSquareFreeIdeal.cpp:675
size_t getNonMultiple(size_t var) const
Definition RawSquareFreeIdeal.cpp:404
Word * getGeneratorUnsafe(size_t index)
Definition RawSquareFreeIdeal.h:362
size_t getMultiple(size_t var) const
Definition RawSquareFreeIdeal.cpp:393
size_t insert(const Ideal &ideal)
Definition RawSquareFreeIdeal.cpp:196
void transpose(Word *eraseVars=0)
Definition RawSquareFreeIdeal.cpp:168
void swap01Exponents()
Definition RawSquareFreeIdeal.cpp:651
void setToTransposeOf(const RawSquareFreeIdeal &ideal, Word *eraseVars=0)
Definition RawSquareFreeIdeal.cpp:140
bool isMinimallyGenerated() const
Definition RawSquareFreeIdeal.cpp:579
void getLcmOfNonMultiples(Word *lcm, size_t var) const
Definition RawSquareFreeIdeal.cpp:304
void insertNonMultiples(const Word *term, const RawSquareFreeIdeal &ideal)
Definition RawSquareFreeIdeal.cpp:490
unsigned long Word
Definition stdinc.h:60