void flag_orbit_node::print_latex(flag_orbits *Flag_orbits,
ostream &ost,
int f_print_stabilizer_gens)
{
longinteger_object go;
ost << "Flag orbit " << flag_orbit_index << " / " << Flag_orbits->nb_flag_orbits
<< " down=(" << downstep_primary_orbit
<< "," << downstep_secondary_orbit
<< ")"
<< " up=(" << upstep_primary_orbit
<< "," << upstep_secondary_orbit
<< ")";
if (f_fusion_node) {
ost << " fuse to " << fusion_with;
}
ost << " is ";
int_vec_print(ost, Flag_orbits->Pt +
flag_orbit_index * Flag_orbits->pt_representation_sz,
Flag_orbits->pt_representation_sz);
ost << " with a stabilizer of order ";
gens->group_order(go);
ost << go << "\\\\" << endl;
if (f_print_stabilizer_gens) {
gens->print_generators_tex(ost);
}
if (f_fusion_node) {
ost << "Fusion element:\\\\" << endl;
ost << "$$" << endl;
Flag_orbits->A->element_print_latex(fusion_elt, ost);
ost << "$$" << endl;
}
}
int vector_hashing::rank(int *data)
{
int h, idx, f, l, i, I;
sorting Sorting;
h = int_vec_hash(data, data_size, bit_length);
if (!Sorting.int_vec_search(type_value, nb_types, h, idx)) {
cout << "vector_hashing::rank did not "
"find hash value h=" << h << endl;
exit(1);
}
f = type_first[idx];
l = type_len[idx];
for (i = 0; i < l; i++) {
I = f + i;
idx = perm_inv[I];
if (int_vec_compare(vector_data + idx * data_size,
data, data_size) == 0) {
return idx;
}
}
cout << "vector_hashing::rank did not find "
"data f=" << f << " l=" << l << endl;
cout << "data:" << endl;
int_vec_print(cout, data, data_size);
cout << endl;
cout << "hash h=" << h << endl;
cout << "idx=" << idx << endl;
for (i = 0; i < l; i++) {
I = f + i;
idx = perm_inv[I];
cout << I << " : " << idx << " : ";
int_vec_print(cout, vector_data + idx * data_size, data_size);
cout << endl;
}
cout << endl;
print();
exit(1);
}
void vector_hashing::print()
{
int i, j, idx;
cout << "vector_hashing N=" << N << " nb_types=" << nb_types << endl;
cout << "data:" << endl;
for (i = 0; i < N; i++) {
cout << i << " : ";
int_vec_print(cout, vector_data + i * data_size, data_size);
cout << " : " << H[i] << endl;
}
cout << "H sorted:" << endl;
int_vec_print(cout, H_sorted, N);
cout << endl;
cout << "types:" << endl;
for (i = 0; i < nb_types; i++) {
//if (type_len[i] == 1)
//continue;
cout << i << " : "
<< type_first[i] << " : "
<< type_len[i]
<< " : " << H_sorted[type_first[i]] << " : " << endl;
for (j = 0; j < type_len[i]; j++) {
idx = perm_inv[type_first[i] + j];
cout << "j=" << j << " index " << idx << endl;
cout << idx << " : ";
int_vec_print(cout, vector_data + idx * data_size, data_size);
cout << " : " << H[idx] << endl;
}
}
cout << "type_value:" << endl;
for (i = 0; i < nb_types; i++) {
cout << setw(4) << i << " : " << setw(10) << type_value[i] << endl;
}
}
void orbit_node::init(classification_step *C, int orbit_index,
strong_generators *gens, int *Rep, int verbose_level)
{
int f_v = (verbose_level >= 1);
if (f_v) {
cout << "orbit_node::init "
"orbit_index=" << orbit_index << " rep=";
int_vec_print(cout, Rep, C->representation_sz);
cout << endl;
}
orbit_node::C = C;
orbit_node::orbit_index = orbit_index;
orbit_node::gens = gens;
int_vec_copy(Rep,
C->Rep + orbit_index * C->representation_sz,
C->representation_sz);
}
void vector_hashing::compute_tables(int verbose_level)
{
int f_v = (verbose_level >= 1);
int f_vv = (verbose_level >= 2);
int i, j, idx;
sorting Sorting;
if (f_v) {
cout << "vector_hashing::compute_tables" << endl;
}
for (i = 0; i < N; i++) {
H[i] = int_vec_hash(
vector_data + i * data_size,
data_size, bit_length);
}
#if 0
cout << "H:" << endl;
int_vec_print(cout, H, N);
cout << endl;
#endif
Sorting.int_vec_classify(N, H, H_sorted, perm, perm_inv,
nb_types, type_first, type_len);
if (f_v) {
cout << "N =" << N << endl;
cout << "nb_types=" << nb_types << endl;
}
type_value = NEW_int(nb_types);
for (i = 0; i < nb_types; i++) {
idx = type_first[i] + 0;
type_value[i] = H_sorted[idx];
}
//int_vec_sorting_permutation(H, N, perm, perm_inv,
//TRUE /* f_increasingly */);
#if 0
for (i = 0; i < N; i++) {
H_sorted[perm[i]] = H[i];
}
#endif
#if 0
cout << "H sorted:" << endl;
int_vec_print(cout, H_sorted, N);
cout << endl;
#endif
if (f_vv) {
cout << "vector_hashing::compute_tables() N=" << N
<< " nb_types=" << nb_types << endl;
for (i = 0; i < nb_types; i++) {
if (type_len[i] == 1)
continue;
cout << i << " : "
<< type_first[i] << " : "
<< type_len[i]
<< " : " << H_sorted[type_first[i]] << " : " << endl;
for (j = 0; j < type_len[i]; j++) {
idx = perm_inv[type_first[i] + j];
cout << "j=" << j << " index " << idx << endl;
cout << idx << " : ";
int_vec_print(cout, vector_data + idx * data_size, data_size);
cout << " : " << H[idx] << endl;
}
}
}
}
void blt_set_invariants::latex(ostream &ost, int verbose_level)
{
int f_v = (verbose_level >= 1);
sorting Sorting;
if (f_v) {
cout << "blt_set_invariants::latex" << endl;
}
int a, i, j;
ost << "Plane intersection type is ";
for (i = highest_intersection_number; i >= 0; i--) {
a = intersection_type[i];
if (a == 0)
continue;
ost << "$" << i;
if (a > 9) {
ost << "^{" << a << "}";
}
else if (a > 1) {
ost << "^" << a;
}
ost << "$ ";
}
ost << "\\\\" << endl;
ost << "Plane invariant is ";
if (nb_planes < 10) {
ost << "$$";
ost << "\\left[" << endl;
ost << "\\begin{array}{*{" << nb_planes << "}{c}}" << endl;
for (i = 0; i < nb_planes; i++) {
for (j = 0; j < nb_planes; j++) {
ost << intersection_matrix[i * nb_planes + j];
if (j < nb_planes - 1) {
ost << " & ";
}
}
ost << "\\\\" << endl;
}
ost << "\\end{array}" << endl;
ost << "\\right]" << endl;
ost << "$$" << endl;
}
else {
ost << "too big (" << nb_planes << " planes)\\\\" << endl;
}
int f_enter_math = FALSE;
int f_print_subscripts = TRUE;
ost << "$$" << endl;
D2->print_row_decomposition_tex(
ost, f_enter_math, f_print_subscripts, verbose_level - 1);
ost << "\\quad" << endl;
D2->print_column_decomposition_tex(
ost, f_enter_math, f_print_subscripts, verbose_level - 1);
ost << "$$" << endl;
D2->Stack->print_classes_tex(ost);
if (Sos3->nb_sets) {
ost << "$$" << endl;
D3->print_row_decomposition_tex(
ost, f_enter_math, f_print_subscripts, verbose_level - 1);
ost << "$$" << endl;
ost << "$$" << endl;
D3->print_column_decomposition_tex(
ost, f_enter_math, f_print_subscripts, verbose_level - 1);
ost << "$$" << endl;
D3->Stack->print_classes_tex(ost);
int t, fst_col, fst, len, u, a;
fst_col = D3->Stack->startCell[1];
for (t = 0; t < D3->Stack->ht; t++) {
if (!D3->Stack->is_col_class(t)) {
continue;
}
ost << "Column cell " << t << ":\\\\" << endl;
len = D3->Stack->cellSize[t];
fst = D3->Stack->startCell[t];
int *Cell;
Cell = NEW_int(len);
for (u = 0; u < len; u++) {
a = D3->Stack->pointList[fst + u] - fst_col;
Cell[u] = a;
}
Sorting.int_vec_heapsort(Cell, len);
#if 0
for (u = 0; u < len; u++) {
a = Cell[u];
b = Sos3_idx[h][a];
f << a << " (rank = ";
R[h][b].print_not_scientific(f);
f << ") = ";
G->unrank_longinteger(R[h][b], 0 /* verbose_level */);
f << "$\\left[" << endl;
f << "\\begin{array}{*{" << 5 << "}{c}}" << endl;
for (i = 0; i < 3; i++) {
for (j = 0; j < 5; j++) {
c = G->M[i * 5 + j];
f << c;
if (j < 4) {
f << "&";
}
}
f << "\\\\" << endl;
}
f << "\\end{array}" << endl;
f << "\\right]$\\\\" << endl;
}
#endif
FREE_int(Cell);
}
}
int tt, u, v;
tt = (set_size + 3) / 4;
ost << "The points by ranks:\\\\" << endl;
ost << "\\begin{center}" << endl;
for (u = 0; u < 4; u++) {
ost << "\\begin{tabular}[t]{|c|c|}" << endl;
ost << "\\hline" << endl;
ost << "$i$ & Rank \\\\" << endl;
ost << "\\hline" << endl;
for (i = 0; i < tt; i++) {
v = u * tt + i;
if (v < set_size) {
ost << "$" << v << "$ & $" << the_set_in_orthogonal[v]
<< "$ \\\\" << endl;
}
}
ost << "\\hline" << endl;
ost << "\\end{tabular}" << endl;
}
ost << "\\end{center}" << endl;
ost << "The points:\\\\" << endl;
int v5[5];
for (i = 0; i < set_size; i++) {
D->O->unrank_point(
v5, 1, the_set_in_orthogonal[i], 0 /* verbose_level */);
//Grass->unrank_int(data[i], 0/*verbose_level - 4*/);
if ((i % 4) == 0) {
if (i) {
ost << "$$" << endl;
}
ost << "$$" << endl;
}
//f << "\\left[" << endl;
//f << "\\begin{array}{c}" << endl;
ost << "P_{" << i /*data[i]*/ << "}=";
int_vec_print(ost, v5, 5);
#if 0
for (u = 0; u < 5; u++) {
for (v = 0; v < n; v++) {
f << Grass->M[u * n + v];
}
ost << "\\\\" << endl;
}
#endif
//f << "\\end{array}" << endl;
//f << "\\right]" << endl;
}
ost << "$$" << endl;
if (f_v) {
cout << "blt_set_invariants::latex done" << endl;
}
}
void tdo_scheme::init_partition_stack(int verbose_level)
{
int k, at, f, c, l, i;
int f_v = (verbose_level >= 1);
int f_vv = (verbose_level >= 2);
int f_vvv = (verbose_level >= 3);
if (f_v) {
cout << "tdo_scheme::init_partition_stack" << endl;
}
if (f_vv) {
cout << "part_length=" << part_length << endl;
cout << "row_level=" << row_level << endl;
cout << "col_level=" << col_level << endl;
cout << "verbose_level=" << verbose_level << endl;
}
mn = part[0];
m = part[1];
n = mn - m;
if (part_length < 2) {
cout << "part_length < 2" << endl;
exit(1);
}
if (f_vvv) {
cout << "init_partition_stack: m=" << m << " n=" << n << endl;
int_vec_print(part, part_length + 1);
cout << endl;
}
P = new partitionstack;
P->allocate(m + n, 0 /* verbose_level */);
//PB.init_partition_backtrack_basic(m, n, verbose_level - 10);
if (f_vvv) {
cout << "after PB.init_partition_backtrack_basic" << endl;
}
//partitionstack &P = PB.P;
if (f_vvv) {
cout << "initial partition stack: " << endl;
P->print(cout);
}
for (k = 1; k < part_length; k++) {
at = part[k];
c = P->cellNumber[at];
f = P->startCell[c];
l = P->cellSize[c];
if (f_vvv) {
cout << "part[" << k << "]=" << at << endl;
cout << "P->cellNumber[at]=" << c << endl;
cout << "P->startCell[c]=" << f << endl;
cout << "P->cellSize[c]=" << l << endl;
cout << "f + l - at=" << f + l - at << endl;
}
P->subset_continguous(at, f + l - at);
P->split_cell(FALSE);
if (f_vvv) {
cout << "after splitting at " << at << endl;
P->print(cout);
}
if (P->ht == row_level) {
l = P->ht;
if (the_row_scheme) {
FREE_int(the_row_scheme);
the_row_scheme = NULL;
}
the_row_scheme = NEW_int(l * l);
for (i = 0; i < l * l; i++) {
the_row_scheme[i] = -1;
}
get_partition(ROW, l, verbose_level - 3);
get_row_or_col_scheme(ROW, l, verbose_level - 3);
}
if (P->ht == col_level) {
l = P->ht;
if (the_col_scheme) {
FREE_int(the_col_scheme);
the_col_scheme = NULL;
}
the_col_scheme = NEW_int(l * l);
for (i = 0; i < l * l; i++) {
the_col_scheme[i] = -1;
}
get_partition(COL, l, verbose_level - 3);
get_row_or_col_scheme(COL, l, verbose_level - 3);
}
if (P->ht == extra_row_level) {
l = P->ht;
if (the_extra_row_scheme) {
FREE_int(the_extra_row_scheme);
the_extra_row_scheme = NULL;
}
the_extra_row_scheme = NEW_int(l * l);
for (i = 0; i < l * l; i++) {
the_extra_row_scheme[i] = -1;
}
get_partition(EXTRA_ROW, l, verbose_level - 3);
get_row_or_col_scheme(EXTRA_ROW, l, verbose_level - 3);
}
if (P->ht == extra_col_level) {
l = P->ht;
if (the_extra_col_scheme) {
FREE_int(the_extra_col_scheme);
the_extra_col_scheme = NULL;
}
the_extra_col_scheme = NEW_int(l * l);
for (i = 0; i < l * l; i++) {
the_extra_col_scheme[i] = -1;
}
get_partition(EXTRA_COL, l, verbose_level - 3);
get_row_or_col_scheme(EXTRA_COL, l, verbose_level - 3);
}
if (P->ht == lambda_level) {
l = P->ht;
get_partition(LAMBDA, l, verbose_level - 3);
}
} // next k
if (f_vvv) {
cout << "before complete_partition_info" << endl;
}
if (row_level >= 2) {
complete_partition_info(ROW, 0/*verbose_level*/);
}
if (col_level >= 2) {
complete_partition_info(COL, 0/*verbose_level*/);
}
if (extra_row_level >= 2) {
complete_partition_info(EXTRA_ROW, 0/*verbose_level*/);
}
if (extra_col_level >= 2 && extra_col_level < part_length) {
complete_partition_info(EXTRA_COL, 0/*verbose_level*/);
}
complete_partition_info(LAMBDA, 0/*verbose_level*/);
if (f_vv) {
if (row_level >= 2) {
print_scheme(ROW, FALSE);
}
if (col_level >= 2) {
print_scheme(COL, FALSE);
}
if (extra_row_level >= 2) {
print_scheme(EXTRA_ROW, FALSE);
}
if (extra_col_level >= 2) {
print_scheme(EXTRA_COL, FALSE);
}
print_scheme(LAMBDA, FALSE);
}
}
void coding_theory_domain::make_tensor_code_9dimensional_as_point_set(
finite_field *F,
int *&the_set, int &length,
int verbose_level)
{
int f_v = (verbose_level >= 1);
int f_hyperoval = FALSE;
const char *override_poly = "";
const char *override_poly_Q = "";
int i, t, q;
int *code;
if (f_v) {
cout << "make_tensor_code_9dimensional_as_point_set" << endl;
}
q = F->q;
if (q == 2) {
override_poly_Q = ""; override_poly = ""; f_hyperoval = FALSE;
}
else if (q == 3) {
override_poly_Q = ""; override_poly = ""; f_hyperoval = FALSE;
}
else if (q == 4) {
override_poly_Q = "19"; override_poly = "7"; f_hyperoval = FALSE;
// F_256 generated by X^8 + X^4 + X^3 + X^2 + 1
// F_16 generated by X^4+X+1 = 19
// F_4 generated by X^2+X+1 = 7
}
else if (q == 5) {
override_poly_Q = "47"; override_poly = ""; f_hyperoval = FALSE;
// F_625 generated by X^4 + X^3 + 3X + 2
// F_25 generated by X^2 + 4X + 2 = 47
}
else if (q == 7) {
override_poly_Q = ""; override_poly = ""; f_hyperoval = FALSE;
}
else if (q == 8) {
override_poly_Q = "97"; override_poly = "11"; f_hyperoval = TRUE;
// F_4096 generated by x^12+x^6+x^4+x+1
// F_64 generated by X^6+X^5+1 = 97
// F_8 generated by X^3+X+1 = 11
}
else if (q == 9) {
override_poly_Q = ""; override_poly = "17"; f_hyperoval = FALSE;
}
make_tensor_code_9_dimensional(q, override_poly_Q, override_poly,
f_hyperoval, code, length, verbose_level - 1);
the_set = NEW_int(length);
int pt[9], rk;
for (t = 0; t < length; t++) {
for (i = 0; i < 9; i++) {
pt[i] = code[i * length + t];
}
F->PG_element_rank_modified(pt, 1, 9, rk);
the_set[t] = rk;
}
FREE_int(code);
if (f_v) {
cout << "make_tensor_code_9dimensional_as_point_set done" << endl;
cout << "created the set: ";
int_vec_print(cout, the_set, length);
cout << endl;
}
}
void coding_theory_domain::twisted_tensor_product_codes(
int *&H_subfield, int &m, int &n,
finite_field *F, finite_field *f,
int f_construction_A, int f_hyperoval,
int f_construction_B, int verbose_level)
{
int f_v = (verbose_level >= 1);
int f_vv = (verbose_level >= 2);
int index;
int exponents[9];
int *M;
//int *H_subfield;
int *C;
int *C_inv;
int q = f->q;
int q2;
int Q;
//int m, n;
int r;
int beta, beta_q;
int f_elements_exponential = TRUE;
const char *symbol_for_print = "\\alpha";
const char *symbol_for_print_subfield = "\\omega";
if (f_v) {
cout << "twisted_tensor_product_codes" << endl;
cout << "f_construction_A=" << f_construction_A << endl;
cout << "f_hyperoval=" << f_hyperoval << endl;
cout << "f_construction_B=" << f_construction_B << endl;
}
q2 = q * q;
Q = 0;
if (f_construction_A) {
Q = q2;
}
else if (f_construction_B) {
Q = q2 * q;
}
index = (Q - 1) / (q - 1);
if (Q != F->q) {
cout << "twisted_tensor_product_codes Q != F->q" << endl;
exit(1);
}
if (f_vv) {
cout << "q = " << q << endl;
cout << "Q = " << Q << endl;
cout << "index = " << index << endl;
}
#if 0
F.init_override_polynomial(Q, override_poly_Q, verbose_level - 2);
if (f_vv) {
cout << "field of order " << Q << " initialized" << endl;
}
f.init_override_polynomial(q, override_poly_q, verbose_level - 2);
if (f_vv) {
cout << "field of order " << q << " initialized" << endl;
cout << "index = " << index << endl;
}
#endif
F->compute_subfields(verbose_level - 2);
create_matrix_M(
M,
F, f,
m, n, beta, r, exponents,
f_construction_A, f_hyperoval, f_construction_B,
f_elements_exponential, symbol_for_print,
verbose_level - 2);
beta_q = F->power(beta, q);
if (f_vv) {
cout << "twisted_tensor_product_codes after create_matrix_M" << endl;
cout << "m = " << m << endl;
cout << "n = " << n << endl;
cout << "Q = " << Q << endl;
cout << "q2 = " << q2 << endl;
cout << "beta = " << beta << endl;
cout << "beta_q = " << beta_q << endl;
cout << "Exponents: ";
int_vec_print(cout, exponents, m);
cout << endl;
}
if (f_vv) {
cout << "twisted_tensor_product_codes: M:" << endl;
print_integer_matrix_width(cout, M, m, n, n, 2);
F->latex_matrix(cout, f_elements_exponential, symbol_for_print, M, m, n);
}
#if 0
for (j = 0; j < n; j++) {
PG_element_normalize(F, M + j, n, m);
}
cout << "column normalized M:" << endl;
print_integer_matrix_width(cout, M, m, n, n, 2);
#endif
C = NEW_int(m * m);
C_inv = NEW_int(m * m);
H_subfield = NEW_int(m * n);
create_matrix_H_subfield(F, f,
H_subfield, C, C_inv, M, m, n, beta, beta_q,
f_elements_exponential, symbol_for_print, symbol_for_print_subfield,
f_construction_A, f_hyperoval, f_construction_B,
verbose_level - 2);
if (f_v) {
cout << "twisted_tensor_product_codes: after create_matrix_H_subfield" << endl;
cout << "H_subfield:" << endl;
print_integer_matrix_width(cout, H_subfield, m, n, n, 2);
f->latex_matrix(cout, f_elements_exponential, symbol_for_print_subfield, H_subfield, m, n);
}
FREE_int(M);
FREE_int(C);
FREE_int(C_inv);
}
