void ConvergenceTable::save(const char* filename) const
{
if (num_columns() == 0) throw Hermes::Exceptions::Exception("No data columns defined.");
for (unsigned int i = 1; i < num_columns(); i++)
if (columns[i].data.size() != num_rows())
throw Hermes::Exceptions::Exception("Incompatible column sizes.");
FILE* f = fopen(filename, "w");
if (f == NULL) throw Hermes::Exceptions::Exception("Error writing to %s.", filename);
for (unsigned int i = 0; i < num_columns(); i++)
fprintf(f, columns[i].label.c_str());
fprintf(f, "\n");
for (int j = 0; j < num_rows(); j++)
{
for (unsigned int i = 0; i < num_columns(); i++)
{
if (columns[i].data[j].data_type == Column::Entry::INT)
fprintf(f, columns[i].format.c_str(), columns[i].data[j].ivalue);
else if (columns[i].data[j].data_type == Column::Entry::DOUBLE)
fprintf(f, columns[i].format.c_str(), columns[i].data[j].dvalue);
}
fprintf(f, "\n");
}
fclose(f);
Hermes::Mixins::Loggable::Static::info("Convergence table saved to file '%s'.", filename);
}
void operator() (const m_type& u, m_type& f)
{
for (int r= 0; r < num_rows(u); r++)
for (int c= 0; c < num_columns(u); c++) {
f(r, c)= 4 * u(r, c);
if (r > 0) f(r, c)-= u(r-1, c);
if (r < num_rows(u)-1) f(r, c)-= u(r+1, c);
if (c > 0) f(r, c)-= u(r, c-1);
if (c < num_columns(u)-1) f(r, c)-= u(r, c+1);
}
}
void ColumnSet::LinkColumnSizes(int first, ...)
{
va_list marker;
va_start(marker, first);
DCHECK(first>=0 && first<num_columns());
for(int last=first,next=va_arg(marker, int); next!=-1;
next=va_arg(marker, int))
{
DCHECK(next>=0 && next<num_columns());
columns_[last]->same_size_column_ = next;
last = next;
}
va_end(marker);
}
inline void _debug_check_consistency(std::set<const node_info*>& seen) const {
if(seen.count(this))
return;
seen.insert(this);
DASSERT_TRUE(pnode->operator_type == type);
DASSERT_EQ(pnode->inputs.size(), inputs.size());
DASSERT_TRUE(is_source_node() || !inputs.empty());
if(attributes.num_inputs != -1)
DASSERT_EQ(inputs.size(), attributes.num_inputs);
DASSERT_EQ(num_columns(), infer_planner_node_num_output_columns(pnode));
{
// Make sure that all inputs and outputs are consistent.
std::map<const node_info*, size_t> input_counts;
for(size_t i = 0; i < inputs.size(); ++i)
input_counts[inputs[i].get()] += 1;
for(size_t i = 0; i < inputs.size(); ++i) {
DASSERT_TRUE(pnode->inputs[i] == inputs[i]->pnode);
size_t n_present = 0;
for(const cnode_info_ptr& out : inputs[i]->outputs) {
if(out.get() == this)
++n_present;
}
DASSERT_EQ(n_present, input_counts.at(inputs[i].get()));
}
}
{
// Make sure that all inputs and outputs are consistent.
std::map<const node_info*, size_t> output_counts;
for(size_t i = 0; i < outputs.size(); ++i)
output_counts[outputs[i].get()] += 1;
for(size_t i = 0; i < outputs.size(); ++i) {
size_t n_present = 0;
for(const cnode_info_ptr& out : outputs[i]->inputs) {
if(out.get() == this)
++n_present;
}
DASSERT_EQ(n_present, output_counts.at(outputs[i].get()));
}
}
for(size_t i = 0; i < outputs.size(); ++i) {
outputs[i]->_debug_check_consistency(seen);
}
for(size_t i = 0; i < inputs.size(); ++i) {
inputs[i]->_debug_check_consistency(seen);
}
}
static void apply(matrix_expression<MatrixExprT> const& me, UnaryFunctorT f)
{
typedef typename matrix_traits<MatrixExprT>::size_type size_type;
size_type nr = num_rows(me);
size_type nc = num_columns(me);
for (size_type r = 0; r < nr; ++r)
{
for (size_type c = 0; c < nc; ++c)
{
f(me()(r,c));
}
}
}
flwor_clause* orderby_clause::clone(
user_function* udf,
expr::substitution_t& subst) const
{
csize numColumns = num_columns();
std::vector<expr*> cloneExprs(numColumns);
for (csize i = 0; i < numColumns; ++i)
{
cloneExprs[i] = theOrderingExprs[i]->clone(udf, subst);
}
return theCCB->theEM->create_orderby_clause(theContext,
get_loc(),
theStableOrder,
theModifiers,
cloneExprs);
}
void test_table() {
// Create a database with the default options.
auto db = grnxx::open_db("");
// Create a table named "Table".
auto table = db->create_table("Table");
assert(table->db() == db.get());
assert(table->name() == "Table");
assert(table->num_columns() == 0);
assert(!table->key_column());
assert(table->num_rows() == 0);
assert(table->max_row_id().is_na());
assert(table->is_empty());
assert(table->is_full());
// Create a column named "Column_1".
auto column = table->create_column("Column_1", GRNXX_BOOL);
assert(column->name() == "Column_1");
assert(table->num_columns() == 1);
assert(table->get_column(0) == column);
assert(table->find_column("Column_1") == column);
// The following create_column() must fail because "Column_1" already exists.
try {
table->create_column("Column_1", GRNXX_BOOL);
assert(false);
} catch (...) {
}
// Create columns named "Column_2" and Column_3".
table->create_column("Column_2", GRNXX_BOOL);
table->create_column("Column_3", GRNXX_BOOL);
assert(table->num_columns() == 3);
// Remove "Column_2".
table->remove_column("Column_2");
assert(table->num_columns() == 2);
assert(table->get_column(0)->name() == "Column_1");
assert(table->get_column(1)->name() == "Column_3");
// Recreate "Column_2".
table->create_column("Column_2", GRNXX_BOOL);
// Move "Column_3" to the next to "Column_2".
table->reorder_column("Column_3", "Column_2");
assert(table->get_column(0)->name() == "Column_1");
assert(table->get_column(1)->name() == "Column_2");
assert(table->get_column(2)->name() == "Column_3");
// Move "Column_3" to the head.
table->reorder_column("Column_3", "");
assert(table->get_column(0)->name() == "Column_3");
assert(table->get_column(1)->name() == "Column_1");
assert(table->get_column(2)->name() == "Column_2");
// Move "Column_2" to the next to "Column3".
table->reorder_column("Column_2", "Column_3");
assert(table->get_column(0)->name() == "Column_3");
assert(table->get_column(1)->name() == "Column_2");
assert(table->get_column(2)->name() == "Column_1");
}
static std::ptrdiff_t storage_size (matrix_type& sm) {
return num_rows (sm) * num_columns (sm);
}
