/**
\brief Setrese pole, vysledek bude jen jedno zalokovane pole.
\warning Muze zpusobit bad_alloc, protoze alokuje dvakrat tak velkou pamet nez je potreba pro jednu matici
\warning Dodela spravu pameti, kdyz bude shakedown pouzit funkci LDU nemusi byt prealokovan s plnym poctem radku
\todo - Zkusit udelat tak aby se neodalokovavaly vsechna pole
\param rm Rozsireni matice - o kolik bude nulte pole delsi nez je pocet hodnot, v %
\param new_value Nove pole value, ktere nahradi stare pole value
\param new_column Nove pole column, ktere nahradi stare pole column
*/
void SPARSE::M_shake_down(const int& rm)
{
printf("\n\n\n\n\n\n ============================Jsem v Shakedown============================\n\n\n\n\n\n");
// - Zalokuj nove pole
long i,j,ii;
long new_field_length = enlarge_field(value_number,rm);
double* new_value = new double[new_field_length];
long* new_column = new long[new_field_length];
double** new_value_start = new double*[row_number];
long** new_column_start = new long*[row_number];
long* new_value_length = new long[row_number];
double** new_diagonal = new double*[row_number];
ii=0;
// - Zkopiruj do nich hodnoty
for (i=0; i<row_number; i++){//projed po radcich
new_value_start[i] = &new_value[ii];
new_column_start[i] = &new_column[ii];
new_value_length[i] = value_length[i];
for (j=0; j<value_length[i]; j++){//projed po sloupcich
new_value[ii]=value_start[i][j];
new_column[ii]=column_start[i][j];
if(new_column[ii]==i){
new_diagonal[i]=&new_value[ii];
// dia = true;
}
ii++;
}
}
// - Odalokuj puvodne alokovana pole
dealloc();
// - Preukazuj ukazatele
M_aloc = true;
value[0] = new_value;
column[0] = new_column;
value_start = new_value_start;
column_start = new_column_start;
value_length = new_value_length;
diagonal = new_diagonal;
value_number = ii;
// - Predelej veci na spravu pameti
allocated_field = 0;
M_allocated_field_length[0] = new_field_length;
M_empty_start[allocated_field] = value[allocated_field]+ii;
M_empty_end[allocated_field] = &value[allocated_field][M_allocated_field_length[0]-1];
}
int board_toggle_cell (struct klife_board *board, unsigned long x, unsigned long y)
{
int ret = 0;
write_lock (&board->lock);
if (enlarge_needed (board, x, y)) {
printk (KERN_INFO "Enlarge needed to process set of cell %lu,%lu\n", x, y);
ret = enlarge_field (board, max (x, y));
}
if (!ret)
board->field[CELL_BYTE (x, y, board->field_side)] ^= CELL_MASK (x);
write_unlock (&board->lock);
return 0;
}
/**
Procedura - alokuje pole pouzita v matici. Neni blbuvzdorna - jestli byla alokovana, smaze se a prealokuje
\param r/c - row, column, two fields
\param ph - pocet hodnot
\param rm - rozsireni matice
*/
void SPARSE::alloc(const long& r, const long& nov, const int& rm)
{
if (M_aloc == true) dealloc();
M_aloc = true;
M_allocated_field_length[0] = enlarge_field(nov, rm);
extra_field_length = (long)M_allocated_field_length[0]*extra_field_enlargement/100;
allocated_field = 0; // pri kopirovani se vytvori jenom jedno pole do ktereho se vse zkopiruje
value[allocated_field] = new double [M_allocated_field_length[0]];
column[allocated_field] = new long [M_allocated_field_length[0]];
value_start = new double* [r+1];
column_start = new long* [r+1];
value_length = new long [r];
diagonal = new double* [r];
addit_values = false; //jsou alokovana doplnkova pole addit_val a addit_col?
M_empty_start[allocated_field] = &value[0][0];
M_empty_end[allocated_field] = &value[0][M_allocated_field_length[0]-1];
}
int board_set_cell (struct klife_board *board, unsigned long x, unsigned long y)
{
int ret = 0;
write_lock (&board->lock);
if (enlarge_needed (board, x, y)) {
printk (KERN_INFO "Enlarge needed to process set of cell %lu,%lu\n", x, y);
ret = enlarge_field (board, max (x, y));
}
if (!ret) {
/* check for side change */
if (board->side < max (x, y))
board->side = max (x, y) + 1;
/* printk (KERN_INFO "%lu,%lu, ofs = %lu, mask = %lx\n", x, y, CELL_BYTE (x, y, board->field_side << 3), CELL_MASK (x)); */
board->field[CELL_BYTE (x, y, board->field_side)] |= CELL_MASK (x);
}
write_unlock (&board->lock);
return 0;
}
