1 /* 2 This is files.h 3 4 Coxeter version 3.0 Copyright (C) 2002 Fokko du Cloux 5 See file main.cpp for full copyright notice 6 */ 7 8 #ifndef FILES_H /* guard against multiple inclusions */ 9 #define FILES_H 10 11 #include "globals.h" 12 #include "hecke.h" 13 #include "invkl.h" 14 #include "kl.h" 15 #include "uneqkl.h" 16 #include "wgraph.h" 17 18 namespace files { 19 using namespace coxeter; 20 using namespace hecke; 21 using namespace wgraph; 22 // do _not_ use namespace kl! creates conflicts in coxgroup 23 24 /******** type declarations *************************************************/ 25 26 enum Header { bettiH, basisH, closureH, dufloH, extremalsH, ihBettiH, 27 lCOrderH, lCellsH, lCellWGraphsH, lWGraphH, lrCOrderH, 28 lrCellsH, lrCellWGraphsH, lrWGraphH, rCOrderH, rCellsH, 29 rCellWGraphsH, rWGraphH, slocusH, sstratificationH, 30 numHeaders}; 31 32 struct AddHeckeTraits; 33 struct HeckeTraits; 34 struct OutputTraits; 35 struct PolynomialTraits; 36 struct PosetTraits; 37 struct PartitionTraits; 38 struct WgraphTraits; 39 40 /******** function definitions **********************************************/ 41 42 template <class C> 43 void appendCoefficient(String& str, const C& c, 44 PolynomialTraits& traits); 45 template <class E> 46 void appendExponent(String& str, const E& e, PolynomialTraits& traits); 47 template <class M> 48 void appendHeckeMonomial(String& str, const M& m, const SchubertContext& p, 49 const Interface& I, HeckeTraits& hTraits, 50 PolynomialTraits& pTraits, const Length& l); 51 void appendHomology(String& str, const Homology& h, OutputTraits& traits); 52 template <class C> 53 void appendMonomial(String& str, const C& c, const Ulong& e, 54 PolynomialTraits& traits, 55 const Ulong& d = 1, const long& m = 0); 56 void appendModifier(String& str, const Ulong& d, const long& m, 57 PolynomialTraits& traits); 58 template <class M> 59 void appendMuMark(String& str, const M& m, const SchubertContext& p, 60 const Length& l, HeckeTraits& traits); 61 template <class P> 62 void appendPolynomial(String& str, const P& p, 63 PolynomialTraits& traits, 64 const Ulong& d = 1, const long& m = 0); 65 void appendSeparator(String& str, const Ulong& n, HeckeTraits& traits); 66 template <class KL> 67 void makeWGraph(WGraph& X, const List<CoxNbr>& c, const LFlags& f, KL& kl); 68 void minReps(List<CoxNbr>& min, const Partition& pi, schubert::NFCompare& c); 69 void pad(String& str, const Ulong& n, HeckeTraits& traits); 70 template<class H> 71 void printAsBasisElt(FILE* file, const H& h, const SchubertContext& p, 72 Interface& I, OutputTraits& traits); 73 void printBetti(FILE* file, const CoxNbr& y, const SchubertContext& p, 74 OutputTraits& traits); 75 void printCellOrder(FILE* file, const OrientedGraph& X, 76 const SchubertContext& p, const Interface& I, 77 PosetTraits& traits); 78 void printCoatoms(FILE* file, const CoxNbr& y, const SchubertContext& p, 79 const Interface& I, OutputTraits& traits); 80 template <class KL> 81 void printClosure(FILE* file, const CoxNbr& y, KL& kl, const Interface& I, 82 OutputTraits& traits); 83 template <class C> 84 void printCoefficient(FILE* file, const C& c, 85 PolynomialTraits& traits); 86 void printDescents(FILE* file, const LFlags& df, const LFlags& f, 87 const Interface& I, WgraphTraits& traits); 88 template <class KL> 89 void printDuflo(FILE* file, const List<CoxNbr>& d, const Partition& pi, 90 KL& kl, const Interface& I, OutputTraits& traits); 91 void printEltData(FILE* file, const CoxNbr& y, const SchubertContext& p, 92 const Interface& I, OutputTraits& traits); 93 template <class E> 94 void printExponent(FILE* file, const E& e, PolynomialTraits& traits); 95 template <class KL> 96 void printExtremals(FILE* file, const CoxNbr& y, const KL& kl, 97 const Interface& I, OutputTraits& traits); 98 void printHeader(FILE* file, const Header& header, OutputTraits& traits); 99 template <class H> 100 void printHeckeElt(FILE* file, const H& h, const SchubertContext& p, 101 const Interface& I, OutputTraits& traits, 102 const Length& l = undef_length); 103 template <class H> 104 void printHeckeElt(FILE* file, const H& h, const Permutation& a, 105 const SchubertContext& p, const Interface& I, 106 HeckeTraits& hTraits, 107 PolynomialTraits& pTraits, 108 const Length& l = undef_length); 109 void printHomology(FILE* file, const Homology& h, OutputTraits& traits); 110 template <class KL> 111 void printIHBetti(FILE* file, const CoxNbr& y, KL& kl, OutputTraits& traits); 112 template <class KL> 113 void printLCOrder(FILE* file, KL& kl, const Interface& I, 114 OutputTraits& traits); 115 template <class KL> 116 void printLCells(FILE* file, const Partition& lp, KL& kl, const Interface& I, 117 OutputTraits& traits); 118 template <class KL> 119 void printLCellWGraphs(FILE* file, const Partition& lp, KL& kl, 120 const Interface& I, OutputTraits& traits); 121 template <class KL> 122 void printLRCOrder(FILE* file, KL& kl, const Interface& I, 123 OutputTraits& traits); 124 template <class KL> 125 void printLRCells(FILE* file, const Partition& lp, KL& kl, 126 const Interface& I, OutputTraits& traits); 127 template <class KL> 128 void printLRCellWGraphs(FILE* file, const Partition& lp, KL& kl, 129 const Interface& I, OutputTraits& traits); 130 template <class KL> 131 void printLRWGraph(FILE* file, KL& kl, const Interface& I, 132 OutputTraits& traits); 133 template <class KL> 134 void printLWGraph(FILE* file, KL& kl, const Interface& I, 135 OutputTraits& traits); 136 template <class C> 137 void printMonomial(FILE* file, const C& c, const Ulong& e, 138 PolynomialTraits& traits, 139 const Ulong& d = 1, const long& m = 0); 140 void printModifier(FILE* file, const Ulong& d, const long& m, 141 PolynomialTraits& traits); 142 template <class M> 143 void printMuMark(FILE* file, const M& m, const SchubertContext& p, 144 const Length& l, HeckeTraits& traits); 145 void printPartition(FILE* file, const Partition& pi, const SchubertContext& p, 146 const Interface& I, PartitionTraits& traits); 147 template <class P> 148 void printPolynomial(FILE* file, const P& p, PolynomialTraits& traits, 149 const Ulong& d = 1, const long& m = 0); 150 template <class KL> 151 void printRCOrder(FILE* file, KL& kl, const Interface& I, 152 OutputTraits& traits); 153 template <class KL> 154 void printRCells(FILE* file, const Partition& lp, KL& kl, const Interface& I, 155 OutputTraits& traits); 156 template <class KL> 157 void printRCellWGraphs(FILE* file, const Partition& lp, KL& kl, 158 const Interface& I, OutputTraits& traits); 159 template <class KL> 160 void printRWGraph(FILE* file, KL& kl, const Interface& I, 161 OutputTraits& traits); 162 void printSeparator(FILE* file, const Ulong& n, HeckeTraits& traits); 163 template <class KL> 164 void printSingularLocus(FILE* file, const CoxNbr& y, KL& kl, 165 const Interface& I, OutputTraits& traits); 166 template <class KL> 167 void printSingularStratification(FILE* file, const CoxNbr& y, KL& kl, 168 const Interface& I, OutputTraits& traits); 169 void printWGraph(FILE* file, const WGraph& X, const LFlags& f, 170 const Interface& I, WgraphTraits& traits); 171 template <class KL> 172 void printWGraphList(FILE* file, const Partition& pi, const LFlags& f, 173 const Interface& I, KL& kl, OutputTraits& traits); 174 template <class H> 175 bool setTwoSided(const H& h, const Permutation& a, const SchubertContext& p, 176 const Interface& I, HeckeTraits& hTraits, 177 PolynomialTraits& pTraits, const Length& l = undef_length); 178 void sortLists(List<List<CoxNbr> >& lc, schubert::NFCompare& nfc, 179 Permutation& a); 180 void writeClasses(List<List<CoxNbr> >& lc, const Partition& pi); 181 182 /******** type definitions **************************************************/ 183 184 struct PolynomialTraits { 185 String prefix; 186 String postfix; 187 String indeterminate; 188 String sqrtIndeterminate; 189 String posSeparator; 190 String negSeparator; 191 String product; 192 String exponent; 193 String expPrefix; 194 String expPostfix; 195 String zeroPol; 196 String one; 197 String negOne; 198 String modifierPrefix; 199 String modifierPostfix; 200 String modifierSeparator; 201 bool printExponent; 202 bool printModifier; 203 // constructors and destructors newPolynomialTraits204 void* operator new(size_t size) {return arena().alloc(size);} deletePolynomialTraits205 void operator delete(void* ptr) 206 {return arena().free(ptr,sizeof(PolynomialTraits));} 207 PolynomialTraits(Pretty); 208 PolynomialTraits(Terse); 209 PolynomialTraits(GAP); 210 ~PolynomialTraits(); 211 }; 212 213 struct HeckeTraits { 214 String prefix; 215 String postfix; 216 String evenSeparator; 217 String oddSeparator; 218 String monomialPrefix; 219 String monomialPostfix; 220 String monomialSeparator; 221 String muMark; 222 String hyphens; 223 Ulong lineSize; 224 Ulong indent; 225 Ulong evenWidth; 226 Ulong oddWidth; 227 char padChar; 228 bool doShift; 229 bool reversePrint; 230 bool twoSided; 231 // constructors and destructors newHeckeTraits232 void* operator new(size_t size) {return arena().alloc(size);} deleteHeckeTraits233 void operator delete(void* ptr) 234 {return arena().free(ptr,sizeof(HeckeTraits));} 235 HeckeTraits(const Interface& I, Pretty); 236 HeckeTraits(const Interface& I, Terse); 237 HeckeTraits(const Interface& I, GAP); 238 virtual ~HeckeTraits(); 239 }; 240 241 struct AddHeckeTraits:public HeckeTraits { // Hecke traits for additive output 242 GroupEltInterface* eltTraits; 243 // constructors and destructors newAddHeckeTraits244 void* operator new(size_t size) {return arena().alloc(size);} deleteAddHeckeTraits245 void operator delete(void* ptr) 246 {return arena().free(ptr,sizeof(AddHeckeTraits));} 247 AddHeckeTraits(const Interface& I, Pretty); 248 AddHeckeTraits(const Interface& I, Terse); 249 AddHeckeTraits(const Interface& I, GAP); 250 ~AddHeckeTraits(); 251 }; 252 253 struct PartitionTraits { 254 String prefix; 255 String postfix; 256 String separator; 257 String classPrefix; 258 String classPostfix; 259 String classSeparator; 260 String classNumberPrefix; 261 String classNumberPostfix; 262 bool printClassNumber; 263 // constructors and destructors newPartitionTraits264 void* operator new(size_t size) {return arena().alloc(size);} deletePartitionTraits265 void operator delete(void* ptr) 266 {return arena().free(ptr,sizeof(PartitionTraits));} 267 PartitionTraits(Pretty); 268 PartitionTraits(Terse); 269 PartitionTraits(GAP); 270 ~PartitionTraits(); 271 }; 272 273 struct PosetTraits { 274 String prefix; 275 String postfix; 276 String separator; 277 String edgePrefix; 278 String edgePostfix; 279 String edgeSeparator; 280 String nodePrefix; 281 String nodePostfix; 282 Ulong nodeShift; 283 bool printNode; 284 // constructors and destructors newPosetTraits285 void* operator new(size_t size) {return arena().alloc(size);} deletePosetTraits286 void operator delete(void* ptr) 287 {return arena().free(ptr,sizeof(PosetTraits));} 288 PosetTraits(Pretty); 289 PosetTraits(Terse); 290 PosetTraits(GAP); 291 ~PosetTraits(); 292 }; 293 294 struct WgraphTraits { 295 String prefix; 296 String postfix; 297 String separator; 298 String edgeListPrefix; 299 String edgeListPostfix; 300 String edgeListSeparator; 301 String edgePrefix; 302 String edgePostfix; 303 String edgeSeparator; 304 String nodePrefix; 305 String nodePostfix; 306 String nodeSeparator; 307 String nodeNumberPrefix; 308 String nodeNumberPostfix; 309 Ulong nodeShift; 310 int padSize; 311 bool hasPadding; 312 bool printNodeNumber; 313 // constructors and destructors newWgraphTraits314 void* operator new(size_t size) {return arena().alloc(size);} deleteWgraphTraits315 void operator delete(void* ptr) 316 {return arena().free(ptr,sizeof(WgraphTraits));} 317 WgraphTraits(Pretty); 318 WgraphTraits(Terse); 319 WgraphTraits(GAP); 320 ~WgraphTraits(); 321 }; 322 323 struct OutputTraits { 324 // strings 325 String versionString; 326 String typeString; 327 // header file names 328 String header[numHeaders]; 329 String prefix[numHeaders]; 330 String postfix[numHeaders]; 331 bool hasHeader[numHeaders]; 332 // prettyfying strings for printouts 333 String closureSeparator1; 334 String closureSeparator2; 335 String closureSeparator3; 336 String closureSeparator4; 337 String closureSeparator5; 338 String closureSeparator6; 339 String eltList; 340 String singularLocus; 341 String singularStratification; 342 String emptySingularLocus; 343 String emptySingularStratification; 344 // list formatting 345 String bettiPrefix; 346 String bettiPostfix; 347 String bettiSeparator; 348 String bettiRankPrefix; 349 String bettiRankPostfix; 350 String cellNumberPrefix; 351 String cellNumberPostfix; 352 String closureSizePrefix; 353 String closureSizePostfix; 354 String coatomPrefix; 355 String coatomPostfix; 356 String coatomSeparator; 357 String compCountPrefix; 358 String compCountPostfix; 359 String dufloPrefix; 360 String dufloPostfix; 361 String dufloSeparator; 362 String dufloListPrefix; 363 String dufloListPostfix; 364 String dufloListSeparator; 365 String dufloNumberPrefix; 366 String dufloNumberPostfix; 367 String eltNumberPrefix; 368 String eltNumberPostfix; 369 String eltListPrefix; 370 String eltListPostfix; 371 String eltListSeparator; 372 String eltPrefix; 373 String eltPostfix; 374 String eltDataPrefix; 375 String eltDataPostfix; 376 String graphListPrefix; 377 String graphListPostfix; 378 String graphListSeparator; 379 String lDescentPrefix; 380 String lDescentPostfix; 381 String rDescentPrefix; 382 String rDescentPostfix; 383 String lengthPrefix; 384 String lengthPostfix; 385 String closeString; 386 String bettiHyphens; 387 Ulong lineSize; 388 // traits for the output of a polynomial 389 PolynomialTraits polTraits; 390 // traits for the output of a Hecke element 391 HeckeTraits heckeTraits; 392 AddHeckeTraits addHeckeTraits; 393 // traits for the output of a partition 394 PartitionTraits partitionTraits; 395 // traits for the output of a W-graph 396 WgraphTraits wgraphTraits; 397 // traits for the output of a poset 398 PosetTraits posetTraits; 399 // flags 400 bool printBettiRank; 401 bool printCellNumber; 402 bool printClosureSize; 403 bool printCoatoms; 404 bool printCompCount; 405 bool printDufloNumber; 406 bool printEltDescents; 407 bool printElt; 408 bool printEltData; 409 bool printEltNumber; 410 bool printLength; 411 bool printType; 412 bool printVersion; 413 bool hasBettiPadding; 414 // constructors and destructors newOutputTraits415 void* operator new(size_t size) {return arena().alloc(size);} newOutputTraits416 void* operator new(size_t size, void* ptr) {return ptr;} deleteOutputTraits417 void operator delete(void* ptr) 418 {return arena().free(ptr,sizeof(OutputTraits));} deleteOutputTraits419 void operator delete(void* p1, void* p2) {}; 420 OutputTraits(const CoxGraph& G, const Interface& I, Pretty); 421 OutputTraits(const CoxGraph& G, const Interface& I, Terse); 422 OutputTraits(const CoxGraph& G, const Interface& I, GAP); 423 ~OutputTraits(); 424 // manipulators 425 void setBasisTraits(HeckeTraits& hTraits); 426 void setDefaultTraits(HeckeTraits& hTraits); 427 }; 428 429 } 430 431 /******** inline definitions *************************************************/ 432 433 #include "files.hpp" 434 435 #endif 436