Orbiter 2022
Combinatorial Objects
poset_classification_draw.cpp
Go to the documentation of this file.
1// poset_classification_draw.cpp
2//
3// Anton Betten
4// moved out of poset_classification.cpp November 14, 2007
5
6#include "foundations/foundations.h"
7#include "discreta/discreta.h"
8#include "group_actions/group_actions.h"
9#include "classification/classification.h"
10#include "math.h"
11
12#define MAX_NODES_FOR_TREEFILE 25000
13//#define MAX_NODES_FOR_TREEFILE 6500
14
15using namespace std;
16
17namespace orbiter {
18namespace layer4_classification {
19namespace poset_classification {
20
21
22static void print_table1_top(ofstream &fp);
23static void print_table1_bottom(ofstream &fp);
24static void print_table_top(ofstream &fp, int f_permutation_degree_is_small);
25static void print_table_bottom(ofstream &fp);
26static void print_set_special(ofstream &fp, long int *set, int sz);
27
28void poset_classification::draw_poset_fname_base_aux_poset(
29 std::string &fname, int depth)
30{
31 char str[1000];
32
33 fname.assign(problem_label_with_path);
34 sprintf(str, "_aux_poset_lvl_%d", depth);
35 fname.append(str);
36}
37
38void poset_classification::draw_poset_fname_base_poset_lvl(
39 std::string &fname, int depth)
40{
41 char str[1000];
42
43 fname.assign(problem_label_with_path);
44 sprintf(str, "_poset_lvl_%d", depth);
45 fname.append(str);
46}
47
48void poset_classification::draw_poset_fname_base_tree_lvl(
49 std::string &fname, int depth)
50{
51 char str[1000];
52
53 fname.assign(problem_label_with_path);
54 sprintf(str, "_tree_lvl_%d", depth);
55 fname.append(str);
56}
57
58void poset_classification::draw_poset_fname_base_poset_detailed_lvl(
59 std::string &fname, int depth)
60{
61 char str[1000];
62
63 fname.assign(problem_label_with_path);
64 sprintf(str, "_poset_detailed_lvl_%d", depth);
65 fname.append(str);
66}
67
68void poset_classification::draw_poset_fname_aux_poset(
69 std::string &fname, int depth)
70{
71 draw_poset_fname_base_aux_poset(fname, depth);
72 fname.append(".layered_graph");
73}
74
75void poset_classification::draw_poset_fname_poset(
76 std::string &fname, int depth)
77{
78 draw_poset_fname_base_poset_lvl(fname, depth);
79 fname.append(".layered_graph");
80}
81
82void poset_classification::draw_poset_fname_tree(
83 std::string &fname, int depth)
84{
85 draw_poset_fname_base_tree_lvl(fname, depth);
86 fname.append(".layered_graph");
87}
88
89void poset_classification::draw_poset_fname_poset_detailed(
90 std::string &fname, int depth)
91{
92 draw_poset_fname_base_poset_detailed_lvl(fname, depth);
93 fname.append(".layered_graph");
94}
95
96
97void poset_classification::write_treefile(
98 std::string &fname_base, int lvl,
99 graphics::layered_graph_draw_options *draw_options,
100 int verbose_level)
101{
102 int f_v = (verbose_level >= 1);
103
104 if (f_v) {
105 cout << "poset_classification::write_treefile "
106 "verbose_level=" << verbose_level << endl;
107 }
108 if (write_treefile(fname_base, lvl, verbose_level)) {
109#if 0
110 if (f_v) {
111 cout << "poset_classification::write_treefile "
112 "before draw_tree" << endl;
113 }
114 draw_tree(fname_base, lvl, xmax, ymax, rad, f_embedded,
115 verbose_level);
116#endif
117 }
118 if (f_v) {
119 cout << "poset_classification::write_treefile done" << endl;
120 }
121}
122
123int poset_classification::write_treefile(std::string &fname_base,
124 int lvl, int verbose_level)
125{
126 int f_v = (verbose_level >= 1);
127 int f_vv = (verbose_level >= 2);
128 char str[1000];
129 string fname1;
130 int i, level;
131 orbiter_kernel_system::file_io Fio;
132
133 if (f_v) {
134 cout << "poset_classification::write_treefile" << endl;
135 }
136 fname1.assign(fname_base);
137 sprintf(str, "_%d.tree", lvl);
138 fname1.append(str);
139
140 if (Poo->first_node_at_level(lvl + 1) < MAX_NODES_FOR_TREEFILE) {
141 {
142 if (f_vv) {
143 cout << "poset_classification::write_treefile "
144 "writing treefile " << fname1 << endl;
145 }
146 ofstream f(fname1);
147
148 f << "# " << lvl << endl;
149
150 if (f_base_case) {
151 level = 0; // starter_size;
152 }
153 else {
154 level = 0;
155 }
156 for (i = Poo->first_node_at_level(level);
157 i < Poo->first_node_at_level(level + 1); i++) {
158 if (f_vv) {
159 cout << "poset_classification::write_treefile "
160 "node " << i << ":" << endl;
161 }
162 Poo->log_nodes_for_treefile(level, i, f,
163 TRUE /* f_recurse */, verbose_level);
164 }
165
166 f << "-1 " << Poo->first_node_at_level(lvl + 1) << endl;
167 }
168 if (f_vv) {
169 cout << "written file " << fname1
170 << " of size " << Fio.file_size(fname1) << endl;
171 }
172 if (f_v) {
173 cout << "poset_classification::write_treefile done" << endl;
174 }
175 return TRUE;
176 }
177 else {
178 cout << "poset_classification::write_treefile too many nodes, "
179 "you may increase MAX_NODES_FOR_TREEFILE if you wish" << endl;
180 cout << "MAX_NODES_FOR_TREEFILE=" << MAX_NODES_FOR_TREEFILE << endl;
181 cout << "first_poset_orbit_node_at_level[lvl + 1]="
182 << Poo->first_node_at_level(lvl + 1) << endl;
183 cout << "lvl=" << lvl << endl;
184 return FALSE;
185 }
186}
187
188void poset_classification::draw_tree(
189 std::string &fname_base, int lvl,
190 graphics::tree_draw_options *Tree_draw_options,
191 graphics::layered_graph_draw_options *Draw_options,
192 int xmax, int ymax, int rad, int f_embedded,
193 int f_sideways, int verbose_level)
194{
195 int f_v = (verbose_level >= 1);
196 int f_vv = (verbose_level >= 2);
197 string fname;
198 string fname1;
199 char str[1000];
200 graphics::tree T;
201 int idx = 0;
202 int nb_nodes, i;
203 int *coord_xyw;
204 int *perm;
205 int *perm_inv;
206 int f_draw_points = TRUE;
207 int f_draw_extension_points = FALSE;
208 int f_draw_aut_group_order = FALSE;
209 orbiter_kernel_system::file_io Fio;
210
211 if (f_v) {
212 cout << "poset_classification::draw_tree" << endl;
213 }
214 fname.assign(fname_base);
215 sprintf(str, "_%d", lvl);
216 fname.assign(fname_base);
217
218 fname1.assign(fname_base);
219 sprintf(str, "_%d.tree", lvl);
220 fname1.assign(fname_base);
221
222
223 if (Fio.file_size(fname1)) {
224 if (f_vv) {
225 cout << "reading treefile" << endl;
226 }
227 Tree_draw_options->f_file = TRUE;
228 Tree_draw_options->file_name.assign(fname1);
229
230 T.init(Tree_draw_options, xmax, ymax, verbose_level - 1);
231
232 nb_nodes = T.nb_nodes;
233 if (f_vv) {
234 cout << "poset_classification::draw_tree read treefile "
235 << fname1 << " with " << nb_nodes
236 << " nodes" << endl;
237 cout << "poset_classification::draw_tree "
238 "first_poset_orbit_node_at_level"
239 "level[lvl + 1] "
240 << Poo->first_node_at_level(lvl + 1)
241 << " nodes" << endl;
242 }
243 if (nb_nodes != Poo->first_node_at_level(lvl + 1)) {
244 cout << "poset_classification::draw_tree nb_nodes != "
245 "first_poset_orbit_node_at_level"
246 "[lvl + 1]" << endl;
247 cout << "nb_nodes=" << nb_nodes << endl;
248 cout << "first_poset_orbit_node_at_level[lvl + 1]="
249 << Poo->first_node_at_level(lvl + 1) << endl;
250 exit(1);
251 }
252 if (nb_nodes > 100) {
253 f_draw_points = FALSE;
254 f_draw_aut_group_order = FALSE;
255 }
256
257 coord_xyw = NEW_int(3 * nb_nodes);
258
259 if (f_vv) {
260 cout << "poset_classification::draw_tree "
261 "calling get_coordinates" << endl;
262 }
263 T.root->get_coordinates_and_width(idx, coord_xyw);
264
265#if 0
266 for (i = 0; i < nb_nodes; i++) {
267 coord_xyw[i * 3 + 2] = (int)sqrt((double)coord_xyw[i * 3 + 2]);
268 }
269#endif
270
271 if (FALSE) {
272 cout << "poset_classification::draw_tree coord_xyw:" << endl;
273 for (i = 0; i < nb_nodes; i++) {
274 cout << i << " : ("
275 << coord_xyw[i * 3 + 0] << ","
276 << coord_xyw[i * 3 + 1] << ","
277 << coord_xyw[i * 3 + 2] << ")" << endl;
278 }
279 }
280
281 if (f_vv) {
282 cout << "poset_classification::draw_tree calling "
283 "poset_orbit_node_depth_"
284 "breadth_perm_and_inverse" << endl;
285 }
286 Poo->poset_orbit_node_depth_breadth_perm_and_inverse(lvl /* max_depth */,
287 perm, perm_inv, verbose_level);
288 if (FALSE) {
289 cout << "poset_classification::draw_tree depth_breadth_perm_"
290 "and_inverse:" << endl;
291 for (i = 0; i < nb_nodes; i++) {
292 cout << i << " : ("
293 << perm[i] << ","
294 << perm_inv[i] << ")" << endl;
295 }
296 }
297
298 if (f_vv) {
299 cout << "poset_classification::draw_tree "
300 "before draw_tree_low_level" << endl;
301 }
302 draw_tree_low_level(fname, Tree_draw_options, Draw_options,
303 nb_nodes,
304 coord_xyw, perm_inv, perm,
305 f_draw_points, f_draw_extension_points,
306 f_draw_aut_group_order,
307 xmax, ymax, rad, f_embedded, f_sideways,
308 0 /*verbose_level - 2*/);
309
310 FREE_int(coord_xyw);
311 FREE_int(perm);
312 FREE_int(perm_inv);
313 }
314 else {
315 cout << "poset_classification::draw_tree the file " << fname1
316 << " does not exist, cannot draw the tree" << endl;
317 }
318}
319
320void poset_classification::draw_tree_low_level(
321 std::string &fname,
322 graphics::tree_draw_options *Tree_draw_options,
323 graphics::layered_graph_draw_options *Draw_options,
324 int nb_nodes,
325 int *coord_xyw, int *perm, int *perm_inv,
326 int f_draw_points, int f_draw_extension_points,
327 int f_draw_aut_group_order,
328 int xmax, int ymax, int rad, int f_embedded,
329 int f_sideways,
330 int verbose_level)
331{
332 int f_v = (verbose_level >= 1);
333 int factor_1000 = 1000;
334 string fname_full;
335 orbiter_kernel_system::file_io Fio;
336
337 if (xmax == -1)
338 xmax = 2000;
339 if (ymax == -1)
340 ymax = 3000;
341 if (ymax == 0)
342 ymax = 3000;
343
344 fname_full.assign(fname);
345 fname_full.append(".mp");
346
347 if (f_v) {
348 cout << "poset_classification::draw_tree_low_level "
349 "xmax = " << xmax << " ymax = " << ymax
350 << " fname=" << fname_full << endl;
351 cout << "verbose_level=" << verbose_level << endl;
352 }
353 {
354
355#if 0
356 mp_graphics G(fname_full, x_min, y_min, x_max, y_max);
357
358 G.out_xmin() = 0;
359 G.out_ymin() = 0;
360 G.out_xmax() = xmax;
361 G.out_ymax() = ymax;
362 //cout << "xmax/ymax = " << xmax << " / " << ymax << endl;
363#endif
364 graphics::mp_graphics G;
365
366 G.init(fname, Draw_options, verbose_level - 1);
367#if 0
368 G.setup(fname,
369 x_min, y_min, x_max, y_max, xmax, ymax,
370 f_embedded, f_sideways, scale, line_width,
371 verbose_level - 1);
372 //G.frame(0.05);
373#endif
374
375 G.header();
376 G.begin_figure(factor_1000);
377
378 draw_tree_low_level1(G,
379 nb_nodes, coord_xyw, perm, perm_inv,
380 f_draw_points, f_draw_extension_points,
381 f_draw_aut_group_order, rad, 0 /*verbose_level - 1*/);
382
383
384 //G.draw_boxes_final();
385 //G.end_figure();
386 //G.footer();
387
388 G.finish(cout, verbose_level);
389 }
390 if (f_v) {
391 cout << "poset_classification::draw_tree_low_level "
392 "written file " << fname_full
393 << " of size " << Fio.file_size(fname_full) << endl;
394 }
395
396}
397
398void poset_classification::draw_tree_low_level1(
399 graphics::mp_graphics &G,
400 int nb_nodes,
401 int *coords, int *perm, int *perm_inv,
402 int f_draw_points, int f_draw_extension_points,
403 int f_draw_aut_group_order,
404 int radius, int verbose_level)
405{
406 int f_v = (verbose_level >= 1);
407 int f_vv = (verbose_level >= 2);
408 int f_vvv = (verbose_level >= 3);
409 int *Px, *Py, *Width;
410 int *Qx, *Qy;
411 int x, y;
412 int i, j;
413 int y_offset2 = 200;
414 //int y_offset3 = -590;
415 //int y_offset4 = -350;
416 //int delta_x = 1000;
417 //int delta_y = 1000;
418 int nb_e, Nb_e, pt, dx, dx0, /*Dx, Dx0,*/ nxt, hdl, depth, hdl2;
419 long int set0[100];
420 long int set1[100];
421 char str[1000];
422 int rad = 200 >> 3;
423 data_structures::sorting Sorting;
424
425 Px = NEW_int(nb_nodes);
426 Py = NEW_int(nb_nodes);
427 Width = NEW_int(nb_nodes);
428 Qx = NEW_int(100);
429 Qy = NEW_int(100);
430
431 if (f_v) {
432 cout << "draw_tree_low_level1" << endl;
433 cout << "nb_nodes = " << nb_nodes << endl;
434 cout << "rad = " << rad << endl;
435 cout << "verbose_level = " << verbose_level << endl;
436 }
437 for (i = 0; i < nb_nodes; i++) {
438 Px[i] = coords[i * 3 + 0];
439 Py[i] = coords[i * 3 + 1];
440 Width[i] = coords[i * 3 + 2];
441 }
442
443 for (i = 0; i < nb_nodes; i++) {
444 if (f_vv) {
445 cout << "draw_tree_low_level1: i=" << i << endl;
446 }
447 nb_e = Poo->node_get_nb_of_extensions(i);
448 if (f_vv) {
449 cout << "draw_tree_low_level1: nb_e=" << nb_e << endl;
450 }
451 if (nb_e) {
452 dx = MINIMUM(Width[i] / nb_e, 200);
453 dx0 = ((nb_e - 1) * dx) >> 1;
454 }
455 else {
456 dx = 0;
457 dx0 = 0;
458 }
459 for (j = 0; j < nb_e; j++) {
460 Nb_e = Poo->node_get_nb_of_extensions(j);
461 if (f_vv) {
462 cout << "draw_tree_low_level1: i=" << i
463 << " j=" << j << " nb_e=" << nb_e <<
464 " Nb_e=" << Nb_e << endl;
465 cout << "root[i].get_E(j)->get_type()=" << Poo->get_node(i)->get_E(j)->get_type() << endl;
466 }
467
468#if 0
469 if (Nb_e) {
470 Dx = MINIMUM(Width[j] / Nb_e, 200);
471 //Dx0 = ((Nb_e - 1) * Dx) >> 1;
472 }
473 else {
474 Dx = 0;
475 //Dx0 = 0;
476 }
477#endif
478
479 if (Poo->get_node(i)->get_E(j)->get_type() == EXTENSION_TYPE_EXTENSION) {
480 // extension node
481 pt = Poo->get_node(i)->get_E(j)->get_pt();
482 nxt = Poo->get_node(i)->get_E(j)->get_data();
483 if (f_vv) {
484 cout << "extension node: pt=" << pt
485 << " nxt=" << nxt << endl;
486 }
487 if (nxt >= 0) {
488 Qx[0] = Px[perm[i]];
489 Qy[0] = Py[perm[i]];
490
491 Qx[1] = Px[perm[nxt]];
492 Qy[1] = Py[perm[nxt]];
493 if (FALSE) {
494 cout << "Qx[0]=" << Qx[0] << " Qy[0]=" << Qy[0] << endl;
495 cout << "Qx[1]=" << Qx[1] << " Qy[1]=" << Qy[1] << endl;
496 }
497
498 if (f_draw_points) {
499 Qx[0] -= dx0;
500 Qx[0] += j * dx;
501 Qy[0] -= y_offset2;
502
503 Qx[1] += 0;
504 Qy[1] += y_offset2;
505 }
506 if (FALSE) {
507 cout << "Qx[0]=" << Qx[0] << " Qy[0]=" << Qy[0] << endl;
508 cout << "Qx[1]=" << Qx[1] << " Qy[1]=" << Qy[1] << endl;
509 }
510
511 G.polygon2(Qx, Qy, 0, 1);
512 if (FALSE) {
513 cout << "after G.polygon2" << endl;
514 }
515 }
516 }
517 else if (Poo->get_node(i)->get_E(j)->get_type() == EXTENSION_TYPE_FUSION) {
518 // fusion node
519 if (f_vv) {
520 cout << "fusion node" << endl;
521 }
522 if (TRUE /*root[i].E[j].get_pt() > root[i].get_pt()*/) {
523 pt = Poo->get_node(i)->get_E(j)->get_pt();
524 hdl = Poo->get_node(i)->get_E(j)->get_data();
525 depth = Poo->get_node(i)->depth_of_node(this);
526 Poo->get_node(i)->store_set_to(this, depth - 1, set0);
527 set0[depth] = pt;
528 if (f_vvv) {
529 cout << "fusion node i=" << i
530 << " j=" << j << " set = ";
531 Lint_vec_print(cout, set0, depth + 1);
532 cout << endl;
533 }
534
535 Poset->A2->element_retrieve(hdl, Elt1, FALSE);
536
537 Poset->A2->map_a_set(set0, set1, depth + 1, Elt1, 0);
538
539 Sorting.lint_vec_heapsort(set1, depth + 1);
540
541 if (f_vvv) {
542 cout << "mapping the set to = ";
543 Lint_vec_print(cout, set1, depth + 1);
544 cout << endl;
545 }
546
547 hdl2 = find_poset_orbit_node_for_set(depth + 1, set1,
548 FALSE /* f_tolerant */,
549 0 /* verbose_level */);
550 if (hdl2 >= 0) {
551 if (f_vvv) {
552 cout << "which is node " << hdl2 << endl;
553 }
554
555 Qx[0] = Px[perm[i]];
556 Qy[0] = Py[perm[i]];
557 Qx[1] = Px[perm[i]] - dx0 + j * dx;
558 Qy[1] = Py[perm[i]] - y_offset2 - 30;
559
560 Qx[2] = Px[perm[hdl2]];
561 Qy[2] = Py[perm[hdl2]] + y_offset2 + 30;
562 Qx[3] = Px[perm[hdl2]];
563 Qy[3] = Py[perm[hdl2]];
564
565 if (f_draw_points) {
566 Qx[0] -= dx0;
567 Qx[0] += j * dx;
568 Qy[0] -= y_offset2;
569 Qx[3] += 0;
570 Qy[3] += y_offset2;
571 }
572
573 G.sl_udsty(100);
574 if (f_draw_points) {
575 G.bezier2(Qx, Qy, 1, 2);
576 //G.bezier4(Qx, Qy, 0, 1, 2, 3);
577 //G.polygon4(Qx, Qy, 0, 1, 2, 3);
578 }
579 G.sl_udsty(0);
580 } // if (hdl2 >= 0)
581 } // if (root[i].E[j].get_pt() > root[i].get_pt())
582 } // if fusion node
583 } // next j
584 } // next i
585
586#if 0
587 for (i = 0; i < nb_nodes; i++) {
588 Qx[0] = Px[perm[i]];
589 Qy[0] = Py[perm[i]];
590 Qx[1] = Px[perm[i]];
591 Qy[1] = Py[perm[i]];
592 Qx[2] = Px[perm[i]];
593 Qy[2] = Py[perm[i]];
594 Qx[3] = Px[perm[i]];
595 Qy[3] = Py[perm[i]];
596 if (i >= first_poset_orbit_node_node_at_level[sz]) {
597 Qx[0] -= 15 * delta_x;
598 Qx[1] += 15 * delta_x;
599 Qx[2] += 15 * delta_x;
600 Qx[3] -= 15 * delta_x;
601 Qy[0] -= 12 * delta_y;
602 Qy[1] -= 12 * delta_y;
603 Qy[2] -= 20 * delta_y;
604 Qy[3] -= 20 * delta_y;
605 }
606 else {
607 Qx[0] -= 15 * delta_x;
608 Qx[1] += 15 * delta_x;
609 Qx[2] += 15 * delta_x;
610 Qx[3] -= 15 * delta_x;
611 Qy[0] -= 12 * delta_y;
612 Qy[1] -= 12 * delta_y;
613 Qy[2] -= 25 * delta_y;
614 Qy[3] -= 25 * delta_y;
615 }
616 G.polygon5(Qx, Qy, 0, 1, 2, 3, 0);
617 }
618#endif
619
620 if (f_v) {
621 cout << "now drawing node labels" << endl;
622 }
623
624 G.sf_interior(100 /* fill_interior */);
625 G.sf_color(1 /* fill_color */);
626
627 for (i = 0; i < nb_nodes; i++) {
628 if (i == 0) {
629 continue;
630 }
631 pt = Poo->get_node(perm_inv[i])->get_pt();
632 snprintf(str, 1000, "%d", pt);
633 //G.aligned_text(Px, Py, i, "", str);
634 if (f_draw_points) {
635 G.circle_text(Px[i], Py[i], rad, str);
636 }
637 else {
638 G.circle(Px[i], Py[i], rad);
639 }
640 }
641
642#if 0
643 cout << "writing text" << endl;
644 for (i = 0; i < nb_nodes; i++) {
645 cout << perm_inv[i] << " ";
646 }
647 cout << endl;
648#endif
649
650#if 0
651 if (f_draw_aut_group_order) {
652 //longinteger_domain D;
653 longinteger_object go;
654 int x_offset = 0;
655 int y_offset = -200;
656 char str2[1000];
657
658 for (i = 0; i < nb_nodes; i++) {
659 if (root[i].addl == NULL)
660 continue;
661 root[i].addl->G->group_order(go);
662 go.print_to_string(str);
663 snprintf(str2, 1000, "$%s$", str);
664 G.aligned_text_with_offset(Px, Py, perm[i],
665 x_offset, y_offset, "", str2);
666 }
667 }
668#endif
669
670
671 if (f_draw_points) {
672 if (f_v) {
673 cout << "now drawing connections" << endl;
674 }
675 for (i = 0; i < nb_nodes; i++) {
676 nb_e = Poo->node_get_nb_of_extensions(i);
677 if (nb_e) {
678 dx = MINIMUM(Width[i] / nb_e, 200);
679 dx0 = ((nb_e - 1) * dx) >> 1;
680 }
681 else {
682 dx = 0;
683 dx0 = 0;
684 }
685
686 x = Px[perm[i]];
687 y = Py[perm[i]] + y_offset2;
688 G.circle(x, y, rad);
689
690 for (j = 0; j < nb_e; j++) {
691 pt = Poo->get_node(i)->get_E(j)->get_pt();
692 snprintf(str, 1000, "%d", pt);
693 x = Px[perm[i]] - dx0 + j * dx;
694 y = Py[perm[i]] - y_offset2;
695 if (f_draw_extension_points) {
696 G.circle_text(x, y, rad, str);
697 //G.aligned_text_with_offset(Px, Py,
698 // perm[i], x_offset, y_offset, "", "$48$");
699 }
700 else {
701 G.circle(x, y, rad);
702 }
703 }
704 }
705 }
706
707 FREE_int(Px);
708 FREE_int(Py);
709 FREE_int(Width);
710 FREE_int(Qx);
711 FREE_int(Qy);
712}
713
714void poset_classification::draw_poset_full(std::string &fname_base,
715 int depth, int data,
716 graphics::layered_graph_draw_options *LG_Draw_options,
717 double x_stretch,
718 int verbose_level)
719{
720 int f_v = (verbose_level >= 1);
721 graph_theory::layered_graph *LG;
722
723 if (f_v) {
724 cout << "poset_classification::draw_poset_full "
725 "fname_base=" << fname_base << " data=" << data << endl;
726 }
727 make_full_poset_graph(depth, LG, data, x_stretch, verbose_level);
728 if (f_v) {
729 cout << "poset_classification::draw_poset_full "
730 "after make_full_poset_graph" << endl;
731 }
732
733 char str[1000];
734 string fname1;
735 string fname2;
736
737 sprintf(str, "_poset_full_lvl_%d.layered_graph", depth);
738
739 fname1.assign(fname_base);
740 fname1.append(str);
741
742 LG->write_file(fname1, 0 /*verbose_level*/);
743 if (f_v) {
744 cout << "poset_classification::draw_poset_full "
745 "after LG->write_file" << endl;
746 }
747
748 sprintf(str, "_poset_full_lvl_%d", depth);
749
750 fname2.assign(fname_base);
751 fname2.append(str);
752
753 LG->draw_with_options(fname2, LG_Draw_options, 0 /* verbose_level */);
754
755 if (f_v) {
756 cout << "poset_classification::draw_poset_full "
757 "after LG->draw" << endl;
758 }
759
760 FREE_OBJECT(LG);
761
762 if (f_v) {
763 cout << "poset_classification::draw_poset_full done" << endl;
764 }
765}
766
767void poset_classification::draw_poset(
768 std::string &fname_base,
769 int depth, int data,
770 graphics::layered_graph_draw_options *LG_Draw_options,
771 int verbose_level)
772{
773 int f_v = (verbose_level >= 1);
774 graph_theory::layered_graph *LG1;
775 graph_theory::layered_graph *LG2;
776 graph_theory::layered_graph *LG3;
777 graph_theory::layered_graph *LG4;
778
779 if (f_v) {
780 cout << "poset_classification::draw_poset "
781 "data=" << data << " fname_base=" << fname_base << endl;
782 }
783
784
785 if (f_v) {
786 cout << "poset_classification::draw_poset "
787 "before make_auxiliary_graph" << endl;
788 }
789 make_auxiliary_graph(depth, LG1, data,
790 0 /*verbose_level - 1*/);
791 if (f_v) {
792 cout << "poset_classification::draw_poset "
793 "before make_graph" << endl;
794 }
795 make_graph(depth, LG2, data, FALSE /* f_tree */,
796 0 /*verbose_level - 1*/);
797 if (f_v) {
798 cout << "poset_classification::draw_poset "
799 "before make_graph" << endl;
800 }
801 make_graph(depth, LG3, data, TRUE /* f_tree */,
802 0 /*verbose_level - 1*/);
803 if (f_v) {
804 cout << "poset_classification::draw_poset "
805 "before make_poset_graph_detailed" << endl;
806 }
807 make_poset_graph_detailed(LG4, data, depth,
808 0 /*verbose_level - 1*/);
809 if (f_v) {
810 cout << "poset_classification::draw_poset "
811 "after make_poset_graph_detailed" << endl;
812 }
813
814 string fname_base1;
815 string fname_base2;
816 string fname_base3;
817 string fname_base4;
818 string fname1;
819 string fname2;
820 string fname3;
821 string fname4;
822
823 draw_poset_fname_base_aux_poset(fname_base1, depth);
824 draw_poset_fname_base_poset_lvl(fname_base2, depth);
825 draw_poset_fname_base_tree_lvl(fname_base3, depth);
826 draw_poset_fname_base_poset_detailed_lvl(fname_base4, depth);
827
828 fname1.assign(fname_base1);
829 fname2.assign(fname_base2);
830 fname3.assign(fname_base3);
831 fname4.assign(fname_base4);
832
833 fname1.append(".layered_graph");
834 fname2.append(".layered_graph");
835 fname3.append(".layered_graph");
836 fname4.append(".layered_graph");
837
838 if (f_v) {
839 cout << "poset_classification::draw_poset "
840 "writing file " << fname1 << endl;
841 }
842
843
844
845 LG1->write_file(fname1, 0 /*verbose_level*/);
846 LG1->draw_with_options(fname_base1, LG_Draw_options,
847 0 /* verbose_level */);
848
849 if (f_v) {
850 cout << "poset_classification::draw_poset "
851 "writing file " << fname2 << endl;
852 }
853
854 LG2->write_file(fname2, 0 /*verbose_level*/);
855 LG2->draw_with_options(fname_base2, LG_Draw_options,
856 0 /* verbose_level */);
857
858 if (f_v) {
859 cout << "poset_classification::draw_poset "
860 "writing file " << fname3 << endl;
861 }
862
863 LG3->write_file(fname3, 0 /*verbose_level*/);
864 LG3->draw_with_options(fname_base3, LG_Draw_options,
865 0 /* verbose_level */);
866
867 if (f_v) {
868 cout << "poset_classification::draw_poset "
869 "writing file " << fname4 << endl;
870 }
871
872 LG4->write_file(fname4, 0 /*verbose_level*/);
873 LG4->draw_with_options(fname_base4, LG_Draw_options,
874 0 /* verbose_level */);
875
876 FREE_OBJECT(LG1);
877 FREE_OBJECT(LG2);
878 FREE_OBJECT(LG3);
879 FREE_OBJECT(LG4);
880
881 if (f_v) {
882 cout << "poset_classification::draw_poset done" << endl;
883 }
884}
885
886void poset_classification::draw_level_graph(
887 std::string &fname_base,
888 int depth, int data, int level,
889 graphics::layered_graph_draw_options *LG_Draw_options,
890 int verbose_level)
891{
892 int f_v = (verbose_level >= 1);
893 graph_theory::layered_graph *LG;
894
895 if (f_v) {
896 cout << "poset_classification::draw_level_graph "
897 "data=" << data << endl;
898 }
899
900
901 make_level_graph(depth, LG, data, level, verbose_level - 1);
902
903
904 string fname_base1;
905 string fname;
906 char str[1000];
907
908 fname_base1.assign(fname_base);
909 sprintf(str, "_lvl_%d_bipartite_lvl_%d", depth, level);
910 fname_base1.append(str);
911
912 fname.assign(fname_base);
913 sprintf(str, "_lvl_%d_bipartite_lvl_%d.layered_graph", depth, level);
914 fname.append(str);
915
916 LG->write_file(fname, 0 /*verbose_level*/);
917
918
919 LG->draw_with_options(fname_base1, LG_Draw_options, 0 /* verbose_level */);
920
921 FREE_OBJECT(LG);
922
923 if (f_v) {
924 cout << "poset_classification::draw_level_graph done" << endl;
925 }
926}
927
928
929void poset_classification::make_flag_orbits_on_relations(
930 int depth, const char *fname_prefix, int verbose_level)
931{
932 int f_v = (verbose_level >= 1);
933 int f_vv = (verbose_level >= 2);
934 int f_v5 = (verbose_level >= 5);
935 int nb_layers;
936 int *Nb_elements;
937 int *Fst;
938 int *Nb_orbits;
939 int **Fst_element_per_orbit;
940 int **Orbit_len;
941 int i, j, lvl, po, po2, so, n1, n2, ol1, ol2, el1, el2, h;
942 long int *set;
943 long int *set1;
944 long int *set2;
945 int f_contained;
946 //longinteger_domain D;
947 data_structures::sorting Sorting;
948
949 if (f_v) {
950 cout << "poset_classification::make_flag_orbits_on_relations" << endl;
951 }
952 set = NEW_lint(depth + 1);
953 set1 = NEW_lint(depth + 1);
954 set2 = NEW_lint(depth + 1);
955 nb_layers = depth + 1;
956 Nb_elements = NEW_int(nb_layers);
957 Nb_orbits = NEW_int(nb_layers);
958 Fst = NEW_int(nb_layers + 1);
959 Fst_element_per_orbit = NEW_pint(nb_layers);
960 Orbit_len = NEW_pint(nb_layers);
961 Fst[0] = 0;
962 for (i = 0; i <= depth; i++) {
963 Nb_orbits[i] = nb_orbits_at_level(i);
964 Fst_element_per_orbit[i] = NEW_int(Nb_orbits[i] + 1);
965 Orbit_len[i] = NEW_int(Nb_orbits[i]);
966 Nb_elements[i] = 0;
967
968 Fst_element_per_orbit[i][0] = 0;
969 for (j = 0; j < Nb_orbits[i]; j++) {
970 Orbit_len[i][j] = orbit_length_as_int(j, i);
971 Nb_elements[i] += Orbit_len[i][j];
972 Fst_element_per_orbit[i][j + 1] =
973 Fst_element_per_orbit[i][j] + Orbit_len[i][j];
974 }
975 Fst[i + 1] = Fst[i] + Nb_elements[i];
976 }
977
978 for (lvl = 0; lvl <= depth; lvl++) {
979 string fname;
980 char str[1000];
981 orbiter_kernel_system::file_io Fio;
982
983 fname.assign(fname_prefix);
984 sprintf(str, "_depth_%d_orbit_lengths.csv", lvl);
985 fname.append(str);
986
987 Fio.int_vec_write_csv(Orbit_len[lvl], Nb_orbits[lvl],
988 fname, "Orbit_length");
989
990 cout << "poset_classification::make_flag_orbits_on_relations "
991 "Written file " << fname << " of size " << Fio.file_size(fname) << endl;
992 }
993
994 for (lvl = 0; lvl < depth; lvl++) {
995 if (f_vv) {
996 cout << "poset_classification::make_flag_orbits_on_relations "
997 "adding edges lvl=" << lvl << " / " << depth << endl;
998 }
999 //f = 0;
1000
1001 int *F;
1002 int flag_orbit_idx;
1003 string fname;
1004 char str[1000];
1005
1006 if (f_vv) {
1007 cout << "poset_classification::make_flag_orbits_on_relations allocating F" << endl;
1008 }
1009 F = NEW_int(Nb_elements[lvl] * Nb_elements[lvl + 1]);
1010 Int_vec_zero(F, Nb_elements[lvl] * Nb_elements[lvl + 1]);
1011
1012 fname.assign(fname_prefix);
1013 sprintf(str, "_depth_%d.csv", lvl);
1014 fname.append(str);
1015
1016 flag_orbit_idx = 1;
1017 for (po = 0; po < nb_orbits_at_level(lvl); po++) {
1018
1019 if (f_vv) {
1020 cout << "poset_classification::make_flag_orbits_on_relations "
1021 "adding edges lvl=" << lvl
1022 << " po=" << po << " / " << nb_orbits_at_level(lvl)
1023 << " Fst_element_per_orbit[lvl][po]="
1024 << Fst_element_per_orbit[lvl][po] << endl;
1025 }
1026
1027 ol1 = Orbit_len[lvl][po];
1028 //
1029 n1 = Poo->first_node_at_level(lvl) + po;
1030
1031
1032 int *Down_orbits;
1033 int nb_down_orbits;
1034
1035 Down_orbits = NEW_int(Poo->node_get_nb_of_extensions(n1));
1036 nb_down_orbits = 0;
1037
1038 for (so = 0; so < Poo->node_get_nb_of_extensions(n1); so++) {
1039
1040 if (f_vv) {
1041 cout << "poset_classification::make_flag_orbits_on_relations "
1042 "adding edges lvl=" << lvl
1043 << " po=" << po << " / " << nb_orbits_at_level(lvl)
1044 << " so=" << so << " / " << Poo->node_get_nb_of_extensions(n1)
1045 << endl;
1046 }
1047
1048
1049 extension *E = Poo->get_node(n1)->get_E(so);
1050 if (E->get_type() == EXTENSION_TYPE_EXTENSION) {
1051 //cout << "extension node" << endl;
1052 n2 = E->get_data();
1053
1054 Down_orbits[nb_down_orbits++] = n2;
1055 }
1056 else if (E->get_type() == EXTENSION_TYPE_FUSION) {
1057 //cout << "fusion node" << endl;
1058 // po = data1
1059 // so = data2
1060 int n0, so0;
1061 n0 = E->get_data1();
1062 so0 = E->get_data2();
1063 //cout << "fusion (" << n1 << "/" << so << ") "
1064 //"-> (" << n0 << "/" << so0 << ")" << endl;
1065 extension *E0;
1066 E0 = Poo->get_node(n0)->get_E(so0);
1067 if (E0->get_type() != EXTENSION_TYPE_EXTENSION) {
1068 cout << "warning: fusion node does not point "
1069 "to extension node" << endl;
1070 cout << "type = ";
1071 print_extension_type(cout, E0->get_type());
1072 cout << endl;
1073 exit(1);
1074 }
1075 n2 = E0->get_data();
1076 Down_orbits[nb_down_orbits++] = n2;
1077 }
1078
1079 } // next so
1080
1081
1082 if (f_vv) {
1083 cout << "poset_classification::make_flag_orbits_on_relations adding edges "
1084 "lvl=" << lvl
1085 << " po=" << po << " / " << nb_orbits_at_level(lvl)
1086 << " so=" << so << " / " << Poo->node_get_nb_of_extensions(n1)
1087 << " downorbits = ";
1088 Int_vec_print(cout, Down_orbits, nb_down_orbits);
1089 cout << endl;
1090 }
1091
1092 Sorting.int_vec_sort_and_remove_duplicates(Down_orbits, nb_down_orbits);
1093 if (f_vv) {
1094 cout << "poset_classification::make_flag_orbits_on_relations adding edges "
1095 "lvl=" << lvl << " po=" << po
1096 << " so=" << so << " unique downorbits = ";
1097 Int_vec_print(cout, Down_orbits, nb_down_orbits);
1098 cout << endl;
1099 }
1100
1101 for (h = 0; h < nb_down_orbits; h++, flag_orbit_idx++) {
1102 n2 = Down_orbits[h];
1103 po2 = n2 - Poo->first_node_at_level(lvl + 1);
1104 ol2 = Orbit_len[lvl + 1][po2];
1105 if (f_v5) {
1106 cout << "poset_classification::make_flag_orbits_on_relations "
1107 "adding edges lvl=" << lvl
1108 << " po=" << po << " / " << nb_orbits_at_level(lvl)
1109 << " so=" << so << " / " << Poo->node_get_nb_of_extensions(n1)
1110 << " downorbit = " << h << " / " << nb_down_orbits
1111 << " n1=" << n1 << " n2=" << n2
1112 << " po2=" << po2
1113 << " ol1=" << ol1 << " ol2=" << ol2
1114 << " Fst_element_per_orbit[lvl][po]="
1115 << Fst_element_per_orbit[lvl][po]
1116 << " Fst_element_per_orbit[lvl + 1][po2]="
1117 << Fst_element_per_orbit[lvl + 1][po2] << endl;
1118 }
1119 for (el1 = 0; el1 < ol1; el1++) {
1120 if (f_v5) {
1121 cout << "unrank " << lvl << ", " << po
1122 << ", " << el1 << endl;
1123 }
1124 orbit_element_unrank(lvl, po, el1, set1,
1125 0 /* verbose_level */);
1126 if (f_v5) {
1127 cout << "set1=";
1128 Lint_vec_print(cout, set1, lvl);
1129 cout << endl;
1130 }
1131
1132
1133 for (el2 = 0; el2 < ol2; el2++) {
1134 if (f_v5) {
1135 cout << "unrank " << lvl + 1 << ", "
1136 << po2 << ", " << el2 << endl;
1137 }
1138 orbit_element_unrank(lvl + 1, po2, el2, set2,
1139 0 /* verbose_level */);
1140 if (f_v5) {
1141 cout << "set2=";
1142 Lint_vec_print(cout, set2, lvl + 1);
1143 cout << endl;
1144 }
1145
1146 if (f_v5) {
1147 cout << "poset_classification::make_flag_orbits_on_relations "
1148 "adding edges lvl=" << lvl
1149 << " po=" << po << " so=" << so
1150 << " downorbit = " << h << " / "
1151 << nb_down_orbits << " n1=" << n1
1152 << " n2=" << n2 << " po2=" << po2
1153 << " ol1=" << ol1 << " ol2=" << ol2
1154 << " el1=" << el1 << " el2=" << el2
1155 << endl;
1156 cout << "set1=";
1157 Lint_vec_print(cout, set1, lvl);
1158 cout << endl;
1159 cout << "set2=";
1160 Lint_vec_print(cout, set2, lvl + 1);
1161 cout << endl;
1162 }
1163
1164
1165 Lint_vec_copy(set1, set, lvl);
1166
1167 //f_contained = int_vec_sort_and_test_if_contained(
1168 // set, lvl, set2, lvl + 1);
1169 f_contained = poset_structure_is_contained(
1170 set, lvl, set2, lvl + 1,
1171 0 /* verbose_level*/);
1172
1173
1174 if (f_contained) {
1175 if (f_v5) {
1176 cout << "is contained" << endl;
1177 }
1178
1179#if 0
1180 LG->add_edge(lvl,
1181 Fst_element_per_orbit[lvl][po] + el1,
1182 lvl + 1,
1183 Fst_element_per_orbit[lvl + 1][po2] + el2,
1184 0 /*verbose_level*/);
1185#else
1186 F[(Fst_element_per_orbit[lvl][po] + el1) * Nb_elements[lvl + 1] + Fst_element_per_orbit[lvl + 1][po2] + el2] = flag_orbit_idx;
1187#endif
1188 }
1189 else {
1190 if (f_v5) {
1191 cout << "is NOT contained" << endl;
1192 }
1193 }
1194
1195 } // next el2
1196 } // next el1
1197 } // next h
1198
1199
1200 FREE_int(Down_orbits);
1201
1202 } // po
1203
1204 orbiter_kernel_system::file_io Fio;
1205
1206 Fio.int_matrix_write_csv(fname,
1207 F, Nb_elements[lvl], Nb_elements[lvl + 1]);
1208 FREE_int(F);
1209
1210 cout << "poset_classification::make_flag_orbits_on_relations "
1211 "Written file " << fname << " of size "
1212 << Fio.file_size(fname) << endl;
1213
1214 } // lvl
1215
1216
1217
1218
1219
1220
1221 FREE_lint(set);
1222 FREE_lint(set1);
1223 FREE_lint(set2);
1224 FREE_int(Nb_elements);
1225 FREE_int(Nb_orbits);
1226 FREE_int(Fst);
1227 for (i = 0; i <= depth; i++) {
1228 FREE_int(Fst_element_per_orbit[i]);
1229 }
1230 FREE_pint(Fst_element_per_orbit);
1231 for (i = 0; i <= depth; i++) {
1232 FREE_int(Orbit_len[i]);
1233 }
1234 FREE_pint(Orbit_len);
1235 if (f_v) {
1236 cout << "poset_classification::make_flag_orbits_on_relations done" << endl;
1237 }
1238}
1239
1240
1241
1242void poset_classification::make_full_poset_graph(
1243 int depth, graph_theory::layered_graph *&LG,
1244 int data1, double x_stretch, int verbose_level)
1245// Draws the full poset: each element of each orbit is drawn.
1246// The orbits are indicated by grouping the elements closer together.
1247// Uses int_vec_sort_and_test_if_contained to test containment relation.
1248// This is only good for actions on sets, not for actions on subspaces
1249{
1250 int f_v = (verbose_level >= 1);
1251 int f_vv = (verbose_level >= 2);
1252 int nb_layers;
1253 int *Nb_elements;
1254 int *Fst;
1255 int *Nb_orbits;
1256 int **Fst_element_per_orbit;
1257 int **Orbit_len;
1258 int i, j, lvl, po, po2, so, n1, n2, ol1, ol2, el1, el2, h;
1259 long int *set;
1260 long int *set1;
1261 long int *set2;
1262 int f_contained;
1263 //longinteger_domain D;
1264 data_structures::sorting Sorting;
1265
1266 if (f_v) {
1267 cout << "poset_classification::make_full_poset_graph" << endl;
1268 }
1269 set = NEW_lint(depth + 1);
1270 set1 = NEW_lint(depth + 1);
1271 set2 = NEW_lint(depth + 1);
1272 nb_layers = depth + 1;
1273 Nb_elements = NEW_int(nb_layers);
1274 Nb_orbits = NEW_int(nb_layers);
1275 Fst = NEW_int(nb_layers + 1);
1276 Fst_element_per_orbit = NEW_pint(nb_layers);
1277 Orbit_len = NEW_pint(nb_layers);
1278 Fst[0] = 0;
1279 for (i = 0; i <= depth; i++) {
1280 Nb_orbits[i] = nb_orbits_at_level(i);
1281 Fst_element_per_orbit[i] = NEW_int(Nb_orbits[i] + 1);
1282 Orbit_len[i] = NEW_int(Nb_orbits[i]);
1283 Nb_elements[i] = 0;
1284
1285 Fst_element_per_orbit[i][0] = 0;
1286 for (j = 0; j < Nb_orbits[i]; j++) {
1287 Orbit_len[i][j] = orbit_length_as_int(j, i);
1288 Nb_elements[i] += Orbit_len[i][j];
1289 Fst_element_per_orbit[i][j + 1] =
1290 Fst_element_per_orbit[i][j] + Orbit_len[i][j];
1291 }
1292 Fst[i + 1] = Fst[i] + Nb_elements[i];
1293 }
1294 LG = NEW_OBJECT(graph_theory::layered_graph);
1295 LG->add_data1(data1, 0/*verbose_level*/);
1296
1297 if (f_v) {
1298 cout << "poset_classification::make_full_poset_graph "
1299 "before LG->init" << endl;
1300 cout << "nb_layers=" << nb_layers << endl;
1301 for (lvl = 0; lvl < depth; lvl++) {
1302 cout << "Nb_elements[" << lvl << "]=" << Nb_elements[lvl] << endl;
1303 }
1304 }
1305 string dummy;
1306 dummy.assign("");
1307 LG->init(nb_layers, Nb_elements, dummy, verbose_level);
1308
1309 if (f_v) {
1310 cout << "poset_classification::make_full_poset_graph "
1311 "after LG->init" << endl;
1312 }
1313 if (f_v) {
1314 cout << "poset_classification::make_full_poset_graph "
1315 "before LG->place_with_grouping" << endl;
1316 }
1317 LG->place_with_grouping(Orbit_len, Nb_orbits, x_stretch, verbose_level);
1318 //LG->place(verbose_level);
1319 if (f_v) {
1320 cout << "poset_classification::make_full_poset_graph "
1321 "after LG->place" << endl;
1322 }
1323
1324 for (lvl = 0; lvl < depth; lvl++) {
1325 if (f_vv) {
1326 cout << "poset_classification::make_full_poset_graph "
1327 "adding edges lvl=" << lvl << " / " << depth << endl;
1328 }
1329 //f = 0;
1330 for (po = 0; po < nb_orbits_at_level(lvl); po++) {
1331
1332 if (f_vv) {
1333 cout << "poset_classification::make_full_poset_graph "
1334 "adding edges lvl=" << lvl
1335 << " po=" << po << " / "
1336 << nb_orbits_at_level(lvl)
1337 << " Fst_element_per_orbit[lvl][po]="
1338 << Fst_element_per_orbit[lvl][po] << endl;
1339 }
1340
1341 ol1 = Orbit_len[lvl][po];
1342 //
1343 n1 = Poo->first_node_at_level(lvl) + po;
1344
1345
1346 int *Down_orbits;
1347 int nb_down_orbits;
1348
1349 Down_orbits = NEW_int(Poo->node_get_nb_of_extensions(n1));
1350 nb_down_orbits = 0;
1351
1352 for (so = 0; so < Poo->node_get_nb_of_extensions(n1); so++) {
1353
1354 if (f_vv) {
1355 cout << "poset_classification::make_full_poset_graph "
1356 "adding edges lvl=" << lvl
1357 << " po=" << po << " so=" << so << endl;
1358 }
1359
1360
1361 extension *E = Poo->get_node(n1)->get_E(so);
1362 if (E->get_type() == EXTENSION_TYPE_EXTENSION) {
1363 //cout << "extension node" << endl;
1364 n2 = E->get_data();
1365
1366 Down_orbits[nb_down_orbits++] = n2;
1367 }
1368 else if (E->get_type() == EXTENSION_TYPE_FUSION) {
1369 //cout << "fusion node" << endl;
1370 // po = data1
1371 // so = data2
1372 int n0, so0;
1373 n0 = E->get_data1();
1374 so0 = E->get_data2();
1375 //cout << "fusion (" << n1 << "/" << so << ") "
1376 //"-> (" << n0 << "/" << so0 << ")" << endl;
1377 extension *E0;
1378 E0 = Poo->get_node(n0)->get_E(so0);
1379 if (E0->get_type() != EXTENSION_TYPE_EXTENSION) {
1380 cout << "warning: fusion node does not point "
1381 "to extension node" << endl;
1382 cout << "type = ";
1383 print_extension_type(cout, E0->get_type());
1384 cout << endl;
1385 exit(1);
1386 }
1387 n2 = E0->get_data();
1388 Down_orbits[nb_down_orbits++] = n2;
1389 }
1390
1391 } // next so
1392
1393
1394 if (f_vv) {
1395 cout << "poset_classification::make_full_poset_graph adding edges "
1396 "lvl=" << lvl << " po=" << po
1397 << " so=" << so << " downorbits = ";
1398 Int_vec_print(cout, Down_orbits, nb_down_orbits);
1399 cout << endl;
1400 }
1401
1402 Sorting.int_vec_sort_and_remove_duplicates(Down_orbits, nb_down_orbits);
1403 if (f_vv) {
1404 cout << "poset_classification::make_full_poset_graph adding edges "
1405 "lvl=" << lvl << " po=" << po
1406 << " so=" << so << " unique downorbits = ";
1407 Int_vec_print(cout, Down_orbits, nb_down_orbits);
1408 cout << endl;
1409 }
1410
1411 for (h = 0; h < nb_down_orbits; h++) {
1412 n2 = Down_orbits[h];
1413 po2 = n2 - Poo->first_node_at_level(lvl + 1);
1414 ol2 = Orbit_len[lvl + 1][po2];
1415 if (f_vv) {
1416 cout << "poset_classification::make_full_poset_graph "
1417 "adding edges lvl=" << lvl << " po=" << po
1418 << " so=" << so << " downorbit = " << h
1419 << " / " << nb_down_orbits << " n1=" << n1
1420 << " n2=" << n2 << " po2=" << po2
1421 << " ol1=" << ol1 << " ol2=" << ol2
1422 << " Fst_element_per_orbit[lvl][po]="
1423 << Fst_element_per_orbit[lvl][po]
1424 << " Fst_element_per_orbit[lvl + 1][po2]="
1425 << Fst_element_per_orbit[lvl + 1][po2] << endl;
1426 }
1427 for (el1 = 0; el1 < ol1; el1++) {
1428 if (f_vv) {
1429 cout << "unrank " << lvl << ", " << po
1430 << ", " << el1 << endl;
1431 }
1432 orbit_element_unrank(lvl, po, el1, set1,
1433 0 /* verbose_level */);
1434 if (f_vv) {
1435 cout << "set1=";
1436 Lint_vec_print(cout, set1, lvl);
1437 cout << endl;
1438 }
1439
1440
1441 for (el2 = 0; el2 < ol2; el2++) {
1442 if (f_vv) {
1443 cout << "unrank " << lvl + 1 << ", "
1444 << po2 << ", " << el2 << endl;
1445 }
1446 orbit_element_unrank(lvl + 1, po2, el2, set2,
1447 0 /* verbose_level */);
1448 if (f_vv) {
1449 cout << "set2=";
1450 Lint_vec_print(cout, set2, lvl + 1);
1451 cout << endl;
1452 }
1453
1454 if (f_vv) {
1455 cout << "poset_classification::make_full_poset_graph "
1456 "adding edges lvl=" << lvl
1457 << " po=" << po << " so=" << so
1458 << " downorbit = " << h << " / "
1459 << nb_down_orbits << " n1=" << n1
1460 << " n2=" << n2 << " po2=" << po2
1461 << " ol1=" << ol1 << " ol2=" << ol2
1462 << " el1=" << el1 << " el2=" << el2
1463 << endl;
1464 cout << "set1=";
1465 Lint_vec_print(cout, set1, lvl);
1466 cout << endl;
1467 cout << "set2=";
1468 Lint_vec_print(cout, set2, lvl + 1);
1469 cout << endl;
1470 }
1471
1472
1473 Lint_vec_copy(set1, set, lvl);
1474
1475 //f_contained = int_vec_sort_and_test_if_contained(
1476 // set, lvl, set2, lvl + 1);
1477 f_contained = poset_structure_is_contained(
1478 set, lvl, set2, lvl + 1,
1479 0 /* verbose_level*/);
1480
1481
1482 if (f_contained) {
1483 if (f_vv) {
1484 cout << "is contained" << endl;
1485 }
1486 LG->add_edge(lvl,
1487 Fst_element_per_orbit[lvl][po] + el1,
1488 lvl + 1,
1489 Fst_element_per_orbit[lvl + 1][po2] + el2,
1490 0 /*verbose_level*/);
1491 }
1492 else {
1493 if (f_vv) {
1494 cout << "is NOT contained" << endl;
1495 }
1496 }
1497
1498 } // next el2
1499 } // next el1
1500 } // next h
1501
1502
1503 FREE_int(Down_orbits);
1504
1505 } // po
1506 } // lvl
1507
1508
1509
1510 if (f_vv) {
1511 cout << "poset_classification::make_full_poset_graph "
1512 "now making vertex labels" << endl;
1513 }
1514 for (lvl = 0; lvl <= depth; lvl++) {
1515 if (f_vv) {
1516 cout << "poset_classification::make_full_poset_graph "
1517 "now making vertex labels lvl " << lvl
1518 << " / " << depth << endl;
1519 }
1520 for (po = 0; po < nb_orbits_at_level(lvl); po++) {
1521
1522 ol1 = Orbit_len[lvl][po];
1523 //
1524 n1 = Poo->first_node_at_level(lvl) + po;
1525
1526 if (f_vv) {
1527 cout << "poset_classification::make_full_poset_graph "
1528 "now making vertex labels lvl " << lvl
1529 << " / " << depth << " po=" << po << " / "
1530 << nb_orbits_at_level(lvl)
1531 << " ol1=" << ol1 << endl;
1532 }
1533
1534 for (el1 = 0; el1 < ol1; el1++) {
1535
1536 if (f_vv) {
1537 cout << "unrank " << lvl << ", "
1538 << po << ", " << el1 << endl;
1539 }
1540 orbit_element_unrank(lvl, po, el1, set1,
1541 0 /* verbose_level */);
1542 if (f_vv) {
1543 cout << "set1=";
1544 Lint_vec_print(cout, set1, lvl);
1545 cout << endl;
1546 }
1547
1548 LG->add_node_vec_data(lvl,
1549 Fst_element_per_orbit[lvl][po] + el1,
1550 set1, lvl,
1551 0 /* verbose_level */);
1552 }
1553
1554
1555 }
1556 }
1557
1558
1559
1560 FREE_lint(set);
1561 FREE_lint(set1);
1562 FREE_lint(set2);
1563 FREE_int(Nb_elements);
1564 FREE_int(Nb_orbits);
1565 FREE_int(Fst);
1566 for (i = 0; i <= depth; i++) {
1567 FREE_int(Fst_element_per_orbit[i]);
1568 }
1569 FREE_pint(Fst_element_per_orbit);
1570 for (i = 0; i <= depth; i++) {
1571 FREE_int(Orbit_len[i]);
1572 }
1573 FREE_pint(Orbit_len);
1574 if (f_v) {
1575 cout << "poset_classification::make_full_poset_graph done" << endl;
1576 }
1577}
1578
1579void poset_classification::make_auxiliary_graph(int depth,
1580 graph_theory::layered_graph *&LG, int data1, int verbose_level)
1581// makes a graph of the poset of orbits with 2 * depth + 1 layers.
1582// The middle layers represent the flag orbits.
1583{
1584 int f_v = (verbose_level >= 1);
1585 int f_vv = (verbose_level >= 2);
1586 int f_v3 = (verbose_level >= 3);
1587 int f_v4 = (verbose_level >= 4);
1588 int nb_layers;
1589 int *Nb;
1590 int *Fst;
1591 int i, lvl, po, so, n, n1, f;
1592 ring_theory::longinteger_domain D;
1593
1594 if (f_v) {
1595 cout << "poset_classification::make_auxiliary_graph" << endl;
1596 }
1597
1598 //print_fusion_nodes(depth);
1599
1600
1601
1602 nb_layers = 2 * depth + 1;
1603 Nb = NEW_int(nb_layers);
1604 Fst = NEW_int(nb_layers);
1605 Fst[0] = 0;
1606 for (i = 0; i < depth; i++) {
1607 Nb[2 * i] = nb_orbits_at_level(i);
1608 Fst[2 * i + 1] = Fst[2 * i] + Nb[2 * i];
1609 count_extension_nodes_at_level(i);
1610 Nb[2 * i + 1] = Poo->get_nb_extension_nodes_at_level_total(i);
1611 Fst[2 * i + 2] = Fst[2 * i + 1] + Nb[2 * i + 1];
1612 }
1613 Nb[2 * depth] = nb_orbits_at_level(depth);
1614
1615 LG = NEW_OBJECT(graph_theory::layered_graph);
1616 if (f_vv) {
1617 cout << "poset_classification::make_auxiliary_graph "
1618 "before LG->init" << endl;
1619 }
1620 LG->add_data1(data1, 0/*verbose_level*/);
1621
1622 string dummy;
1623 dummy.assign("");
1624
1625 LG->init(nb_layers, Nb, dummy, verbose_level - 1);
1626 if (f_vv) {
1627 cout << "poset_classification::make_auxiliary_graph "
1628 "after LG->init" << endl;
1629 }
1630 LG->place(verbose_level - 1);
1631 if (f_vv) {
1632 cout << "poset_classification::make_auxiliary_graph "
1633 "after LG->place" << endl;
1634 }
1635 for (lvl = 0; lvl < depth; lvl++) {
1636 if (f_vv) {
1637 cout << "poset_classification::make_auxiliary_graph "
1638 "adding edges "
1639 "lvl=" << lvl << " / " << depth << endl;
1640 }
1641 f = 0;
1642 for (po = 0; po < nb_orbits_at_level(lvl); po++) {
1643
1644 if (f_v3) {
1645 cout << "poset_classification::make_auxiliary_graph "
1646 "adding edges lvl=" << lvl << " po=" << po
1647 << " / " << nb_orbits_at_level(lvl) << endl;
1648 }
1649
1650 //
1651 n = Poo->first_node_at_level(lvl) + po;
1652 for (so = 0; so < Poo->node_get_nb_of_extensions(n); so++) {
1653
1654 if (f_v4) {
1655 cout << "poset_classification::make_auxiliary_graph "
1656 "adding edges "
1657 "lvl=" << lvl << " po=" << po
1658 << " so=" << so << endl;
1659 }
1660 LG->add_edge(2 * lvl, po, 2 * lvl + 1, f + so,
1661 verbose_level - 4);
1662
1663 extension *E = Poo->get_node(n)->get_E(so);
1664 if (E->get_type() == EXTENSION_TYPE_EXTENSION) {
1665 if (f_v4) {
1666 cout << "extension node" << endl;
1667 }
1668 n1 = E->get_data();
1669 if (f_v4) {
1670 cout << "n1=" << n1 << endl;
1671 }
1672 LG->add_edge(2 * lvl + 1, f + so, 2 * lvl + 2,
1673 n1 - Poo->first_node_at_level(lvl + 1),
1674 verbose_level - 4);
1675 }
1676 else if (E->get_type() == EXTENSION_TYPE_FUSION) {
1677 if (f_v4) {
1678 cout << "fusion node" << endl;
1679 }
1680 // po = data1
1681 // so = data2
1682 int n0, so0;
1683 n0 = E->get_data1();
1684 so0 = E->get_data2();
1685 if (f_v4) {
1686 cout << "fusion (" << n << "/" << so << ") -> ("
1687 << n0 << "/" << so0 << ")" << endl;
1688 }
1689 extension *E0;
1690 E0 = Poo->get_node(n0)->get_E(so0);
1691 if (E0->get_type() != EXTENSION_TYPE_EXTENSION) {
1692 cout << "warning: fusion node does not point "
1693 "to extension node" << endl;
1694 cout << "type = ";
1695 print_extension_type(cout, E0->get_type());
1696 cout << endl;
1697 exit(1);
1698 }
1699 n1 = E0->get_data();
1700 if (f_v4) {
1701 cout << "n1=" << n1
1702 << " first_poset_orbit_node_node_at_level[lvl + 1] = "
1703 << Poo->first_node_at_level(lvl + 1) << endl;
1704 }
1705 LG->add_edge(2 * lvl + 1, f + so, 2 * lvl + 2,
1706 n1 - Poo->first_node_at_level(lvl + 1),
1707 verbose_level - 4);
1708 }
1709 }
1710
1711 f += Poo->node_get_nb_of_extensions(n);
1712 }
1713 if (f_vv) {
1714 cout << "poset_classification::make_auxiliary_graph "
1715 "after LG->add_edge (1)" << endl;
1716 }
1717 }
1718
1719
1720 if (f_vv) {
1721 cout << "poset_classification::make_auxiliary_graph "
1722 "now making vertex labels" << endl;
1723 }
1724 for (lvl = 0; lvl <= depth; lvl++) {
1725 f = 0;
1726 if (f_vv) {
1727 cout << "poset_classification::make_auxiliary_graph now making vertex "
1728 "labels lvl " << lvl << " / " << depth << endl;
1729 }
1730 for (po = 0; po < nb_orbits_at_level(lvl); po++) {
1731
1732
1733 if (f_v3) {
1734 cout << "poset_classification::make_auxiliary_graph "
1735 "now making vertex labels lvl " << lvl << " / "
1736 << depth << " po=" << po << " / "
1737 << nb_orbits_at_level(lvl) << endl;
1738 }
1739
1740
1741 char text1[1000];
1742 char text2[2000];
1743 ring_theory::longinteger_object go, go1;
1744 int n, so, len, r;
1745
1746 n = Poo->first_node_at_level(lvl) + po;
1747 get_stabilizer_order(lvl, po, go);
1748 go.print_to_string(text1);
1749 if (lvl) {
1750 snprintf(text2, 2000, "$%ld_{%s}$", Poo->get_node(n)->get_pt(), text1);
1751 }
1752 else {
1753 snprintf(text2, 2000, "$\\emptyset_{%s}$", text1);
1754 }
1755
1756 // set label to be the automorphism group order:
1757 //LG->add_text(2 * lvl + 0, po, text1, 0/*verbose_level*/);
1758
1759 // set label to be the pt:
1760 LG->add_text(2 * lvl + 0, po, text2, 0/*verbose_level*/);
1761
1762
1763 LG->add_node_data1(2 * lvl + 0, po, Poo->get_node(n)->get_pt(),
1764 0/*verbose_level*/);
1765 if (lvl) {
1766 LG->add_node_data2(2 * lvl + 0, po, 2 * (lvl - 1),
1767 0/*verbose_level*/);
1768 LG->add_node_data3(2 * lvl + 0, po,
1769 Poo->get_node(n)->get_prev() - Poo->first_node_at_level(lvl - 1),
1770 0/*verbose_level*/);
1771 }
1772 else {
1773 LG->add_node_data2(2 * lvl + 0, po, -1, 0/*verbose_level*/);
1774 LG->add_node_data3(2 * lvl + 0, po, -1, 0/*verbose_level*/);
1775 }
1776 for (so = 0; so < Poo->node_get_nb_of_extensions(n); so++) {
1777 extension *E = Poo->get_node(n)->get_E(so);
1778 len = E->get_orbit_len();
1779 D.integral_division_by_int(go, len, go1, r);
1780
1781 go1.print_to_string(text1);
1782 snprintf(text2, 2000, "$%d_{%s}$", E->get_pt(), text1);
1783
1784 // set label to be the automorphism group order:
1785 //LG->add_text(2 * lvl + 1, f + so, text1, 0/*verbose_level*/);
1786 // set label to be the point:
1787 LG->add_text(2 * lvl + 1, f + so, text2, 0/*verbose_level*/);
1788
1789
1790 }
1791 f += Poo->node_get_nb_of_extensions(n);
1792 }
1793 }
1794 FREE_int(Nb);
1795 FREE_int(Fst);
1796
1797 if (f_v) {
1798 cout << "poset_classification::make_auxiliary_graph done" << endl;
1799 }
1800}
1801
1802void poset_classification::make_graph(int depth,
1803 graph_theory::layered_graph *&LG, int data1, int f_tree, int verbose_level)
1804// makes a graph of the poset of orbits with depth + 1 layers.
1805{
1806 int f_v = (verbose_level >= 1);
1807 int f_vv = FALSE; //(verbose_level >= 2);
1808 int nb_layers;
1809 int *Nb;
1810 int *Fst;
1811 int i, lvl, po, so, n, n1;
1812 long int *the_set;
1813 //longinteger_domain D;
1814
1815 if (f_v) {
1816 cout << "poset_classification::make_graph f_tree=" << f_tree << endl;
1817 }
1818
1819 //print_fusion_nodes(depth);
1820
1821
1822
1823 nb_layers = depth + 1;
1824 Nb = NEW_int(nb_layers);
1825 Fst = NEW_int(nb_layers);
1826 Fst[0] = 0;
1827 for (i = 0; i < depth; i++) {
1828 Nb[i] = nb_orbits_at_level(i);
1829 Fst[i + 1] = Fst[i] + Nb[i];
1830 }
1831 Nb[depth] = nb_orbits_at_level(depth);
1832
1833 the_set = NEW_lint(depth);
1834
1835
1836 LG = NEW_OBJECT(graph_theory::layered_graph);
1837 if (f_vv) {
1838 cout << "poset_classification::make_graph before LG->init" << endl;
1839 }
1840 LG->add_data1(data1, 0/*verbose_level*/);
1841
1842 string dummy;
1843 dummy.assign("");
1844
1845 LG->init(nb_layers, Nb, dummy, verbose_level);
1846 if (f_vv) {
1847 cout << "poset_classification::make_graph after LG->init" << endl;
1848 }
1849 LG->place(verbose_level);
1850 if (f_vv) {
1851 cout << "poset_classification::make_graph after LG->place" << endl;
1852 }
1853
1854
1855 // make edges:
1856 for (lvl = 0; lvl < depth; lvl++) {
1857 if (f_v) {
1858 cout << "poset_classification::make_graph adding edges "
1859 "lvl=" << lvl << " / " << depth << endl;
1860 }
1861 for (po = 0; po < nb_orbits_at_level(lvl); po++) {
1862
1863 if (FALSE /*f_v*/) {
1864 cout << "poset_classification::make_graph adding edges "
1865 "lvl=" << lvl << " po=" << po << " / "
1866 << nb_orbits_at_level(lvl) << endl;
1867 }
1868
1869 //
1870 n = Poo->first_node_at_level(lvl) + po;
1871 for (so = 0; so < Poo->node_get_nb_of_extensions(n); so++) {
1872
1873 if (FALSE /*f_v*/) {
1874 cout << "poset_classification::make_graph adding edges "
1875 "lvl=" << lvl << " po=" << po
1876 << " so=" << so << endl;
1877 }
1878 //LG->add_edge(2 * lvl, po, 2 * lvl + 1,
1879 //f + so, 0 /*verbose_level*/);
1880 extension *E = Poo->get_node(n)->get_E(so);
1881 if (E->get_type() == EXTENSION_TYPE_EXTENSION) {
1882 //cout << "extension node" << endl;
1883 n1 = E->get_data();
1884 //cout << "n1=" << n1 << endl;
1885 LG->add_edge(lvl, po, lvl + 1,
1886 n1 - Poo->first_node_at_level(lvl + 1),
1887 0 /*verbose_level*/);
1888 }
1889
1890 if (!f_tree) {
1891 if (E->get_type() == EXTENSION_TYPE_FUSION) {
1892 //cout << "fusion node" << endl;
1893 // po = data1
1894 // so = data2
1895 int n0, so0;
1896 n0 = E->get_data1();
1897 so0 = E->get_data2();
1898 //cout << "fusion (" << n << "/" << so << ") -> ("
1899 //<< n0 << "/" << so0 << ")" << endl;
1900 extension *E0;
1901 E0 = Poo->get_node(n0)->get_E(so0);
1902 if (E0->get_type() != EXTENSION_TYPE_EXTENSION) {
1903 cout << "warning: fusion node does not point to "
1904 "extension node" << endl;
1905 cout << "type = ";
1906 print_extension_type(cout, E0->get_type());
1907 cout << endl;
1908 exit(1);
1909 }
1910 n1 = E0->get_data();
1911 //cout << "n1=" << n1
1912 //<< " first_poset_orbit_node_at_level[lvl + 1] = "
1913 //<< first_poset_orbit_node_at_level[lvl + 1] << endl;
1914 LG->add_edge(lvl, po, lvl + 1,
1915 n1 - Poo->first_node_at_level(lvl + 1),
1916 0 /*verbose_level*/);
1917 }
1918 }
1919 }
1920 }
1921 if (f_vv) {
1922 cout << "poset_classification::make_graph "
1923 "after LG->add_edge (1)" << endl;
1924 }
1925 }
1926
1927
1928 // create vertex labels:
1929 if (f_vv) {
1930 cout << "poset_classification::make_graph "
1931 "now making vertex labels" << endl;
1932 }
1933 for (lvl = 0; lvl <= depth; lvl++) {
1934 if (f_vv) {
1935 cout << "poset_classification::make_graph "
1936 "now making vertex labels "
1937 "lvl " << lvl << " / " << depth << endl;
1938 }
1939 for (po = 0; po < nb_orbits_at_level(lvl); po++) {
1940
1941
1942 if (f_vv) {
1943 cout << "poset_classification::make_graph "
1944 "now making vertex "
1945 "labels lvl " << lvl << " / " << depth << " po="
1946 << po << " / " << nb_orbits_at_level(lvl) << endl;
1947 }
1948
1949
1950 char text[1000];
1951 char text2[1000];
1952 ring_theory::longinteger_object go, go1;
1953 int n;
1954
1955 n = Poo->first_node_at_level(lvl) + po;
1956
1957
1958 get_set_by_level(lvl, po, the_set);
1959
1960
1961 get_stabilizer_order(lvl, po, go);
1962 go.print_to_string(text);
1963 if (lvl) {
1964 snprintf(text2, 1000, "%ld", the_set[lvl - 1]);
1965 //snprintf(text2, 1000, "%d;%s", the_set[lvl - 1], text);
1966 }
1967 else {
1968 snprintf(text2, 1000, "$\\emptyset$");
1969 //snprintf(text2, 1000, "$\\emptyset$;%s", text);
1970 }
1971
1972 LG->add_text(lvl, po, text2, 0/*verbose_level*/);
1973
1974 // if no vector data, the text will be printed:
1975 //LG->add_node_vec_data(lvl, po, the_set, lvl, 0 /* verbose_level */);
1976
1977
1978 if (Control->f_node_label_is_group_order) {
1979 // label the node with the group order:
1980 LG->add_node_data1(lvl, po, go.as_int(), 0/*verbose_level*/);
1981 }
1982 else if (Control->f_node_label_is_element) {
1983 // label the node with the point:
1984 if (lvl) {
1985 LG->add_node_data1(lvl, po, Poo->get_node(n)->get_pt(), 0/*verbose_level*/);
1986 }
1987 else {
1988 // root node has no element
1989 }
1990 }
1991 else {
1992 LG->add_node_data1(lvl, po, n, 0/*verbose_level*/);
1993 }
1994
1995 if (lvl) {
1996 LG->add_node_data2(lvl, po, lvl - 1, 0/*verbose_level*/);
1997 LG->add_node_data3(lvl, po,
1998 Poo->get_node(n)->get_prev() - Poo->first_node_at_level(lvl - 1),
1999 0/*verbose_level*/);
2000 }
2001 else {
2002 LG->add_node_data2(lvl, po, -1, 0/*verbose_level*/);
2003 LG->add_node_data3(lvl, po, -1, 0/*verbose_level*/);
2004 }
2005 }
2006 }
2007 FREE_int(Nb);
2008 FREE_int(Fst);
2009 FREE_lint(the_set);
2010
2011 if (f_v) {
2012 cout << "poset_classification::make_graph done" << endl;
2013 }
2014}
2015
2016void poset_classification::make_level_graph(int depth,
2017 graph_theory::layered_graph *&LG, int data1, int level, int verbose_level)
2018// makes a graph with 4 levels showing the relation between
2019// orbits at level 'level' and orbits at level 'level' + 1
2020{
2021 int f_v = (verbose_level >= 1);
2022 int f_vv = (verbose_level >= 2);
2023 int *Nb;
2024 int *Fst;
2025 long int nb_middle;
2026 int i, lvl, po, so, n, n1, f, l;
2027 ring_theory::longinteger_domain D;
2028 int nb_layers = 4;
2029 long int *the_set;
2030 long int *the_set2;
2031
2032 if (f_v) {
2033 cout << "poset_classification::make_level_graph "
2034 "verbose_level=" << verbose_level << endl;
2035 }
2036
2037 //print_fusion_nodes(depth);
2038
2039
2040 the_set = NEW_lint(depth);
2041 the_set2 = NEW_lint(depth);
2042 Nb = NEW_int(4);
2043 Fst = NEW_int(2);
2044 Fst[0] = 0;
2045 for (i = 0; i < level; i++) {
2046 Fst[0] += nb_orbits_at_level(i);
2047 }
2048 nb_middle = count_extension_nodes_at_level(level);
2049 Fst[1] = Fst[0] + nb_orbits_at_level(level);
2050
2051 Nb[0] = nb_orbits_at_level(level);
2052 Nb[1] = nb_middle;
2053 Nb[2] = nb_middle;
2054 Nb[3] = nb_orbits_at_level(level + 1);
2055
2056 LG = NEW_OBJECT(graph_theory::layered_graph);
2057 if (f_vv) {
2058 cout << "poset_classification::make_level_graph "
2059 "before LG->init" << endl;
2060 cout << "nb_layers=" << nb_layers << endl;
2061 cout << "Nb=";
2062 Int_vec_print(cout, Nb, 4);
2063 cout << endl;
2064 }
2065 LG->add_data1(data1, 0/*verbose_level*/);
2066
2067 string dummy;
2068 dummy.assign("");
2069
2070 LG->init(nb_layers, Nb, dummy, verbose_level);
2071 if (f_vv) {
2072 cout << "poset_classification::make_level_graph "
2073 "after LG->init" << endl;
2074 }
2075 LG->place(verbose_level);
2076 if (f_vv) {
2077 cout << "poset_classification::make_level_graph "
2078 "after LG->place" << endl;
2079 }
2080 f = 0;
2081 for (po = 0; po < nb_orbits_at_level(level); po++) {
2082
2083 if (f_vv) {
2084 cout << "poset_classification::make_level_graph "
2085 "adding edges "
2086 "level=" << level << " po=" << po << " / "
2087 << nb_orbits_at_level(level) << endl;
2088 }
2089
2090 //
2091 n = Poo->first_node_at_level(level) + po;
2092 for (so = 0; so < Poo->node_get_nb_of_extensions(n); so++) {
2093
2094 if (FALSE /*f_v*/) {
2095 cout << "poset_classification::make_level_graph "
2096 "adding edges lvl=" << lvl << " po="
2097 << po << " so=" << so << endl;
2098 }
2099 LG->add_edge(0, po, 1, f + so, 0 /*verbose_level*/);
2100 LG->add_edge(1, f + so, 2, f + so, 0 /*verbose_level*/);
2101 extension *E = Poo->get_node(n)->get_E(so);
2102 if (E->get_type() == EXTENSION_TYPE_EXTENSION) {
2103 //cout << "extension node" << endl;
2104 n1 = E->get_data();
2105 //cout << "n1=" << n1 << endl;
2106 LG->add_edge(2, f + so, 3,
2107 n1 - Poo->first_node_at_level(level + 1),
2108 0 /*verbose_level*/);
2109 }
2110 else if (E->get_type() == EXTENSION_TYPE_FUSION) {
2111 //cout << "fusion node" << endl;
2112 // po = data1
2113 // so = data2
2114 int n0, so0;
2115 n0 = E->get_data1();
2116 so0 = E->get_data2();
2117 //cout << "fusion (" << n << "/" << so
2118 //<< ") -> (" << n0 << "/" << so0 << ")" << endl;
2119 extension *E0;
2120 E0 = Poo->get_node(n0)->get_E(so0);
2121 if (E0->get_type() != EXTENSION_TYPE_EXTENSION) {
2122 cout << "warning: fusion node does not point to "
2123 "extension node" << endl;
2124 cout << "type = ";
2125 print_extension_type(cout, E0->get_type());
2126 cout << endl;
2127 exit(1);
2128 }
2129 n1 = E0->get_data();
2130 //cout << "n1=" << n1
2131 //<< " first_poset_orbit_node_at_level[lvl + 1] = "
2132 //<< first_poset_orbit_node_at_level[lvl + 1] << endl;
2133 LG->add_edge(2, f + so, 3,
2134 n1 - Poo->first_node_at_level(level + 1),
2135 0 /*verbose_level*/);
2136 }
2137 }
2138
2139 f += Poo->node_get_nb_of_extensions(n);
2140 }
2141 if (f_vv) {
2142 cout << "poset_classification::make_level_graph "
2143 "after LG->add_edge" << endl;
2144 }
2145
2146
2147 // creates vertex labels for orbits at level 'level' and 'level' + 1:
2148 if (f_vv) {
2149 cout << "poset_classification::make_level_graph "
2150 "now making vertex labels" << endl;
2151 }
2152 for (lvl = level; lvl <= level + 1; lvl++) {
2153 f = 0;
2154 if (f_vv) {
2155 cout << "poset_classification::make_level_graph "
2156 "now making vertex labels lvl " << lvl
2157 << " / " << depth << endl;
2158 }
2159
2160 if (lvl == level) {
2161 l = 0;
2162 }
2163 else {
2164 l = 3;
2165 }
2166
2167 for (po = 0; po < nb_orbits_at_level(lvl); po++) {
2168
2169
2170 if (f_vv) {
2171 cout << "poset_classification::make_level_graph "
2172 "now making vertex labels lvl " << lvl
2173 << " / " << depth << " po=" << po << " / "
2174 << nb_orbits_at_level(lvl) << endl;
2175 }
2176
2177
2178 char text[1000];
2179 ring_theory::longinteger_object go, go1;
2180 int n, so, len, r;
2181
2182 n = Poo->first_node_at_level(lvl) + po;
2183 get_stabilizer_order(lvl, po, go);
2184 go.print_to_string(text);
2185 LG->add_text(l, po, text, 0/*verbose_level*/);
2186 LG->add_node_data1(l, po, Poo->get_node(n)->get_pt(), 0/*verbose_level*/);
2187
2188 get_set_by_level(lvl, po, the_set);
2189 LG->add_node_vec_data(l, po, the_set, lvl, 0 /* verbose_level */);
2190#if 0
2191 if (lvl) {
2192 LG->add_node_data2(2 * lvl + 0, po, 2 * (lvl - 1),
2193 0/*verbose_level*/);
2194 LG->add_node_data3(2 * lvl + 0, po,
2195 root[n].prev - first_poset_orbit_node_at_level[lvl - 1],
2196 0/*verbose_level*/);
2197 }
2198 else {
2199 LG->add_node_data2(2 * lvl + 0, po, -1, 0/*verbose_level*/);
2200 LG->add_node_data3(2 * lvl + 0, po, -1, 0/*verbose_level*/);
2201 }
2202#endif
2203
2204 if (lvl == level) {
2205 for (so = 0; so < Poo->node_get_nb_of_extensions(n); so++) {
2206 extension *E = Poo->get_node(n)->get_E(so);
2207 len = E->get_orbit_len();
2208 D.integral_division_by_int(go, len, go1, r);
2209 go1.print_to_string(text);
2210 LG->add_text(1, f + so, text, 0/*verbose_level*/);
2211 LG->add_text(2, f + so, text, 0/*verbose_level*/);
2212
2213 //get_set_by_level(lvl, po, the_set);
2214 the_set[lvl] = E->get_pt();
2215 LG->add_node_vec_data(l + 1, f + so, the_set, lvl + 1,
2216 0 /* verbose_level */);
2217 LG->set_distinguished_element_index(l + 1, f + so, lvl,
2218 0 /* verbose_level */);
2219
2220
2221 if (E->get_type() == EXTENSION_TYPE_EXTENSION) {
2222 the_set[lvl] = E->get_pt();
2223 LG->add_node_vec_data(l + 2, f + so, the_set, lvl + 1,
2224 0 /* verbose_level */);
2225 LG->set_distinguished_element_index(l + 2, f + so, lvl,
2226 0 /* verbose_level */);
2227 }
2228 else if (E->get_type() == EXTENSION_TYPE_FUSION) {
2229 Poset->A->element_retrieve(E->get_data(), Elt1, 0);
2230 Poset->A2->map_a_set(the_set, the_set2, lvl + 1, Elt1, 0);
2231 LG->add_node_vec_data(l + 2, f + so, the_set2, lvl + 1,
2232 0 /* verbose_level */);
2233 LG->set_distinguished_element_index(l + 2, f + so, lvl,
2234 0 /* verbose_level */);
2235 }
2236 }
2237 f += Poo->node_get_nb_of_extensions(n);
2238 }
2239 }
2240 }
2241 FREE_lint(the_set);
2242 FREE_lint(the_set2);
2243 FREE_int(Nb);
2244 FREE_int(Fst);
2245
2246 if (f_v) {
2247 cout << "poset_classification::make_level_graph done" << endl;
2248 }
2249}
2250
2251void poset_classification::make_poset_graph_detailed(graph_theory::layered_graph *&LG,
2252 int data1, int max_depth, int verbose_level)
2253// creates the poset graph, with two middle layers at each level.
2254// In total, the graph that is created will have 3 * depth + 1 layers.
2255{
2256 int f_v = (verbose_level >= 1);
2257 int f_vv = (verbose_level >= 2);
2258 int *Nb;
2259 int *Nb_middle;
2260 int i, po, so, n, n1, f, L;
2261 ring_theory::longinteger_domain D;
2262 int nb_layers = 3 * max_depth + 1;
2263 long int *the_set;
2264 long int *the_set2;
2265
2266 if (f_v) {
2267 cout << "poset_classification::make_poset_graph_detailed "
2268 "verbose_level=" << verbose_level << endl;
2269 cout << "max_depth=" << max_depth << endl;
2270 cout << "nb_layers=" << nb_layers << endl;
2271 }
2272
2273 //print_fusion_nodes(depth);
2274
2275
2276 the_set = NEW_lint(max_depth);
2277 the_set2 = NEW_lint(max_depth);
2278 Nb = NEW_int(nb_layers);
2279 Nb_middle = NEW_int(max_depth);
2280 for (i = 0; i < max_depth; i++) {
2281 Nb_middle[i] = count_extension_nodes_at_level(i);
2282 }
2283
2284 for (i = 0; i < max_depth; i++) {
2285
2286 Nb[i * 3 + 0] = nb_orbits_at_level(i);
2287 Nb[i * 3 + 1] = Nb_middle[i];
2288 Nb[i * 3 + 2] = Nb_middle[i];
2289 }
2290 Nb[max_depth * 3 + 0] = nb_orbits_at_level(max_depth);
2291
2292 LG = NEW_OBJECT(graph_theory::layered_graph);
2293 if (f_vv) {
2294 cout << "poset_classification::make_poset_graph_detailed "
2295 "before LG->init" << endl;
2296 cout << "nb_layers=" << nb_layers << endl;
2297 cout << "Nb=";
2298 Int_vec_print(cout, Nb, nb_layers);
2299 cout << endl;
2300 }
2301 LG->add_data1(data1, 0/*verbose_level*/);
2302
2303 string dummy;
2304 dummy.assign("");
2305
2306 LG->init(nb_layers, Nb, dummy, verbose_level);
2307 if (f_vv) {
2308 cout << "poset_classification::make_poset_graph_detailed "
2309 "after LG->init" << endl;
2310 }
2311 for (i = 0; i < nb_layers; i++) {
2312 if ((i % 3) == 0) {
2313 LG->set_radius_factor_for_all_nodes_at_level(
2314 i, .9 /* radius_factor */, 0 /* verbose_level */);
2315 }
2316 else {
2317 // .9 means we don't draw a label at that node
2318 //LG->set_radius_factor_for_all_nodes_at_level(
2319 // i, .9 /* radius_factor */, 0 /* verbose_level */);
2320 LG->set_radius_factor_for_all_nodes_at_level(
2321 i, 0.9 /* radius_factor */, 0 /* verbose_level */);
2322 }
2323 }
2324
2325 LG->place(verbose_level);
2326 if (f_vv) {
2327 cout << "poset_classification::make_poset_graph_detailed "
2328 "after LG->place" << endl;
2329 }
2330
2331
2332 // adding edges:
2333 if (f_vv) {
2334 cout << "poset_classification::make_poset_graph_detailed "
2335 "adding edges" << endl;
2336 }
2337 for (L = 0; L < max_depth; L++) {
2338 if (f_vv) {
2339 cout << "poset_classification::make_poset_graph_detailed "
2340 "adding edges at level " << L << endl;
2341 }
2342 f = 0;
2343 for (po = 0; po < nb_orbits_at_level(L); po++) {
2344
2345 if (f_vv) {
2346 cout << "poset_classification::make_poset_graph_detailed "
2347 "adding edges level=" << L << " po=" << po
2348 << " / " << nb_orbits_at_level(L) << endl;
2349 }
2350
2351 //
2352 n = Poo->first_node_at_level(L) + po;
2353 for (so = 0; so < Poo->node_get_nb_of_extensions(n); so++) {
2354
2355 if (FALSE /*f_v*/) {
2356 cout << "poset_classification::make_poset_graph_detailed "
2357 "adding edges level=" << L << " po=" << po
2358 << " so=" << so << endl;
2359 }
2360 LG->add_edge(L * 3 + 0, po,
2361 L * 3 + 1, f + so, 0 /*verbose_level*/);
2362 LG->add_edge(L * 3 + 1, f + so,
2363 L * 3 + 2, f + so, 0 /*verbose_level*/);
2364 extension *E = Poo->get_node(n)->get_E(so);
2365 if (E->get_type() == EXTENSION_TYPE_EXTENSION) {
2366 //cout << "extension node" << endl;
2367 n1 = E->get_data();
2368 //cout << "n1=" << n1 << endl;
2369 LG->add_edge(L * 3 + 2, f + so, L * 3 + 3,
2370 n1 - Poo->first_node_at_level(L + 1),
2371 0 /*verbose_level*/);
2372 }
2373 else if (E->get_type() == EXTENSION_TYPE_FUSION) {
2374 //cout << "fusion node" << endl;
2375 // po = data1
2376 // so = data2
2377 int n0, so0;
2378 n0 = E->get_data1();
2379 so0 = E->get_data2();
2380 //cout << "fusion (" << n << "/" << so
2381 //<< ") -> (" << n0 << "/" << so0 << ")" << endl;
2382 extension *E0;
2383 E0 = Poo->get_node(n0)->get_E(so0);
2384 if (E0->get_type() != EXTENSION_TYPE_EXTENSION) {
2385 cout << "warning: fusion node does not point to "
2386 "extension node" << endl;
2387 cout << "type = ";
2388 print_extension_type(cout, E0->get_type());
2389 cout << endl;
2390 exit(1);
2391 }
2392 n1 = E0->get_data();
2393 //cout << "n1=" << n1
2394 //<< " first_poset_orbit_node_at_level[lvl + 1] = "
2395 //<< first_poset_orbit_node_at_level[lvl + 1] << endl;
2396 LG->add_edge(L * 3 + 2, f + so, L * 3 + 3,
2397 n1 - Poo->first_node_at_level(L + 1),
2398 0 /*verbose_level*/);
2399 }
2400 }
2401
2402 f += Poo->node_get_nb_of_extensions(n);
2403 }
2404 if (f_vv) {
2405 cout << "poset_classification::make_poset_graph_detailed "
2406 "after LG->add_edge" << endl;
2407 }
2408 } // next L
2409 if (f_vv) {
2410 cout << "poset_classification::make_poset_graph_detailed "
2411 "adding edges done" << endl;
2412 }
2413
2414
2415 // adding vertex labels:
2416 if (f_vv) {
2417 cout << "poset_classification::make_poset_graph_detailed "
2418 "now making vertex labels" << endl;
2419 }
2420 for (L = 0; L <= max_depth; L++) {
2421 f = 0;
2422 if (f_vv) {
2423 cout << "poset_classification::make_poset_graph_detailed "
2424 "now making vertex labels level " << L
2425 << " / " << max_depth << endl;
2426 }
2427
2428 for (po = 0; po < nb_orbits_at_level(L); po++) {
2429
2430
2431 if (f_vv) {
2432 cout << "poset_classification::make_poset_graph_detailed "
2433 "now making vertex labels level " << L
2434 << " / " << max_depth << " po=" << po
2435 << " / " << nb_orbits_at_level(L) << endl;
2436 }
2437
2438
2439 char text[1000];
2440 ring_theory::longinteger_object go, go1;
2441 int n, so, len, r;
2442
2443 n = Poo->first_node_at_level(L) + po;
2444 get_stabilizer_order(L, po, go);
2445 go.print_to_string(text);
2446 LG->add_text(3 * L, po, text, 0/*verbose_level*/);
2447 if (L) {
2448 LG->add_node_data1(3 * L, po, Poo->get_node(n)->get_pt(), 0/*verbose_level*/);
2449 }
2450
2451 get_set_by_level(L, po, the_set);
2452 LG->add_node_vec_data(3 * L, po, the_set, L, 0 /* verbose_level */);
2453#if 0
2454 if (lvl) {
2455 LG->add_node_data2(2 * lvl + 0, po, 2 * (lvl - 1),
2456 0/*verbose_level*/);
2457 LG->add_node_data3(2 * lvl + 0, po,
2458 root[n].prev - first_poset_orbit_node_at_level[lvl - 1],
2459 0/*verbose_level*/);
2460 }
2461 else {
2462 LG->add_node_data2(2 * lvl + 0, po, -1, 0/*verbose_level*/);
2463 LG->add_node_data3(2 * lvl + 0, po, -1, 0/*verbose_level*/);
2464 }
2465#endif
2466
2467 if (L < max_depth) {
2468 for (so = 0; so < Poo->node_get_nb_of_extensions(n); so++) {
2469 if (f_vv) {
2470 cout << "poset_classification::make_poset_graph_detailed "
2471 "now making vertex labels level " << L
2472 << " / " << max_depth << " po=" << po
2473 << " / " << nb_orbits_at_level(L)
2474 << " so=" << so << endl;
2475 }
2476 extension *E = Poo->get_node(n)->get_E(so);
2477 len = E->get_orbit_len();
2478 D.integral_division_by_int(go, len, go1, r);
2479 go1.print_to_string(text);
2480 LG->add_text(3 * L + 1, f + so, text, 0/*verbose_level*/);
2481 LG->add_text(3 * L + 2, f + so, text, 0/*verbose_level*/);
2482
2483 //get_set_by_level(lvl, po, the_set);
2484 the_set[L] = E->get_pt();
2485 LG->add_node_vec_data(3 * L + 1, f + so, the_set,
2486 L + 1, 0 /* verbose_level */);
2487 LG->set_distinguished_element_index(3 * L + 1,
2488 f + so, L, 0 /* verbose_level */);
2489
2490
2491 if (E->get_type() == EXTENSION_TYPE_EXTENSION) {
2492 the_set[L] = E->get_pt();
2493 LG->add_node_vec_data(3 * L + 2, f + so,
2494 the_set, L + 1, 0 /* verbose_level */);
2495 LG->set_distinguished_element_index(3 * L + 2,
2496 f + so, L, 0 /* verbose_level */);
2497 }
2498 else if (E->get_type() == EXTENSION_TYPE_FUSION) {
2499 Poset->A->element_retrieve(E->get_data(), Elt1, 0);
2500 Poset->A2->map_a_set(the_set, the_set2, L + 1, Elt1, 0);
2501 LG->add_node_vec_data(3 * L + 2, f + so,
2502 the_set2, L + 1, 0 /* verbose_level */);
2503 LG->set_distinguished_element_index(3 * L + 2,
2504 f + so, L, 0 /* verbose_level */);
2505 }
2506 }
2507 f += Poo->node_get_nb_of_extensions(n);
2508 } // if (L < max_depth)
2509 } // next po
2510 } // next L
2511 FREE_lint(the_set);
2512 FREE_lint(the_set2);
2513 FREE_int(Nb);
2514 FREE_int(Nb_middle);
2515
2516 if (f_v) {
2517 cout << "poset_classification::make_poset_graph_detailed done" << endl;
2518 }
2519}
2520
2521
2522void poset_classification::print_data_structure_tex(int depth, int verbose_level)
2523{
2524 int f_v = (verbose_level >= 1);
2525 //int f_vv = FALSE; //(verbose_level >= 2);
2526 string fname_base1;
2527 string fname;
2528 int lvl, po, so, n, n1, f, cnt;
2529 long int *set;
2530 char str[1000];
2531 ring_theory::longinteger_domain D;
2532
2533 if (f_v) {
2534 cout << "poset_classification::print_data_structure_tex" << endl;
2535 }
2536 fname_base1.assign(problem_label_with_path);
2537 sprintf(str, "_data_lvl_%d", depth);
2538 fname_base1.append(str);
2539
2540 fname.assign(fname_base1);
2541 fname.append(".tex");
2542
2543 set = NEW_lint(depth);
2544 {
2545 ofstream fp(fname);
2546 orbiter_kernel_system::latex_interface L;
2547
2548 L.head_easy(fp);
2549
2550 print_table1_top(fp);
2551 cnt = 0;
2552 for (lvl = 0; lvl <= depth; lvl++) {
2553 if (f_v) {
2554 cout << "poset_classification::print_data_structure_tex "
2555 "adding edges lvl=" << lvl << " / " << depth << endl;
2556 }
2557 f = 0;
2558 for (po = 0; po < nb_orbits_at_level(lvl); po++, cnt++) {
2559
2560
2561 if (cnt == 25) {
2562 print_table1_bottom(fp);
2563 fp << endl;
2564 fp << "\\bigskip" << endl;
2565 fp << endl;
2566 print_table1_top(fp);
2567 cnt = 0;
2568 }
2569 n = Poo->first_node_at_level(lvl) + po;
2570
2571 char text[1000];
2572 ring_theory::longinteger_object go, go1;
2573
2574 n = Poo->first_node_at_level(lvl) + po;
2575 get_stabilizer_order(lvl, po, go);
2576 go.print_to_string(text);
2577
2578 Poo->get_node(n)->store_set_to(this, lvl - 1, set);
2579
2580 fp << lvl << " & " << po << " & ";
2581
2582 Lint_vec_print(fp, set, lvl);
2583
2584 fp << " & " << go << "\\\\" << endl;
2585
2586 } // next po
2587 } // next lvl
2588 print_table1_bottom(fp);
2589
2590 fp << endl;
2591 fp << "\\bigskip" << endl;
2592 fp << endl;
2593
2594 int f_permutation_degree_is_small;
2595
2596 if (Poset->A2->degree < 15) {
2597 f_permutation_degree_is_small = TRUE;
2598 }
2599 else {
2600 f_permutation_degree_is_small = FALSE;
2601 }
2602
2603
2604 print_table_top(fp, f_permutation_degree_is_small);
2605
2606 cnt = 0;
2607
2608 for (lvl = 0; lvl < depth; lvl++) {
2609 if (f_v) {
2610 cout << "poset_classification::print_data_structure_tex "
2611 "adding edges lvl=" << lvl << " / " << depth << endl;
2612 }
2613 f = 0;
2614 for (po = 0; po < nb_orbits_at_level(lvl); po++) {
2615
2616 n = Poo->first_node_at_level(lvl) + po;
2617
2618 ring_theory::longinteger_object go, go1;
2619 int ol, r, hdl;
2620
2621 n = Poo->first_node_at_level(lvl) + po;
2622 get_stabilizer_order(lvl, po, go);
2623
2624
2625 for (so = 0; so < Poo->node_get_nb_of_extensions(n); so++, cnt++) {
2626
2627 if (cnt == 25) {
2628 print_table_bottom(fp);
2629 fp << endl;
2630 fp << "\\bigskip" << endl;
2631 fp << endl;
2632 print_table_top(fp, f_permutation_degree_is_small);
2633 cnt = 0;
2634 }
2635 if (FALSE /*f_v*/) {
2636 cout << "poset_classification::print_data_structure_tex "
2637 "adding edges lvl=" << lvl << " po="
2638 << po << " so=" << so << endl;
2639 }
2640 extension *E = Poo->get_node(n)->get_E(so); // root[n].E + so;
2641 ol = E->get_orbit_len();
2642
2643 D.integral_division_by_int(go, ol, go1, r);
2644
2645 if (E->get_type() == EXTENSION_TYPE_EXTENSION) {
2646 //cout << "extension node" << endl;
2647 n1 = E->get_data();
2648
2649
2650 fp << lvl << " & " << po << " & " << so << " & ";
2651
2652 Poo->get_node(n)->store_set_to(this, lvl - 1, set);
2653 set[lvl] = E->get_pt();
2654
2655 print_set_special(fp, set, lvl + 1);
2656 //int_vec_print(fp, set, lvl + 1);
2657
2658 fp << " & ";
2659
2660 fp << " $id$ ";
2661
2662 fp << " & ";
2663
2664 if (f_permutation_degree_is_small) {
2665 fp << " $id$ ";
2666
2667 fp << " & ";
2668 }
2669
2670 Poo->get_node(n1)->store_set_to(this, lvl + 1 - 1, set);
2671 //int_vec_print(fp, set, lvl + 1);
2672 print_set_special(fp, set, lvl + 1);
2673
2674 fp << " & " << go1 << "\\\\" << endl;
2675
2676
2677 //cout << "n1=" << n1 << endl;
2678 }
2679 else if (E->get_type() == EXTENSION_TYPE_FUSION) {
2680 //cout << "fusion node" << endl;
2681 // po = data1
2682 // so = data2
2683 int n0, so0;
2684 n0 = E->get_data1();
2685 so0 = E->get_data2();
2686 //cout << "fusion (" << n << "/" << so
2687 //<< ") -> (" << n0 << "/" << so0 << ")" << endl;
2688 extension *E0;
2689 E0 = Poo->get_node(n0)->get_E(so0);
2690 if (E0->get_type() != EXTENSION_TYPE_EXTENSION) {
2691 cout << "warning: fusion node does not point "
2692 "to extension node" << endl;
2693 cout << "type = ";
2694 print_extension_type(cout, E0->get_type());
2695 cout << endl;
2696 exit(1);
2697 }
2698 n1 = E0->get_data();
2699 //cout << "n1=" << n1
2700 //<< " first_poset_orbit_node_at_level[lvl + 1] = "
2701 //<< first_poset_orbit_node_at_level[lvl + 1] << endl;
2702
2703
2704
2705
2706 fp << lvl << " & " << po << " & " << so << " & ";
2707
2708 Poo->get_node(n)->store_set_to(this, lvl - 1, set);
2709 set[lvl] = E->get_pt();
2710 //int_vec_print(fp, set, lvl + 1);
2711 print_set_special(fp, set, lvl + 1);
2712
2713 fp << " & ";
2714
2715 hdl = E->get_data();
2716 Poset->A->element_retrieve(hdl, Elt1, FALSE);
2717
2718 fp << "$";
2719 Poset->A->element_print_latex(Elt1, fp);
2720 fp << "$";
2721
2722 fp << " & ";
2723
2724 if (f_permutation_degree_is_small) {
2725 fp << "$";
2726 Poset->A2->element_print_as_permutation(Elt1, fp);
2727 fp << "$";
2728
2729 fp << " & ";
2730 }
2731
2732
2733
2734
2735 Poo->get_node(n1)->store_set_to(this, lvl + 1 - 1, set);
2736 //int_vec_print(fp, set, lvl + 1);
2737 print_set_special(fp, set, lvl + 1);
2738
2739 fp << " & " << go1 << "\\\\" << endl;
2740
2741
2742 }
2743 }
2744
2745 f += Poo->node_get_nb_of_extensions(n);
2746
2747
2748 } // next po
2749 } // next lvl
2750
2751 print_table_bottom(fp);
2752
2753 L.foot(fp);
2754 }
2755 FREE_lint(set);
2756 if (f_v) {
2757 cout << "poset_classification::print_data_structure_tex done" << endl;
2758 }
2759}
2760
2761static void print_table1_top(ofstream &fp)
2762{
2763 fp << "\\begin{tabular}{|r|r|r|r|}" << endl;
2764 fp << "\\hline" << endl;
2765 fp << "$i$ & $j$ & $R_{i,j}$ & $|G_{R_{i,j}}|$\\\\" << endl;
2766 fp << "\\hline" << endl;
2767 fp << "\\hline" << endl;
2768}
2769
2770static void print_table1_bottom(ofstream &fp)
2771{
2772 fp << "\\hline" << endl;
2773 fp << "\\end{tabular}" << endl;
2774}
2775
2776static void print_table_top(ofstream &fp, int f_permutation_degree_is_small)
2777{
2778 fp << "\\begin{tabular}{|r|r|r|r|r";
2779 if (f_permutation_degree_is_small) {
2780 fp << "|r";
2781 }
2782 fp << "|r|r|}" << endl;
2783 fp << "\\hline" << endl;
2784 fp << "$i$ & $j$ & $a$ & $U_{i,j,a}$ & $\\varphi$ & ";
2785 if (f_permutation_degree_is_small) {
2786 fp << "$\\varphi$ & ";
2787 }
2788 fp << "$U_{i+1,c,d}$ & $|\\Stab_{G_{R_{i,j}}}(U_{i,j,a})|$\\\\" << endl;
2789 fp << "\\hline" << endl;
2790 fp << "\\hline" << endl;
2791}
2792
2793static void print_table_bottom(ofstream &fp)
2794{
2795 fp << "\\hline" << endl;
2796 fp << "\\end{tabular}" << endl;
2797}
2798
2799static void print_set_special(ofstream &fp, long int *set, int sz)
2800{
2801 int i;
2802
2803 fp << "(";
2804 for (i = 0; i < sz; i++) {
2805 fp << set[i];
2806 if (i < sz - 2) {
2807 fp << ", ";
2808 }
2809 if (i == sz - 2) {
2810 fp << "; ";
2811 }
2812 }
2813 fp << ")";
2814}
2815
2816
2817}}}
2818
2819
orbiter::layer1_foundations::data_structures::sorting
a collection of functions related to sorted vectors
Definition: data_structures.h:1148
orbiter::layer1_foundations::data_structures::sorting::int_vec_sort_and_remove_duplicates
void int_vec_sort_and_remove_duplicates(int *v, int &len)
Definition: sorting.cpp:180
orbiter::layer1_foundations::data_structures::sorting::lint_vec_heapsort
void lint_vec_heapsort(long int *v, int len)
Definition: sorting.cpp:1954
orbiter::layer1_foundations::graph_theory::layered_graph
a data structure to store layered graphs or Hasse diagrams
Definition: graph_theory.h:654
orbiter::layer1_foundations::graph_theory::layered_graph::add_node_data2
void add_node_data2(int l, int n, int data, int verbose_level)
Definition: layered_graph.cpp:288
orbiter::layer1_foundations::graph_theory::layered_graph::draw_with_options
void draw_with_options(std::string &fname, graphics::layered_graph_draw_options *O, int verbose_level)
Definition: layered_graph.cpp:312
orbiter::layer1_foundations::graph_theory::layered_graph::add_data1
void add_data1(int data, int verbose_level)
Definition: layered_graph.cpp:241
orbiter::layer1_foundations::graph_theory::layered_graph::place_with_grouping
void place_with_grouping(int **Group_sizes, int *Nb_groups, double x_stretch, int verbose_level)
Definition: layered_graph.cpp:155
orbiter::layer1_foundations::graph_theory::layered_graph::add_node_data3
void add_node_data3(int l, int n, int data, int verbose_level)
Definition: layered_graph.cpp:299
orbiter::layer1_foundations::graph_theory::layered_graph::set_radius_factor_for_all_nodes_at_level
void set_radius_factor_for_all_nodes_at_level(int lvl, double radius_factor, int verbose_level)
Definition: layered_graph.cpp:1256
orbiter::layer1_foundations::graph_theory::layered_graph::add_text
void add_text(int l, int n, const char *text, int verbose_level)
Definition: layered_graph.cpp:229
orbiter::layer1_foundations::graph_theory::layered_graph::write_file
void write_file(std::string &fname, int verbose_level)
Definition: layered_graph.cpp:897
orbiter::layer1_foundations::graph_theory::layered_graph::add_node_data1
void add_node_data1(int l, int n, int data, int verbose_level)
Definition: layered_graph.cpp:277
orbiter::layer1_foundations::graph_theory::layered_graph::place
void place(int verbose_level)
Definition: layered_graph.cpp:119
orbiter::layer1_foundations::graph_theory::layered_graph::init
void init(int nb_layers, int *Nb_nodes_layer, std::string &fname_base, int verbose_level)
Definition: layered_graph.cpp:51
orbiter::layer1_foundations::graph_theory::layered_graph::add_node_vec_data
void add_node_vec_data(int l, int n, long int *v, int len, int verbose_level)
Definition: layered_graph.cpp:252
orbiter::layer1_foundations::graph_theory::layered_graph::add_edge
void add_edge(int l1, int n1, int l2, int n2, int verbose_level)
Definition: layered_graph.cpp:186
orbiter::layer1_foundations::graph_theory::layered_graph::set_distinguished_element_index
void set_distinguished_element_index(int l, int n, int index, int verbose_level)
Definition: layered_graph.cpp:264
orbiter::layer1_foundations::graphics::layered_graph_draw_options
options for drawing an object of type layered_graph
Definition: graphics.h:457
orbiter::layer1_foundations::graphics::mp_graphics
a general 2D graphical output interface (metapost, tikz, postscript)
Definition: graphics.h:545
orbiter::layer1_foundations::graphics::mp_graphics::sl_udsty
void sl_udsty(int line_dashing)
Definition: mp_graphics.cpp:1646
orbiter::layer1_foundations::graphics::mp_graphics::polygon2
void polygon2(int *Px, int *Py, int i1, int i2)
Definition: mp_graphics.cpp:1058
orbiter::layer1_foundations::graphics::mp_graphics::init
void init(std::string &file_name, layered_graph_draw_options *Draw_options, int verbose_level)
Definition: mp_graphics.cpp:71
orbiter::layer1_foundations::graphics::mp_graphics::circle_text
void circle_text(int x, int y, int rad, const char *text)
Definition: mp_graphics.cpp:1818
orbiter::layer1_foundations::graphics::mp_graphics::sf_color
void sf_color(int fill_color)
Definition: mp_graphics.cpp:1678
orbiter::layer1_foundations::graphics::mp_graphics::bezier2
void bezier2(int *Px, int *Py, int i1, int i2)
Definition: mp_graphics.cpp:1216
orbiter::layer1_foundations::graphics::mp_graphics::polygon5
void polygon5(int *Px, int *Py, int i1, int i2, int i3, int i4, int i5)
Definition: mp_graphics.cpp:1087
orbiter::layer1_foundations::graphics::mp_graphics::aligned_text_with_offset
void aligned_text_with_offset(int x, int y, int xoffset, int yoffset, const char *alignment, const char *p)
Definition: mp_graphics.cpp:1600
orbiter::layer1_foundations::graphics::mp_graphics::circle
void circle(int x, int y, int rad)
Definition: mp_graphics.cpp:1802
orbiter::layer1_foundations::graphics::mp_graphics::sf_interior
void sf_interior(int fill_interior)
Definition: mp_graphics.cpp:1672
orbiter::layer1_foundations::graphics::tree_draw_options
options for drawing a tree
Definition: graphics.h:1510
orbiter::layer1_foundations::graphics::tree_draw_options::file_name
std::string file_name
Definition: graphics.h:1515
orbiter::layer1_foundations::graphics::tree_draw_options::f_file
int f_file
Definition: graphics.h:1514
orbiter::layer1_foundations::graphics::tree_node::get_coordinates_and_width
void get_coordinates_and_width(int &idx, int *coord_xyw)
Definition: tree_node.cpp:200
orbiter::layer1_foundations::graphics::tree
a data structure for trees
Definition: graphics.h:1470
orbiter::layer1_foundations::graphics::tree::init
void init(graphics::tree_draw_options *Tree_draw_options, int xmax, int ymax, int verbose_level)
Definition: tree.cpp:39
orbiter::layer1_foundations::graphics::tree::root
tree_node * root
Definition: graphics.h:1474
orbiter::layer1_foundations::graphics::tree::nb_nodes
int nb_nodes
Definition: graphics.h:1476
orbiter::layer1_foundations::orbiter_kernel_system::file_io
a collection of functions related to file io
Definition: orbiter_kernel_system.h:82
orbiter::layer1_foundations::orbiter_kernel_system::file_io::int_matrix_write_csv
void int_matrix_write_csv(std::string &fname, int *M, int m, int n)
Definition: file_io.cpp:1300
orbiter::layer1_foundations::orbiter_kernel_system::file_io::int_vec_write_csv
void int_vec_write_csv(int *v, int len, std::string &fname, const char *label)
Definition: file_io.cpp:1175
orbiter::layer1_foundations::orbiter_kernel_system::file_io::file_size
long int file_size(std::string &fname)
Definition: file_io.cpp:3165
orbiter::layer1_foundations::orbiter_kernel_system::latex_interface
interface to create latex output files
Definition: orbiter_kernel_system.h:338
orbiter::layer1_foundations::orbiter_kernel_system::latex_interface::head_easy
void head_easy(std::ostream &ost)
Definition: latex_interface.cpp:32
orbiter::layer1_foundations::orbiter_kernel_system::latex_interface::foot
void foot(std::ostream &ost)
Definition: latex_interface.cpp:516
orbiter::layer1_foundations::ring_theory::longinteger_domain
domain to compute with objects of type longinteger
Definition: ring_theory.h:240
orbiter::layer1_foundations::ring_theory::longinteger_domain::integral_division_by_int
void integral_division_by_int(longinteger_object &a, int b, longinteger_object &q, int &r)
Definition: longinteger_domain.cpp:724
orbiter::layer1_foundations::ring_theory::longinteger_object
a class to represent arbitrary precision integers
Definition: ring_theory.h:366
orbiter::layer1_foundations::ring_theory::longinteger_object::as_int
int as_int()
Definition: longinteger_object.cpp:192
orbiter::layer1_foundations::ring_theory::longinteger_object::print_to_string
void print_to_string(char *str)
Definition: longinteger_object.cpp:378
orbiter::layer3_group_actions::actions::action::element_print_latex
void element_print_latex(void *elt, std::ostream &ost)
Definition: action_cb.cpp:364
orbiter::layer3_group_actions::actions::action::element_retrieve
void element_retrieve(int hdl, void *elt, int verbose_level)
Definition: action_cb.cpp:301
orbiter::layer3_group_actions::actions::action::map_a_set
void map_a_set(long int *set, long int *image_set, int n, int *Elt, int verbose_level)
Definition: action.cpp:668
orbiter::layer3_group_actions::actions::action::degree
long int degree
Definition: actions.h:133
orbiter::layer3_group_actions::actions::action::element_print_as_permutation
void element_print_as_permutation(void *elt, std::ostream &ost)
Definition: action_cb.cpp:421
orbiter::layer4_classification::poset_classification::extension
represents a flag in the poset classification algorithm; related to poset_orbit_node
Definition: poset_classification.h:78
orbiter::layer4_classification::poset_classification::extension::get_data2
int get_data2()
Definition: extension.cpp:83
orbiter::layer4_classification::poset_classification::extension::get_type
int get_type()
Definition: extension.cpp:42
orbiter::layer4_classification::poset_classification::extension::get_pt
int get_pt()
Definition: extension.cpp:32
orbiter::layer4_classification::poset_classification::extension::get_data1
int get_data1()
Definition: extension.cpp:73
orbiter::layer4_classification::poset_classification::extension::get_data
int get_data()
Definition: extension.cpp:62
orbiter::layer4_classification::poset_classification::extension::get_orbit_len
int get_orbit_len()
Definition: extension.cpp:52
orbiter::layer4_classification::poset_classification::poset_classification_control::f_node_label_is_element
int f_node_label_is_element
Definition: poset_classification.h:264
orbiter::layer4_classification::poset_classification::poset_classification_control::f_node_label_is_group_order
int f_node_label_is_group_order
Definition: poset_classification.h:263
orbiter::layer4_classification::poset_classification::poset_classification::make_graph
void make_graph(int depth, graph_theory::layered_graph *&LG, int data1, int f_tree, int verbose_level)
Definition: poset_classification_draw.cpp:1802
orbiter::layer4_classification::poset_classification::poset_classification::draw_poset_fname_base_poset_detailed_lvl
void draw_poset_fname_base_poset_detailed_lvl(std::string &fname, int depth)
Definition: poset_classification_draw.cpp:58
orbiter::layer4_classification::poset_classification::poset_classification::count_extension_nodes_at_level
long int count_extension_nodes_at_level(int lvl)
Definition: poset_classification.cpp:581
orbiter::layer4_classification::poset_classification::poset_classification::draw_tree
void draw_tree(std::string &fname_base, int lvl, graphics::tree_draw_options *Tree_draw_options, graphics::layered_graph_draw_options *Draw_options, int xmax, int ymax, int rad, int f_embedded, int f_sideways, int verbose_level)
Definition: poset_classification_draw.cpp:188
orbiter::layer4_classification::poset_classification::poset_classification::first_node_at_level
int first_node_at_level(int i)
Definition: poset_classification.cpp:32
orbiter::layer4_classification::poset_classification::poset_classification::write_treefile
void write_treefile(std::string &fname_base, int lvl, graphics::layered_graph_draw_options *draw_options, int verbose_level)
Definition: poset_classification_draw.cpp:97
orbiter::layer4_classification::poset_classification::poset_classification::poset_structure_is_contained
int poset_structure_is_contained(long int *set1, int sz1, long int *set2, int sz2, int verbose_level)
Definition: poset_classification.cpp:207
orbiter::layer4_classification::poset_classification::poset_classification::orbit_element_unrank
void orbit_element_unrank(int depth, int orbit_idx, long int rank, long int *set, int verbose_level)
Definition: poset_classification.cpp:1090
orbiter::layer4_classification::poset_classification::poset_classification::nb_orbits_at_level
int nb_orbits_at_level(int level)
Definition: poset_classification.cpp:192
orbiter::layer4_classification::poset_classification::poset_classification::draw_poset_fname_base_poset_lvl
void draw_poset_fname_base_poset_lvl(std::string &fname, int depth)
Definition: poset_classification_draw.cpp:38
orbiter::layer4_classification::poset_classification::poset_classification::make_auxiliary_graph
void make_auxiliary_graph(int depth, graph_theory::layered_graph *&LG, int data1, int verbose_level)
Definition: poset_classification_draw.cpp:1579
orbiter::layer4_classification::poset_classification::poset_classification::orbit_length_as_int
int orbit_length_as_int(int orbit_at_level, int level)
Definition: poset_classification.cpp:767
orbiter::layer4_classification::poset_classification::poset_classification::draw_tree_low_level
void draw_tree_low_level(std::string &fname, graphics::tree_draw_options *Tree_draw_options, graphics::layered_graph_draw_options *Draw_options, int nb_nodes, int *coord_xyw, int *perm, int *perm_inv, int f_draw_points, int f_draw_extension_points, int f_draw_aut_group_order, int xmax, int ymax, int rad, int f_embedded, int f_sideways, int verbose_level)
Definition: poset_classification_draw.cpp:320
orbiter::layer4_classification::poset_classification::poset_classification::get_set_by_level
void get_set_by_level(int level, int node, long int *set)
Definition: poset_classification.cpp:377
orbiter::layer4_classification::poset_classification::poset_classification::draw_tree_low_level1
void draw_tree_low_level1(graphics::mp_graphics &G, int nb_nodes, int *coords, int *perm, int *perm_inv, int f_draw_points, int f_draw_extension_points, int f_draw_aut_group_order, int radius, int verbose_level)
Definition: poset_classification_draw.cpp:398
orbiter::layer4_classification::poset_classification::poset_classification::draw_poset_fname_base_tree_lvl
void draw_poset_fname_base_tree_lvl(std::string &fname, int depth)
Definition: poset_classification_draw.cpp:48
orbiter::layer4_classification::poset_classification::poset_classification::draw_poset_fname_base_aux_poset
void draw_poset_fname_base_aux_poset(std::string &fname, int depth)
Definition: poset_classification_draw.cpp:28
orbiter::layer4_classification::poset_classification::poset_classification::get_stabilizer_order
void get_stabilizer_order(int level, int orbit_at_level, ring_theory::longinteger_object &go)
Definition: poset_classification.cpp:952
orbiter::layer4_classification::poset_classification::poset_classification::make_full_poset_graph
void make_full_poset_graph(int depth, graph_theory::layered_graph *&LG, int data1, double x_stretch, int verbose_level)
Definition: poset_classification_draw.cpp:1242
orbiter::layer4_classification::poset_classification::poset_classification::find_poset_orbit_node_for_set
int find_poset_orbit_node_for_set(int len, long int *set, int f_tolerant, int verbose_level)
Definition: poset_classification.cpp:406
orbiter::layer4_classification::poset_classification::poset_classification::make_poset_graph_detailed
void make_poset_graph_detailed(graph_theory::layered_graph *&LG, int data1, int max_depth, int verbose_level)
Definition: poset_classification_draw.cpp:2251
orbiter::layer4_classification::poset_classification::poset_classification::make_level_graph
void make_level_graph(int depth, graph_theory::layered_graph *&LG, int data1, int level, int verbose_level)
Definition: poset_classification_draw.cpp:2016
orbiter::layer4_classification::poset_classification::poset_of_orbits::poset_orbit_node_depth_breadth_perm_and_inverse
void poset_orbit_node_depth_breadth_perm_and_inverse(int max_depth, int *&perm, int *&perm_inv, int verbose_level)
Definition: poset_of_orbits.cpp:647
orbiter::layer4_classification::poset_classification::poset_of_orbits::node_get_nb_of_extensions
int node_get_nb_of_extensions(int node)
Definition: poset_of_orbits.cpp:308
orbiter::layer4_classification::poset_classification::poset_of_orbits::log_nodes_for_treefile
void log_nodes_for_treefile(int cur, int depth, std::ostream &f, int f_recurse, int verbose_level)
Definition: poset_of_orbits.cpp:1523
orbiter::layer4_classification::poset_classification::poset_of_orbits::get_node
poset_orbit_node * get_node(int node_idx)
Definition: poset_of_orbits.cpp:257
orbiter::layer4_classification::poset_classification::poset_of_orbits::get_nb_extension_nodes_at_level_total
long int get_nb_extension_nodes_at_level_total(int level)
Definition: poset_of_orbits.cpp:237
orbiter::layer4_classification::poset_classification::poset_of_orbits::first_node_at_level
int first_node_at_level(int i)
Definition: poset_of_orbits.cpp:247
orbiter::layer4_classification::poset_classification::poset_orbit_node::get_E
extension * get_E(int idx)
Definition: poset_orbit_node.cpp:320
orbiter::layer4_classification::poset_classification::poset_orbit_node::get_prev
int get_prev()
Definition: poset_orbit_node.cpp:335
orbiter::layer4_classification::poset_classification::poset_orbit_node::depth_of_node
int depth_of_node(poset_classification *gen)
Definition: poset_orbit_node.cpp:753
orbiter::layer4_classification::poset_classification::poset_orbit_node::get_pt
long int get_pt()
Definition: poset_orbit_node.cpp:325
orbiter::layer4_classification::poset_classification::poset_orbit_node::store_set_to
void store_set_to(poset_classification *gen, int i, long int *to)
Definition: poset_orbit_node.cpp:803
orbiter::layer4_classification::poset_classification::poset_with_group_action::A2
actions::action * A2
Definition: poset_classification.h:1626
orbiter::layer4_classification::poset_classification::poset_with_group_action::A
actions::action * A
Definition: poset_classification.h:1625
Lint_vec_copy
#define Lint_vec_copy(A, B, C)
Definition: foundations.h:694
MINIMUM
#define MINIMUM(x, y)
Definition: foundations.h:216
FREE_int
#define FREE_int(p)
Definition: foundations.h:640
Int_vec_zero
#define Int_vec_zero(A, B)
Definition: foundations.h:713
NEW_pint
#define NEW_pint(n)
Definition: foundations.h:627
NEW_OBJECT
#define NEW_OBJECT(type)
Definition: foundations.h:638
Lint_vec_print
#define Lint_vec_print(A, B, C)
Definition: foundations.h:686
FREE_OBJECT
#define FREE_OBJECT(p)
Definition: foundations.h:651
NEW_int
#define NEW_int(n)
Definition: foundations.h:625
TRUE
#define TRUE
Definition: foundations.h:231
FALSE
#define FALSE
Definition: foundations.h:234
FREE_lint
#define FREE_lint(p)
Definition: foundations.h:642
NEW_lint
#define NEW_lint(n)
Definition: foundations.h:628
FREE_pint
#define FREE_pint(p)
Definition: foundations.h:641
Int_vec_print
#define Int_vec_print(A, B, C)
Definition: foundations.h:685
group_actions.h
orbiter::layer4_classification::poset_classification::print_extension_type
void print_extension_type(ostream &ost, int t)
Definition: extension.cpp:94
orbiter
the orbiter library for the classification of combinatorial objects
Definition: classification.h:18
EXTENSION_TYPE_FUSION
#define EXTENSION_TYPE_FUSION
Definition: poset_classification.h:69
EXTENSION_TYPE_EXTENSION
#define EXTENSION_TYPE_EXTENSION
Definition: poset_classification.h:68
MAX_NODES_FOR_TREEFILE
#define MAX_NODES_FOR_TREEFILE
Definition: poset_classification_draw.cpp:12