Frobby 0.9.5
TransformAction.cpp
Go to the documentation of this file.
1/* Frobby: Software for monomial ideal computations.
2 Copyright (C) 2007 Bjarke Hammersholt Roune (www.broune.com)
3
4 This program is free software; you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation; either version 2 of the License, or
7 (at your option) any later version.
8
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
13
14 You should have received a copy of the GNU General Public License
15 along with this program. If not, see http://www.gnu.org/licenses/.
16*/
17#include "stdinc.h"
18#include "TransformAction.h"
19
20#include "BigIdeal.h"
21#include "IOFacade.h"
22#include "IdealFacade.h"
23#include "Scanner.h"
24#include "ElementDeleter.h"
25#include "VarSorter.h"
26#include "DataType.h"
27
28#include <algorithm>
29
31 Action
32(staticGetName(),
33 "Change the representation of the input ideal.",
34 "By default, transform simply writes the input ideals to output. A "
35 "number of parameters allow one to transform the input ideal in various ways.",
36 false),
37
38 _io(DataType::getMonomialIdealType(), DataType::getMonomialIdealType()),
39
40 _canonicalize
41 ("canon",
42 "Sort variables, generators and ideals to get canonical representation.",
43 false),
44
45 _sort
46 ("sort",
47 "Sort generators according to the reverse lexicographic order.",
48 false),
49
50 _unique
51 ("unique",
52 "Remove duplicate generators.",
53 false),
54
55 _minimize
56 ("minimize",
57 "Remove non-minimial generators.",
58 false),
59
60 _deform
61 ("deform",
62 "Apply a generic deformation to the input ideal.",
63 false),
64
65 _radical
66 ("radical",
67 "Take the radical of the generators. Combine this with -minimize to "
68 "get rid of any non-minimal ones.",
69 false),
70
71 _product
72 ("product",
73 "Replace each ideal with the product of its generators.",
74 false),
75
76 _addPurePowers
77 ("addPurePowers",
78 "Adds a pure power for each variable that does not already have a pure "
79 "power in the ideal. Each exponent is chosen to be one larger than the "
80 "maximal exponent of that variable that appears in the ideal.",
81 false),
82
83 _trimVariables
84 ("trimVariables",
85 "Remove variables that divide none of the generators.",
86 false),
87
88 _transpose
89 ("transpose",
90 "Exchange variables and minimal generators. Let M be a matrix whose "
91 "rows are labeled by minimal generators and whose columns are labeled "
92 "by variables. The entry at row g and column x is the number of times "
93 "that x divides g. This options transposes that matrix.",
94 false),
95
96 _swap01
97 ("swap01",
98 "Change all 0 exponents to 1 and vice versa.",
99 false),
100
101 _projectVar
102 ("projectVar",
103 "Project away the i'th variable counting from 1. No action is taken "
104 "for a value of 0 or more than the number of variables in the ring.",
105 0) {
106}
107
110 parameters.push_back(&_canonicalize);
111 parameters.push_back(&_minimize);
112 parameters.push_back(&_sort);
113 parameters.push_back(&_unique);
114 parameters.push_back(&_deform);
115 parameters.push_back(&_radical);
116 parameters.push_back(&_product);
117 parameters.push_back(&_addPurePowers);
118 parameters.push_back(&_trimVariables);
119 parameters.push_back(&_swap01);
120 parameters.push_back(&_projectVar);
121 parameters.push_back(&_transpose);
123}
124
129
131
135
136 facade.readIdeals(in, ideals, names);
137 in.expectEOF();
138
140
141 if (_transpose) {
142 names.clear();
143 for (size_t i = 0; i < ideals.size(); ++i) {
144 const BigIdeal& ideal = *(ideals[i]);
146 trans.reserve(ideal.getVarCount());
147 for (size_t var = 0; var < ideal.getVarCount(); ++var) {
148 trans.newLastTerm();
149 for (size_t gen = 0; gen < ideal.getGeneratorCount(); ++gen)
150 trans.getLastTermRef()[gen] = ideal[gen][var];
151 }
152 (*ideals[i]) = trans;
153 if (i == ideals.size() - 1)
154 names = ideal.getNames();
155 }
156 }
157
158 if (0 < _projectVar && _projectVar <= names.getVarCount()) {
159 size_t var = _projectVar - 1;
160 names.projectVar(var);
161
162 for (size_t i = 0; i < ideals.size(); ++i) {
163 BigIdeal& ideal = *(ideals[i]);
164 idealFacade.projectVar(ideal, var);
165 }
166 }
167
168 if (_product) {
169 auto_ptr<BigIdeal> ideal;
170 ideal.reset(new BigIdeal(names));
171
172 idealFacade.takeProducts(ideals, *ideal);
173
174 idealsDeleter.deleteElements();
176 }
177
178 for (size_t i = 0; i < ideals.size(); ++i) {
179 BigIdeal& ideal = *(ideals[i]);
180
181 if (_radical)
183
184 if (_swap01)
185 idealFacade.swap01(ideal);
186
187 if (_minimize)
188 idealFacade.sortAllAndMinimize(ideal);
189
190 if (_deform)
191 idealFacade.deform(ideal);
192 }
193
194 if (_trimVariables)
195 idealFacade.trimVariables(ideals, names);
196
197 for (size_t i = 0; i < ideals.size(); ++i) {
198 BigIdeal& ideal = *(ideals[i]);
199
200 if (_addPurePowers)
201 idealFacade.addPurePowers(ideal);
202
203 if (_canonicalize)
205
206 if (_unique)
207 idealFacade.sortGeneratorsUnique(ideal);
208 else if (_sort || _canonicalize)
209 idealFacade.sortGenerators(ideal);
210 }
211
212 if (_canonicalize) {
214 sorter.getOrderedNames(names);
215
216 sort(ideals.begin(), ideals.end(), compareIdeals);
217 }
218
220 facade.writeIdeals(ideals, names, output.get(), stdout);
221}
222
224 return "transform";
225}
226
228 return *a < *b;
229}
void exceptionSafePushBack(Container &container, auto_ptr< Element > pointer)
void nameFactoryRegister(NameFactory< AbstractProduct > &factory)
Registers the string returned by ConcreteProduct::getStaticName() to a function that default-construc...
BoolParameter _printActions
Definition Action.h:68
virtual void obtainParameters(vector< Parameter * > &parameters)
Definition Action.cpp:133
size_t getVarCount() const
Definition BigIdeal.h:148
const VarNames & getNames() const
Definition BigIdeal.cpp:253
size_t getGeneratorCount() const
Definition BigIdeal.h:144
void projectVar(size_t var)
Definition BigIdeal.cpp:158
void sortVariables()
Definition BigIdeal.cpp:298
void takeRadical()
Definition BigIdeal.cpp:264
The intention of this class is to describe the different kinds of mathematical structures that Frobby...
Definition DataType.h:29
A facade for input and output of mathematical objects.
Definition IOFacade.h:39
void autoDetectInputFormat(Scanner &in)
If using the input format, this must be called before validating the ideals, since the auto detect fo...
auto_ptr< IOHandler > createOutputHandler() const
const string & getInputFormat() const
void validateFormats() const
A facade for performing operations on BigIdeal.
Definition IdealFacade.h:34
void obtainParameters(vector< Parameter * > &parameters)
This class offers an input interface which is more convenient and for some purposes more efficient th...
Definition Scanner.h:50
static bool compareIdeals(const BigIdeal *a, const BigIdeal *b)
BoolParameter _deform
BoolParameter _canonicalize
BoolParameter _addPurePowers
BoolParameter _transpose
IOParameters _io
BoolParameter _swap01
virtual void obtainParameters(vector< Parameter * > &parameters)
BoolParameter _minimize
static const char * staticGetName()
BoolParameter _product
BoolParameter _unique
BoolParameter _sort
BoolParameter _radical
virtual void perform()
BoolParameter _trimVariables
IntegerParameter _projectVar
Defines the variables of a polynomial ring and facilities IO involving them.
Definition VarNames.h:40