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); }