template <typename T, typename X> void static_matrix<T, X>::copy_column_to_vector (unsigned j, std::vector<T> & v) const {
v.resize(row_count(), numeric_traits<T>::zero());
for (auto & it : m_columns[j]) {
if (!is_zero(it.m_value))
v[it.m_i]=it.m_value;
}
}
template <typename T, typename X> T static_matrix<T, X>::get_balance() const {
T ret = zero_of_type<T>();
for (unsigned i = 0; i < row_count(); i++) {
ret += get_row_balance(i);
}
return ret;
}
raw_block_pointer begin_row( size_t idx ) const {
ASSERT_VALID_RANGE( idx, 0, row_count() )
size_t offset = block_row_offset( idx, m_bpr );
return m_data + offset;
}
bool
BasicGrid::handle_event_impl(
UI::Event const& event
) noexcept {
switch (event.type) {
case UI::EventType::key_input:
if (!has_input_control() && event.key_input.mod == KeyMod::none) {
bool handled = true;
switch (event.key_input.code) {
case KeyCode::up : row_step(-1); break;
case KeyCode::down : row_step(+1); break;
case KeyCode::left : col_step(-1); break;
case KeyCode::right: col_step(+1); break;
case KeyCode::home: row_abs(0); break;
case KeyCode::end : row_abs(max_ce(0, row_count() - 1)); break;
case KeyCode::pgup:
row_step(min_ce(0, -view().fit_count - 1)); break;
case KeyCode::pgdn:
row_step(max_ce(0, +view().fit_count - 1)); break;
default:
switch (event.key_input.cp) {
case 'k': row_step(-1); break;
case 'j': row_step(+1); break;
case 'h': col_step(-1); break;
case 'l': col_step(+1); break;
case 'a': select_all(); break;
case 'A': select_none(); break;
case 's': select_toggle(m_cursor.row, 1); break;
default:
handled = false;
break;
}
}
return handled;
}
break;
case UI::EventType::focus_changed:
queue_cell_render(
m_cursor.row, m_cursor.row + 1,
m_cursor.col, m_cursor.col + 1
);
if (is_focused()) {
App::instance.m_ui.csline->set_location(
std::to_string(m_cursor.row) + ", " +
std::to_string(m_cursor.col)
);
} else {
App::instance.m_ui.csline->clear_location();
}
return false;
default:
break;
}
return false;
}
bool matrix<T, X>::is_equal(const matrix<T, X>& other) {
if (other.row_count() != row_count() || other.column_count() != column_count())
return false;
for (unsigned i = 0; i < row_count(); i++) {
for (unsigned j = 0; j < column_count(); j++) {
auto a = get_elem(i, j);
auto b = other.get_elem(i, j);
if (numeric_traits<T>::precise()) {
if (a != b) return false;
} else if (fabs(numeric_traits<T>::get_double(a - b)) > 0.000001) {
// cout << "returning false from operator== of matrix comparison" << endl;
// cout << "this matrix is " << endl;
// print_matrix(*this);
// cout << "other matrix is " << endl;
// print_matrix(other);
return false;
}
}
}
return true;
}
void
BasicGrid::reflow_impl() noexcept {
base::reflow_impl();
reflow_view(geometry().frame());
adjust_view();
queue_header_render();
queue_cell_render(0, row_count());
enqueue_actions(
UI::UpdateActions::render |
UI::UpdateActions::flag_noclear
);
}
template <typename T, typename X> void static_matrix<T, X>::set(unsigned row, unsigned col, T const & val) {
if (numeric_traits<T>::is_zero(val)) return;
lean_assert(row < row_count() && col < column_count());
#ifdef LEAN_DEBUG
pair<unsigned, unsigned> p(row, col);
lean_assert(m_domain.find(p) == m_domain.end());
m_domain.insert(p);
#endif
auto & r = m_rows[row];
unsigned offs_in_cols = m_columns[col].size();
m_columns[col].push_back(make_column_cell(row, r.size(), val));
r.push_back(make_row_cell(col, offs_in_cols, val));
}
/**
* initializes and loads world map
* @*path: path to map text file
* RETURNS: returns 0 if all goes well, 1 if there was an error
*/
int initialize_world_map(char *path)
{
int nrows, ncolumns, i;
nrows = row_count(path);
ncolumns = column_count(path);
worldMap.map = malloc( (nrows+1) * sizeof(int *));
for (i=0; i<nrows; i++) {
worldMap.map[i] = malloc(ncolumns * sizeof(int));
}
worldMap.map[nrows] = NULL;
load_map_from_file(path, ncolumns);
return 0;
}
void
BasicGrid::set_cursor(
UI::index_type col,
UI::index_type row
) noexcept {
col = value_clamp(col, 0, max_ce(0, col_count() - 1));
row = value_clamp(row, 0, max_ce(0, row_count() - 1));
if (col != m_cursor.col || row != m_cursor.row) {
if (
value_in_bounds(m_cursor.row, 0, row_count()) &&
value_in_bounds(m_cursor.col, 0, col_count())
) {
queue_cell_render(
m_cursor.row, m_cursor.row + 1,
m_cursor.col, m_cursor.col + 1
);
}
if (row_count() > 0) {
queue_cell_render(
row, row + 1,
col, col + 1
);
}
enqueue_actions(
UI::UpdateActions::render |
UI::UpdateActions::flag_noclear
);
m_cursor.col = col;
m_cursor.row = row;
adjust_view();
if (is_focused()) {
App::instance.m_ui.csline->set_location(
std::to_string(m_cursor.row) + ", " +
std::to_string(m_cursor.col)
);
}
}
}
find_cell_text_col(TableUI *tui, unsigned row, unsigned col, char *text) {
Table *table = tui->table;
unsigned r,c;
/* Find in current column after current row */
for (c = col, r = row + 1; r < row_count(table); r++)
if (cell_has_text(table, r, c, text)) goto found;
/* Find in columns after the current */
for (c = col + 1; c < max_col_count(table); c++)
for (r = 0; r < row_count(table); r++)
if (cell_has_text(table, r, c, text)) goto found;
/* Wrap around up to columns before current */
for (c = 0; c <= col; c++)
for (r = 0; r < row_count(table); r++)
if (cell_has_text(table, r, c, text)) goto found;
return 0;
found:
jump_cursor(tui, r, c);
return 1;
}
void
BasicGrid::resize_grid(
UI::index_type new_col_count,
UI::index_type new_row_count
) {
m_sel.resize(new_row_count);
set_row_count(new_row_count);
set_col_count(new_col_count);
set_cursor(0, 0);
update_view(
0, view().fit_count,
0, col_count(),
false
);
queue_header_render();
queue_cell_render(0, row_count());
enqueue_actions(
UI::UpdateActions::render
);
}
find_cell_text_row(TableUI *tui, unsigned row, unsigned col, char *text) {
Table *table = tui->table;
unsigned r,c;
/* Find in current row after current column */
for (r = row, c = col + 1; c < col_count(table, r); c++)
if (cell_has_text(table, r, c, text)) goto found;
/* Find in rows after current */
for (r = row + 1; r < row_count(table); r++)
for (c = 0; c < col_count(table, r); c++)
if (cell_has_text(table, r, c, text)) goto found;
/* Wrap around and find in rows before current */
for (r = 0; r < row; r++)
for (c = 0; c < col_count(table, r); c++)
if (cell_has_text(table, r, c, text)) goto found;
return 0;
found:
jump_cursor(tui, r, c);
return 1;
}
int csvdb_print_result(result_t *res)
{
row_t *row;
column_ref_t *col;
column_ref_t *c;
table_ref_t *tbl;
nvp_t *cd;
nvp_t *t;
row_t *r;
int l;
char buff[1024];
float tm;
char* v;
int rc;
if (!res) {
printf(_("invalid result set\n"));
return -1;
}
tm = (float)res->time/1000.0;
r = res->result;
rc = row_count(r);
if (res->error) {
t = res->error;
while (t) {
switch (t->num) {
case CSVDB_ERROR_NONE:
break;
case CSVDB_ERROR_INTERNAL:
printf(_("An internal error occured\n"));
break;
case CSVDB_ERROR_SYNTAX:
printf(_("Syntax Error near '%s'\n"),t->value);
break;
case CSVDB_ERROR_TABLEREF:
printf(_("Invalid Table Reference '%s'\n"),t->value);
break;
case CSVDB_ERROR_COLUMNREF:
printf(_("Invalid Column Reference '%s'\n"),t->value);
break;
case CSVDB_ERROR_FILEREF:
printf(_("Invalid File Reference '%s'\n"),t->value);
break;
case CSVDB_ERROR_FILEEXISTS:
printf(_("File '%s' can not be written as it already exists\n"),t->value);
break;
case CSVDB_ERROR_UNSUPPORTED:
printf(_("Unsupported SQL '%s'\n"),t->value);
break;
case CSVDB_ERROR_OUTOFRANGE:
printf(_("Reference is Out Of Range '%s'\n"),t->value);
break;
case CSVDB_ERROR_BADRESULT:
printf(_("Bad Result Set '%s'\n"),t->value);
break;
case CSVDB_ERROR_SUBQUERY:
printf(_("Error in SubQuery: %s\n"),t->value);
break;
default:
printf(_("Unknown error (%d): %s\n"),t->num,t->value);
}
t = t->next;
}
}
if (!rc) {
if (res->ar) {
printf(_("-----\n%d rows affected in %.3f seconds\n\n"),res->ar,tm);
return res->ar;
}
printf(_("0 rows returned\n"));
return 0;
}
if (!res->error) {
printf(_("formatting results...\n"));
col = res->cols;
while (col) {
if (col->alias[0]) {
col->num = strlen(col->alias);
}else{
col->num = strlen(col->name);
if (res->table && res->table->next) {
tbl = table_resolve(col->table->name->value,res);
if (tbl->alias && tbl->alias[0]) {
col->num += strlen(tbl->alias)+1;
}else if (tbl->t->name->next) {
col->num += strlen(tbl->t->name->next->value)+1;
}else{
col->num += strlen(tbl->t->name->value)+1;
}
}
}
col = col->next;
}
row = r;
while (row) {
cd = row->data;
c = res->cols;
while (cd && c) {
l = strlen(cd->value);
if (l > c->num)
c->num = l;
cd = cd->next;
c = c->next;
}
row = row->next;
}
col = res->cols;
l = 0;
while (col) {
l += col->num+3;
col = col->next;
}
l += 2;
v = alloca(sizeof(char)*(l));
v[0] = '+';
l = 1;
col = res->cols;
while (col) {
memset(v+l,'-',col->num+2);
l += col->num+2;
v[l] = '+';
l++;
col = col->next;
}
v[l] = '\0';
puts(v);
col = res->cols;
while (col) {
if (col->alias[0]) {
printf("| %*s ",col->num,col->alias);
}else{
if (res->table && res->table->next) {
tbl = table_resolve(col->table->name->value,res);
if (tbl->alias && tbl->alias[0]) {
sprintf(buff,"%s.%s",tbl->alias,col->name);
printf("| %*s ",col->num,buff);
}else if (tbl->t->name->next) {
sprintf(buff,"%s.%s",tbl->t->name->next->value,col->name);
printf("| %*s ",col->num,buff);
}else{
sprintf(buff,"%s.%s",tbl->t->name->value,col->name);
printf("| %*s ",col->num,buff);
}
}else{
printf("| %*s ",col->num,col->name);
}
}
col = col->next;
}
printf("|\n");
puts(v);
row = r;
while (row) {
cd = row->data;
c = res->cols;
while (cd && c) {
printf("| %*s ",c->num,cd->value);
cd = cd->next;
c = c->next;
}
printf("|\n");
row = row->next;
}
puts(v);
}
printf(_("%d rows returned in %.3f seconds\n\n"),rc,tm);
return rc;
}
int main(int argc, char *argv[]){
//verify that the correct number of arguments were passed
assert(argc==5 || argc==4);
double h = 0.005; //step size parameter to be passed into rk
double t = 0;
//thermal paramaters file
FILE *tpfp;
//power trace file
FILE *ptfp;
//output file
FILE *ofp;
//initialize ambient temperature and resistance
ambientTemp = 300;
//check to see if an argument was passed for ambient temp
if(argc==5){
//if it was, set ambientTemp to it
sscanf(argv[3], "%lf", &ambientTemp);
//if there was, the output file is argument 4
ofp = fopen(argv[4], "w");}
//open the files
tpfp = fopen(argv[1], "rb");
ptfp = fopen(argv[2], "rb");
//if there wasn't an ambient temp argument, output file is argument 3
if(ofp==NULL){ofp = fopen(argv[3], "w");}
//make sure the files are there
assert(tpfp != NULL);
assert(ptfp != NULL);
assert(ofp != NULL);
//number of rows in each input file
int thermalParamLength=row_count(tpfp);
//verify that the thermal parameter file is the correct length
assert(thermalParamLength==6);
powerTraceLength=row_count(ptfp);
//read the files into pointer arrays for thermal param and power trace
thermalParam = fileArray(tpfp, thermalParamLength, 4);
powerTrace = fileArray(ptfp, powerTraceLength, 5);
int i;
int j;
//verify that none of the thermal parameters less than or equal to zero, which isn't possible
for(i=0; i<thermalParamLength; i++){
for(j=0; j<4; j++){assert(thermalParam[i][j]>0);}
}
//T holds the temperatures. cores 0-3 are T[0]-T[3], T[4] is ambient
double *T;
T = initializeT();
double* aP = (double *) malloc(4*sizeof(double)); //age pointer...
for(i=0; i<4; i++){aP[i] = 1;}
double* age;
//step through updating the temperature
//counts how many timesteps are taken in each entry of powerTrace
int counter;
//placeholder variable for t (used in output)
double t_temp;
for(j=0; j<(powerTraceLength); j++){
counter=0;
while(t<(powerTrace[j][0]-h/2)){
T = rk(&calculatedTdt, h, t, T, 5);
//verify that none of the temperatures are below ambient (this can't happen)
for(i=0; i<4; i++){assert(T[i]>=T[4]);}
aP = ageRate(t, T);
age = rk(&ageRate, h, t, aP, 4);
//verify that none of the effective ages are less than 1
for(i=0; i<4; i++){assert(age[i]>=1);}
counter++;
t+=h;
}
//file output stuff
fprintf(ofp, "%lf ", t);
for(i=0; i<4; i++){
fprintf(ofp, "%lf ", T[i]);
fprintf(ofp, "%lf ", age[i]);
}
fprintf(ofp, "\r\n");
}
}
void
BasicGrid::content_action(
UI::ProtoGrid::ContentAction action,
UI::index_type row_begin,
UI::index_type count
) noexcept {
using CA = UI::ProtoGrid::ContentAction;
DUCT_ASSERTE(row_count() == signed_cast(m_sel.size()));
// Cast insert_after in terms of insert_before
if (CA::insert_after == action) {
++row_begin;
}
row_begin = value_clamp(row_begin, 0, row_count());
auto const row_end = min_ce(row_begin + count, row_count());
auto clear_flag = UI::UpdateActions::none;
switch (action) {
// Select
case CA::select: // fall-through
case CA::unselect: {
bool const enable = CA::select == action;
auto const end = m_sel.begin() + row_end;
for (auto it = m_sel.begin() + row_begin; end > it; ++it) {
*it = enable;
}
queue_cell_render(row_begin, row_end);
clear_flag = UI::UpdateActions::flag_noclear;
} break;
case CA::select_toggle: {
auto const end = m_sel.begin() + row_end;
for (auto it = m_sel.begin() + row_begin; end > it; ++it) {
*it = !*it;
}
queue_cell_render(row_begin, row_end);
clear_flag = UI::UpdateActions::flag_noclear;
} break;
// Insert
case CA::insert_after: // fall-through
case CA::insert_before:
for (UI::index_type i = 0; i < count; ++i) {
if (content_insert(row_begin + i)) {
m_sel.insert(m_sel.begin() + row_begin + i, false);
content_action_internal(CA::insert_before, row_begin + i, 1);
}
}
if (row_count() == 1) {
set_cursor(m_cursor.col, 0);
} else if (row_begin <= m_cursor.row) {
set_cursor(m_cursor.col, m_cursor.row + count);
}
adjust_view();
break;
// Erase
case CA::erase:
for (UI::index_type i = 0; i < count; ++i) {
if (content_erase(row_begin)) {
m_sel.erase(m_sel.cbegin() + row_begin);
content_action_internal(CA::erase, row_begin, 1);
}
}
break;
case CA::erase_selected:
for (UI::index_type index = 0; index < row_count();) {
if (m_sel[index] && content_erase(index)) {
m_sel.erase(m_sel.cbegin() + index);
content_action_internal(CA::erase, index, 1);
} else {
++index;
}
}
break;
} // switch (action)
// Post action
switch (action) {
case CA::erase:
case CA::erase_selected:
// Let cursor clamp to new bounds
set_cursor(m_cursor.col, m_cursor.row);
adjust_view();
break;
default:
break;
}
enqueue_actions(
UI::UpdateActions::render |
clear_flag
);
}
command(TableUI *tui, int cmd) {
switch (cmd) {
case CmdClearFile: clear_file(tui); break;
case CmdOpenFile:
clear_and_open(tui, tui->filename);
if (row_count(tui->table) < MAX_ROWS_FOR_FIT
&& max_col_count(tui->table) < MAX_COLS_FOR_FIT) {
unsigned i;
for (i = 0; i < max_col_count(tui->table); i++)
auto_resize_col(tui, i);
}
break;
case CmdSaveFile: save_csv(tui, tui->filename); break;
case CmdSetAnchor: set_anchor(tui); break;
case CmdClearAnchor: clear_anchor(tui); break;
case CmdClearRow: clear_selected_rows(tui); break;
case CmdDeleteRow: delete_selected_rows(tui); break;
case CmdDeleteCell: delete_selected_cells(tui); break;
case CmdClearCell: clear_selected_cells(tui); break;
case CmdCopy: copy_to_clipboard(tui); break;
case CmdCutClear: copy_to_clipboard(tui); clear_selected_cells(tui); break;
case CmdCutDelete: copy_to_clipboard(tui); delete_selected_cells(tui); break;
case CmdPaste: clear_anchor(tui); paste_clipboard(tui); break;
case CmdReturn: clear_anchor(tui); move_cursor(tui, 1, 0); break;
case CmdTab: clear_anchor(tui); move_cursor(tui, 0, 1); break;
case CmdUnReturn: clear_anchor(tui); move_cursor(tui, -1, 0); break;
case CmdUnTab: clear_anchor(tui); move_cursor(tui, 0, -1); break;
case CmdEditCell: start_edit(tui, 1); break;
case CmdEditCellClear: start_edit(tui, 0); break;
case CmdCommitEdit: end_edit(tui); break;
case CmdCancelEdit: cancel_edit(tui); break;
case CmdMoveUp: move_cursor(tui, -1, 0); break;
case CmdMoveDown: move_cursor(tui, 1, 0); break;
case CmdMoveLeft: move_cursor(tui, 0, -1); break;
case CmdMoveRight: move_cursor(tui, 0, 1); break;
case CmdScrollUp: scroll(tui, -1, 0); break;
case CmdScrollDown: scroll(tui, 1, 0); break;
case CmdScrollLeft: scroll(tui, 0, -1); break;
case CmdScrollRight: scroll(tui, 0, 1); break;
case CmdHomeCol: jump_cursor(tui, 0, tui->cur_col); break;
case CmdHomeRow: jump_cursor(tui, tui->cur_row, 0); break;
case CmdEndCol: jump_cursor(tui, row_count(tui->table) - 1, tui->cur_col); break;
case CmdEndRow: jump_cursor(tui, tui->cur_row, col_count(tui->table, tui->cur_row) - 1); break;
case CmdInsertDate: insert_datetime(tui, 0); break;
case CmdInsertDateTime: insert_datetime(tui, 1); break;
case CmdInsertCell:
insert_cells(tui->table, tui->cur_row, tui->cur_col, 1);
redraw_rows(tui, tui->cur_row, tui->cur_row);
break;
case CmdInsertRow:
insert_rows(tui->table, tui->cur_row, 1);
redraw_rows(tui, tui->cur_row, -1);
break;
case CmdFindColumn:
find_cell_text_col(tui, tui->cur_row, tui->cur_col, tui->find_text);
break;
case CmdFindRow:
find_cell_text_row(tui, tui->cur_row, tui->cur_col, tui->find_text);
break;
}
}
}
void push_back( raw_vector & r ) {
m_data.push_back( r );
}
size_t hard_block_count() const {
return m_bpr;
}
size_t size() const {
return m_columns * m_rows;
}
raw_block_pointer begin_row( size_t idx ) const {
ASSERT_VALID_RANGE( idx, 0, row_count() )
return m_data[ idx ].get();
}
raw_block_pointer end_row( size_t idx ) const {
ASSERT_VALID_RANGE( idx, 0, row_count() )
return m_data[idx].get() + m_data[idx].m_size;
}
raw_block_pointer begin_block_row( size_t idx ) const {
return begin_row( idx );
}
raw_block_pointer end_block_row( size_t idx ) const {
return end_row(idx);
raw_block_pointer end_row( size_t idx ) const {
ASSERT_VALID_RANGE( idx, 0, row_count() );
return m_data + block_row_offset( idx + alignment_type::GROUP_SIZE, m_bpr );
}
