GaussElimComputation::GaussElimComputation(const Matrix *m, int collsyz, int nsyz)
: row(m->n_rows()-1),
R(m->get_ring()),
gens(m),
n_gb(0),
n_pairs(0),
n_syz(0),
collect_syz(collsyz)
{
int i;
typedef struct gm_elem *gm_elem_ptr;
reduce_list = newarray(gm_elem_ptr,m->n_rows());
gb_list = newarray(gm_elem_ptr,m->n_rows());
for (i=0; i<m->n_rows(); i++)
{
reduce_list[i] = NULL;
gb_list[i] = NULL;
}
if (nsyz < 0 || nsyz > m->n_cols())
nsyz = m->n_cols();
n_comps_per_syz = nsyz;
Fsyz = m->cols()->sub_space(nsyz);
for (i=0; i<m->n_cols(); i++)
{
gm_elem *p = new_gen(i);
insert(p);
}
}
/*
* Initialize an allocated mount node.
* It is assumed that the mount node was b-zero'd
* before getting here so anything that would
* be set to zero isn't done here.
*/
void
init_map(am_node *mp, char *dir)
{
/*
* mp->am_mapno is initialized by exported_ap_alloc
* other fields don't need to be set to zero.
*/
mp->am_mnt = new_mntfs();
mp->am_mfarray = 0;
mp->am_name = strdup(dir);
mp->am_path = strdup(dir);
mp->am_gen = new_gen();
#ifdef HAVE_FS_AUTOFS
mp->am_autofs_fh = 0;
#endif /* HAVE_FS_AUTOFS */
mp->am_timeo = gopt.am_timeo;
mp->am_attr.ns_status = NFS_OK;
mp->am_fattr = gen_fattr;
mp->am_fattr.na_fsid = 42;
mp->am_fattr.na_fileid = mp->am_gen;
clocktime(&mp->am_fattr.na_atime);
/* next line copies a "struct nfstime" among several fields */
mp->am_fattr.na_mtime = mp->am_fattr.na_ctime = mp->am_fattr.na_atime;
new_ttl(mp);
mp->am_stats.s_mtime = mp->am_fattr.na_atime.nt_seconds;
mp->am_dev = -1;
mp->am_rdev = -1;
}
// Reports game status for current position or after the given move. The status
// helps to determine whether to continue with search or if the game is over.
//------------------------------------------------------------------------------
Status standing(Position *self, Move move, int score) {
Status status = InProgress;
if (move) {
self = make_move(self, move);
}
int ply = PLY(); // After the ^^^ move is made.
if (score == 0) {
if (ply == 1) {
if (insufficient(self)) {
status = Insufficient;
} else if (third_repetition(self)) {
status = Repetition;
} else if (fifty(self)) {
status = FiftyMoves;
}
}
if (status == InProgress) {
MoveGen *gen = new_gen(self, MaxPly);
if (!any_valid(generate_moves(gen))) {
status = Stalemate;
}
}
} else if (score == Checkmate - ply) {
if (is_in_check(self, self->color)) {
status = (self->color == White ? BlackWon : WhiteWon);
} else {
status = Stalemate;
}
} else if (score > Checkmate - MaxDepth && (score + ply) / 2 > 0) {
status = (self->color == White ? BlackWinning : WhiteWinning);
}
if (move) {
self = undo_last_move(self);
}
return status;
}
int main() {
int button_code;
int pause_state = 0;
int reset_state = 0;
setup_gui();
// Seed random num generator
srand (time(NULL));
box_fam = create_gen(gen_size);
randomise_gen(box_fam);
ifit = -1;
for (int i=0; i<ngen; i++) {
// Score generation
score_gen(box_fam);
printf("gen %i\r", i);
fflush(stdout);
// Draw fittest of the fit
jfit = fittest_cov(box_fam);
if (ifit != jfit) {
ifit = jfit;
clear_window();
draw_boarder();
draw_cover(& box_fam[ifit]);
draw_pause_button(pause_state);
draw_reset_button(reset_state);
flush_window();
printf("gen %i, %f\n", i, nboxes*pow(box_fam[ifit].l,2));
add_score(i, nboxes*pow(box_fam[ifit].l,2));
}
if (window_redraw_required()) {
clear_window();
draw_boarder();
draw_cover(& box_fam[ifit]);
draw_pause_button(pause_state);
draw_reset_button(reset_state);
draw_scores();
flush_window();
}
button_code = handle_button_presses();
while (button_code != 0 || pause_state || reset_state) {
if (pause_state || reset_state)
button_code = blocking_handle_button_presses();
switch (button_code) {
case -1:
// Redraw Required
clear_window();
draw_boarder();
draw_cover(& box_fam[ifit]);
draw_pause_button(pause_state);
draw_reset_button(reset_state);
draw_scores();
flush_window();
break;
case 1:
// Play/Pause Button
if (pause_state) {
printf("\rPlay! \n");
pause_state = 0;
} else {
printf("\rPause! \n");
pause_state = 1;
}
draw_pause_button(pause_state);
flush_window();
break;
case 2:
// Reset/Start Button
if (reset_state) {
printf("\rStart! \n");
reset_state = 0;
} else {
printf("\rReset! \n");
print_best();
i = 0;
randomise_gen(box_fam);
score_gen(box_fam);
reset_state = 1;
reset_scores();
flush_window();
}
clear_window();
draw_boarder();
draw_cover(& box_fam[ifit]);
draw_pause_button(pause_state);
draw_reset_button(reset_state);
flush_window();
break;
default:
printf("\rButton Error %i\n ", button_code);
exit(button_code);
}
button_code = handle_button_presses();
}
// Evolve Generation
new_gen(box_fam);
}
// Clear last gen n line
printf(" \r");
fflush(stdout);
close_gui();
print_best();
printf("Press enter to close\n");
while( getchar() != '\n' );
return 0;
}
void gbB::initialize(const Matrix *m, int csyz, int nsyz, M2_arrayint gb_weights0, int strat, int max_reduction_count0)
{
// max_reduction_count: default was 10
// 1 is best possible for 3-anderbuch!
// 5 is: (114.64 sec, 494 MB)
// 10 is best so far (125.33 sec, 527 MB virtual).
// 50 is faster/smaller than 100, and 1000 was awful, on 3-andersbuch
max_reduction_count = max_reduction_count0;
const PolynomialRing *origR = m->get_ring()->cast_to_PolynomialRing();
if (origR == NULL)
{
ERROR("ring is not a polynomial ring");
// MES: throw an error here.
assert(0);
}
originalR = origR;
R = origR->get_gb_ring();
weightInfo = new GBWeight(m->rows(), gb_weights0);
gb_weights = weightInfo->get_weights();
nvars = R->get_flattened_monoid()->n_vars();
spair_stash = new stash("gbB spairs", sizeof(spair));
gbelem_stash = new stash("gbB elems", sizeof(gbelem));
exp_size = EXPONENT_BYTE_SIZE(nvars+2);
lcm_stash = new stash("gbB lead monoms", exp_size);
if (nsyz < 0 || nsyz > m->n_cols())
nsyz = m->n_cols();
n_rows_per_syz = nsyz;
F = m->rows();
Fsyz = m->cols()->sub_space(n_rows_per_syz);
S = new SPairSet;
first_in_degree = 0;
n_syz = 0;
n_pairs_computed = 0;
n_gens_left = 0;
n_subring = 0;
_strategy = strat;
_collect_syz = csyz;
_is_ideal = (F->rank() == 1 && csyz == 0);
if (R->is_weyl_algebra())
_is_ideal = false;
hilbert = 0;
n_saved_hilb = 0;
this_degree = F->lowest_primary_degree() - 1;
npairs = 0;
complete_thru_this_degree = this_degree;
set_status(COMP_NOT_STARTED);
stats_nreductions = 0;
stats_ntail = 0;
stats_npairs = 0;
stats_ngb = 0;
stats_ngcd1 = 0;
divisor_previous = -1;
divisor_previous_comp = -1;
lookup = MonomialTable::make(nvars);
minimal_gb = ReducedGB::create(originalR,F,Fsyz);
minimal_gb_valid = true;
if (originalR->is_quotient_ring())
{
ringtable = originalR->get_quotient_MonomialTable();
first_gb_element = originalR->n_quotients();
for (int i=0; i<first_gb_element; i++)
{
gbvector *f = const_cast<gbvector *>(originalR->quotient_gbvector(i));
gbelem *g = gbelem_ring_make(f);
gb.push_back(g);
}
}
for (int i=0; i<m->n_cols(); i++)
{
ring_elem denom;
gbvector *f = originalR->translate_gbvector_from_vec(F,(*m)[i], denom);
spair *p = new_gen(i, f, denom);
if (p != NULL)
{
spair_set_insert(p);
n_gens_left++;
}
}
state = STATE_NEWDEGREE; // will be changed if hilb fcn is used
np_i = first_gb_element;
ar_i = first_gb_element;
ar_j = ar_i+1;
n_gb = first_gb_element;
}
