int main() { { typedef std::pair<const int, double> V; V ar[] = { V(1, 1), V(1, 1.5), V(1, 2), V(2, 1), V(2, 1.5), V(2, 2), V(3, 1), V(3, 1.5), V(3, 2), }; typedef test_compare<std::less<int> > C; typedef test_allocator<V> A; std::multimap<int, double, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(7)); assert(m.get_allocator() == A(7)); assert(m.key_comp() == C(5)); assert(m.size() == 9); assert(distance(m.begin(), m.end()) == 9); assert(*m.begin() == V(1, 1)); assert(*next(m.begin()) == V(1, 1.5)); assert(*next(m.begin(), 2) == V(1, 2)); assert(*next(m.begin(), 3) == V(2, 1)); assert(*next(m.begin(), 4) == V(2, 1.5)); assert(*next(m.begin(), 5) == V(2, 2)); assert(*next(m.begin(), 6) == V(3, 1)); assert(*next(m.begin(), 7) == V(3, 1.5)); assert(*next(m.begin(), 8) == V(3, 2)); } #if __cplusplus >= 201103L { typedef std::pair<const int, double> V; V ar[] = { V(1, 1), V(1, 1.5), V(1, 2), V(2, 1), V(2, 1.5), V(2, 2), V(3, 1), V(3, 1.5), V(3, 2), }; typedef test_compare<std::less<int> > C; typedef min_allocator<V> A; std::multimap<int, double, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A()); assert(m.get_allocator() == A()); assert(m.key_comp() == C(5)); assert(m.size() == 9); assert(distance(m.begin(), m.end()) == 9); assert(*m.begin() == V(1, 1)); assert(*next(m.begin()) == V(1, 1.5)); assert(*next(m.begin(), 2) == V(1, 2)); assert(*next(m.begin(), 3) == V(2, 1)); assert(*next(m.begin(), 4) == V(2, 1.5)); assert(*next(m.begin(), 5) == V(2, 2)); assert(*next(m.begin(), 6) == V(3, 1)); assert(*next(m.begin(), 7) == V(3, 1.5)); assert(*next(m.begin(), 8) == V(3, 2)); } #endif }
void send(Recver const& recver, Match type, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5) { message m(to_match(type)); m << a1 << a2 << a3 << a4 << a5; send_impl(get_actor_ref(), recver, m); }
int main() { { typedef std::multiset<int> M; typedef int V; typedef M::size_type I; V ar[] = { 3, 3, 3, 5, 5, 5, 7, 7, 7 }; M m(ar, ar + sizeof(ar)/sizeof(ar[0])); assert(m.size() == 9); I i = m.erase(6); assert(m.size() == 9); assert(i == 0); assert(*next(m.begin(), 0) == 3); assert(*next(m.begin(), 1) == 3); assert(*next(m.begin(), 2) == 3); assert(*next(m.begin(), 3) == 5); assert(*next(m.begin(), 4) == 5); assert(*next(m.begin(), 5) == 5); assert(*next(m.begin(), 6) == 7); assert(*next(m.begin(), 7) == 7); assert(*next(m.begin(), 8) == 7); i = m.erase(5); assert(m.size() == 6); assert(i == 3); assert(*next(m.begin(), 0) == 3); assert(*next(m.begin(), 1) == 3); assert(*next(m.begin(), 2) == 3); assert(*next(m.begin(), 3) == 7); assert(*next(m.begin(), 4) == 7); assert(*next(m.begin(), 5) == 7); i = m.erase(3); assert(m.size() == 3); assert(i == 3); assert(*next(m.begin(), 0) == 7); assert(*next(m.begin(), 1) == 7); assert(*next(m.begin(), 2) == 7); i = m.erase(7); assert(m.size() == 0); assert(i == 3); } #if __cplusplus >= 201103L { typedef std::multiset<int, std::less<int>, min_allocator<int>> M; typedef int V; typedef M::size_type I; V ar[] = { 3, 3, 3, 5, 5, 5, 7, 7, 7 }; M m(ar, ar + sizeof(ar)/sizeof(ar[0])); assert(m.size() == 9); I i = m.erase(6); assert(m.size() == 9); assert(i == 0); assert(*next(m.begin(), 0) == 3); assert(*next(m.begin(), 1) == 3); assert(*next(m.begin(), 2) == 3); assert(*next(m.begin(), 3) == 5); assert(*next(m.begin(), 4) == 5); assert(*next(m.begin(), 5) == 5); assert(*next(m.begin(), 6) == 7); assert(*next(m.begin(), 7) == 7); assert(*next(m.begin(), 8) == 7); i = m.erase(5); assert(m.size() == 6); assert(i == 3); assert(*next(m.begin(), 0) == 3); assert(*next(m.begin(), 1) == 3); assert(*next(m.begin(), 2) == 3); assert(*next(m.begin(), 3) == 7); assert(*next(m.begin(), 4) == 7); assert(*next(m.begin(), 5) == 7); i = m.erase(3); assert(m.size() == 3); assert(i == 3); assert(*next(m.begin(), 0) == 7); assert(*next(m.begin(), 1) == 7); assert(*next(m.begin(), 2) == 7); i = m.erase(7); assert(m.size() == 0); assert(i == 3); } #endif }
bool app_init_and_loop(int& argc, char**& argv) { // glib needs this for command line args. It will be reset by Gtk::Main later. // This aborts on freebsd with "locale::facet::_S_create_c_locale name not valid", // so use the C equivalent. // std::locale::global(std::locale("")); // set locale to system LANG std::setlocale(LC_ALL, ""); // initialize GThread (for mutexes, etc... to work). Must be called before any other glib function. Glib::thread_init(); // parse command line args CmdArgs args; if (! parse_cmdline_args(args, argc, argv)) { return true; } // Note: parsing gtk option context is initializes gtk, so // gtk_disable_setlocale() won't work here. if (!args.arg_locale) { std::setlocale(LC_ALL, "C"); // set classic locale. otherwise we're already in user locale. } if (args.arg_version) { // show version information and exit app_print_version_info(); return true; } // register libdebug domains debug_register_domain("gtk"); debug_register_domain("app"); debug_register_domain("hz"); debug_register_domain("rmn"); debug_register_domain("rconfig"); // Add special debug channel to collect all libdebug output into a buffer. debug_add_channel("all", debug_level::all, app_get_debug_buf_channel()); std::vector<std::string> load_virtuals; if (args.arg_add_virtual) { const gchar* entry = 0; while ( (entry = *(args.arg_add_virtual)++) != NULL ) { load_virtuals.push_back(entry); } } std::string load_virtuals_str = hz::string_join(load_virtuals, ", "); // for display purposes only std::vector<std::string> load_devices; if (args.arg_add_device) { const gchar* entry = 0; while ( (entry = *(args.arg_add_device)++) != NULL ) { load_devices.push_back(entry); } } std::string load_devices_str = hz::string_join(load_devices, ", "); // for display purposes only // it's here because earlier there are no domains debug_out_dump("app", "Application options:\n" << "\tlocale: " << args.arg_locale << "\n" << "\tversion: " << args.arg_version << "\n" << "\thide_tabs: " << args.arg_hide_tabs << "\n" << "\tscan: " << args.arg_scan << "\n" << "\targ_add_virtual: " << (load_virtuals_str.empty() ? "[empty]" : load_virtuals_str) << "\n" << "\targ_add_device: " << (load_devices_str.empty() ? "[empty]" : load_devices_str) << "\n"); debug_out_dump("app", "LibDebug options:\n" << debug_get_cmd_args_dump()); // Load config files app_init_config(); debug_out_info("app", "Current locale: " << std::setlocale(LC_ALL, NULL) << "\n"); // Initialize GTK+ // Gtk::Main m(argc, argv, args.arg_locale); Gtk::Main m(argc, argv); #ifdef _WIN32 // Now that all program-specific locale setup has been performed, // make sure the future locale changes affect only current thread. // Not available on mingw, so disable for now. // _configthreadlocale(_ENABLE_PER_THREAD_LOCALE); #endif // Redirect all GTK+/Glib and related messages to libdebug static const char* const gtkdomains[] = { // no atk or cairo, they don't log. libgnomevfs may be loaded by gtk file chooser. "GLib", "GModule", "GLib-GObject", "GLib-GRegex", "GLib-GIO", "GThread", "Pango", "Gtk", "Gdk", "GdkPixbuf", "libglade", "libgnomevfs", "glibmm", "giomm", "atkmm", "pangomm", "gdkmm", "gtkmm", "libglademm" }; for (unsigned int i = 0; i < G_N_ELEMENTS(gtkdomains); ++i) { g_log_set_handler(gtkdomains[i], GLogLevelFlags(G_LOG_LEVEL_MASK | G_LOG_FLAG_FATAL | G_LOG_FLAG_RECURSION), glib_message_handler, NULL); } // This shows up in About dialog gtk. Glib::set_application_name("GSmartControl"); // should be localized // Add data file search paths #ifdef _WIN32 hz::data_file_add_search_directory("."); // the program is bundled with all the files in the same directory #else #ifdef DEBUG_BUILD hz::data_file_add_search_directory(std::string(TOP_SRC_DIR) + "/src/res"); // application data resources hz::data_file_add_search_directory(std::string(TOP_SRC_DIR) + "/data"); // application data resources #else hz::data_file_add_search_directory(PACKAGE_PKGDATA_DIR); // /usr/share/program_name #endif #endif // set default icon for all windows. // set_default_icon_name is available since 2.12 in gtkmm, but since 2.6 in gtk. #ifndef _WIN32 // win32 version has its icon compiled-in. { // we load it via icontheme to provide multi-size version. GtkIconTheme* default_icon_theme = gtk_icon_theme_get_default(); // application-installed, /usr/share/icons/<theme_name>/apps/<size> if (gtk_icon_theme_has_icon(default_icon_theme, "gsmartcontrol")) { gtk_window_set_default_icon_name("gsmartcontrol"); // try the gnome icon, it's higher quality / resolution } else if (gtk_icon_theme_has_icon(default_icon_theme, "gnome-dev-harddisk")) { gtk_window_set_default_icon_name("gnome-dev-harddisk"); // gtk built-in, always available } else { gtk_window_set_default_icon_name("gtk-harddisk"); } } #endif // Export some command line arguments to rmn // obey the command line option for no-scan on startup rconfig::set_data("/runtime/gui/force_no_scan_on_startup", !bool(args.arg_scan)); // load virtual drives on startup if specified. rconfig::set_data("/runtime/gui/add_virtuals_on_startup", load_virtuals); // add devices to the list on startup if specified. rconfig::set_data("/runtime/gui/add_devices_on_startup", load_devices); // hide tabs if SMART is disabled rconfig::set_data("/runtime/gui/hide_tabs_on_smart_disabled", bool(args.arg_hide_tabs)); // Create executor log window, but don't show it. // It will track all command executor outputs. GscExecutorLogWindow::create(); // Open the main window GscMainWindow* win = GscMainWindow::create(); if (!win) { debug_out_fatal("app", "Cannot create the main window. Exiting.\n"); return false; // cannot create main window } // first-boot message app_show_first_boot_message(win); // The Main Loop (tm) debug_out_info("app", "Entering main loop.\n"); m.run(); debug_out_info("app", "Main loop exited.\n"); // close the main window and delete its object GscMainWindow::destroy(); GscExecutorLogWindow::destroy(); // std::cerr << app_get_debug_buffer_str(); // this will output everything that went through libdebug. return true; }
void send(Recver const& recver, Match type) { message m(to_match(type)); send_impl(get_actor_ref(), recver, m); }
TEST(Mat44Test, ElementMultiplication) { simphys::mat44 m{0,1,2,3, 4,5,6,7, 8,9,10,11, 12,13,14,15}; m.transpose(); m(2,1) *= 5; EXPECT_FLOAT_EQ( m(0,0), 0); EXPECT_FLOAT_EQ( m(0,1), 4); EXPECT_FLOAT_EQ( m(0,2), 8); EXPECT_FLOAT_EQ( m(0,3), 12); EXPECT_FLOAT_EQ( m(1,0), 1); EXPECT_FLOAT_EQ( m(1,1), 5); EXPECT_FLOAT_EQ( m(1,2), 9); EXPECT_FLOAT_EQ( m(1,3), 13); EXPECT_FLOAT_EQ( m(2,0), 2); EXPECT_FLOAT_EQ( m(2,1), 30); EXPECT_FLOAT_EQ( m(2,2), 10); EXPECT_FLOAT_EQ( m(2,3), 14); EXPECT_FLOAT_EQ( m(3,0), 3); EXPECT_FLOAT_EQ( m(3,1), 7); EXPECT_FLOAT_EQ( m(3,2), 11); EXPECT_FLOAT_EQ( m(3,3), 15); }
void PseudoStateCanvas::menu(const QPoint&) { QPopupMenu m(0); QPopupMenu toolm(0); int index; m.insertItem(new MenuTitle(browser_node->get_data()->definition(FALSE, TRUE), m.font()), -1); m.insertSeparator(); m.insertItem(TR("Upper"), 0); m.insertItem(TR("Lower"), 1); m.insertItem(TR("Go up"), 13); m.insertItem(TR("Go down"), 14); m.insertSeparator(); switch (browser_node->get_type()) { case ForkPS: case JoinPS: m.insertItem((horiz) ? TR("draw vertically") : TR("draw horizontally"), 2); m.insertSeparator(); break; default: break; } /*m.insertItem("Edit drawing settings", 2); m.insertSeparator();*/ m.insertItem(TR("Edit pseudo state"), 3); m.insertSeparator(); m.insertItem(TR("Select in browser"), 4); if (linked()) m.insertItem(TR("Select linked items"), 5); m.insertSeparator(); /*if (browser_node->is_writable()) if (browser_node->get_associated() != (BrowserNode *) the_canvas()->browser_diagram()) m.insertItem(TR("Set associated diagram"),6); m.insertSeparator();*/ m.insertItem(TR("Remove from diagram"), 7); if (browser_node->is_writable()) m.insertItem(TR("Delete from model"), 8); m.insertSeparator(); if (Tool::menu_insert(&toolm, browser_node->get_type(), 20)) m.insertItem(TR("Tool"), &toolm); switch (index = m.exec(QCursor::pos())) { case 0: upper(); modified(); // call package_modified() return; case 1: lower(); modified(); // call package_modified() return; case 13: z_up(); modified(); // call package_modified() return; case 14: z_down(); modified(); // call package_modified() return; case 2: horiz ^= TRUE; if (!manual_size) set_xpm(); else { setSize(height(), width()); DiagramCanvas::resize(width(), height()); } modified(); // call package_modified() return; case 3: browser_node->open(TRUE); return; case 4: browser_node->select_in_browser(); return; case 5: the_canvas()->unselect_all(); select_associated(); return; case 7: //remove from diagram delete_it(); break; case 8: //delete from model browser_node->delete_it(); // will delete the canvas break; default: if (index >= 20) ToolCom::run(Tool::command(index - 20), browser_node); return; } package_modified(); }
/// \ingroup PNG_IO /// \brief Returns the width and height of the PNG file at the specified location. /// Throws std::ios_base::failure if the location does not correspond to a valid PNG file inline point2<std::ptrdiff_t> png_read_dimensions(const char *filename) { detail::png_reader m(filename); return m.get_dimensions(); }
inline void png_read_view(const char* filename,const View& view) { BOOST_STATIC_ASSERT(png_read_support<View>::is_supported); detail::png_reader m(filename); m.apply(view); }
inline void png_read_and_convert_image(const char* filename,Image& im,CC cc) { detail::png_reader_color_convert<CC> m(filename,cc); m.read_image(im); }
inline void png_read_and_convert_image(const char* filename,Image& im) { detail::png_reader_color_convert<default_color_converter> m(filename,default_color_converter()); m.read_image(im); }
inline void png_read_and_convert_view(const char* filename,const View& view) { detail::png_reader_color_convert<default_color_converter> m(filename,default_color_converter()); m.apply(view); }
inline void png_read_and_convert_view(const char* filename,const View& view,CC cc) { detail::png_reader_color_convert<CC> m(filename,cc); m.apply(view); }
inline void png_read_image(const char* filename,Image& im) { BOOST_STATIC_ASSERT(png_read_support<typename Image::view_t>::is_supported); detail::png_reader m(filename); m.read_image(im); }
template<typename SparseMatrixType> void sparse_basic(const SparseMatrixType& ref) { typedef typename SparseMatrixType::Index Index; const Index rows = ref.rows(); const Index cols = ref.cols(); typedef typename SparseMatrixType::Scalar Scalar; enum { Flags = SparseMatrixType::Flags }; double density = (std::max)(8./(rows*cols), 0.01); typedef Matrix<Scalar,Dynamic,Dynamic> DenseMatrix; typedef Matrix<Scalar,Dynamic,1> DenseVector; Scalar eps = 1e-6; SparseMatrixType m(rows, cols); DenseMatrix refMat = DenseMatrix::Zero(rows, cols); DenseVector vec1 = DenseVector::Random(rows); Scalar s1 = internal::random<Scalar>(); std::vector<Vector2i> zeroCoords; std::vector<Vector2i> nonzeroCoords; initSparse<Scalar>(density, refMat, m, 0, &zeroCoords, &nonzeroCoords); if (zeroCoords.size()==0 || nonzeroCoords.size()==0) return; // test coeff and coeffRef for (int i=0; i<(int)zeroCoords.size(); ++i) { VERIFY_IS_MUCH_SMALLER_THAN( m.coeff(zeroCoords[i].x(),zeroCoords[i].y()), eps ); if(internal::is_same<SparseMatrixType,SparseMatrix<Scalar,Flags> >::value) VERIFY_RAISES_ASSERT( m.coeffRef(zeroCoords[0].x(),zeroCoords[0].y()) = 5 ); } VERIFY_IS_APPROX(m, refMat); m.coeffRef(nonzeroCoords[0].x(), nonzeroCoords[0].y()) = Scalar(5); refMat.coeffRef(nonzeroCoords[0].x(), nonzeroCoords[0].y()) = Scalar(5); VERIFY_IS_APPROX(m, refMat); /* // test InnerIterators and Block expressions for (int t=0; t<10; ++t) { int j = internal::random<int>(0,cols-1); int i = internal::random<int>(0,rows-1); int w = internal::random<int>(1,cols-j-1); int h = internal::random<int>(1,rows-i-1); // VERIFY_IS_APPROX(m.block(i,j,h,w), refMat.block(i,j,h,w)); for(int c=0; c<w; c++) { VERIFY_IS_APPROX(m.block(i,j,h,w).col(c), refMat.block(i,j,h,w).col(c)); for(int r=0; r<h; r++) { // VERIFY_IS_APPROX(m.block(i,j,h,w).col(c).coeff(r), refMat.block(i,j,h,w).col(c).coeff(r)); } } // for(int r=0; r<h; r++) // { // VERIFY_IS_APPROX(m.block(i,j,h,w).row(r), refMat.block(i,j,h,w).row(r)); // for(int c=0; c<w; c++) // { // VERIFY_IS_APPROX(m.block(i,j,h,w).row(r).coeff(c), refMat.block(i,j,h,w).row(r).coeff(c)); // } // } } for(int c=0; c<cols; c++) { VERIFY_IS_APPROX(m.col(c) + m.col(c), (m + m).col(c)); VERIFY_IS_APPROX(m.col(c) + m.col(c), refMat.col(c) + refMat.col(c)); } for(int r=0; r<rows; r++) { VERIFY_IS_APPROX(m.row(r) + m.row(r), (m + m).row(r)); VERIFY_IS_APPROX(m.row(r) + m.row(r), refMat.row(r) + refMat.row(r)); } */ // test insert (inner random) { DenseMatrix m1(rows,cols); m1.setZero(); SparseMatrixType m2(rows,cols); if(internal::random<int>()%2) m2.reserve(VectorXi::Constant(m2.outerSize(), 2)); for (int j=0; j<cols; ++j) { for (int k=0; k<rows/2; ++k) { int i = internal::random<int>(0,rows-1); if (m1.coeff(i,j)==Scalar(0)) m2.insert(i,j) = m1(i,j) = internal::random<Scalar>(); } } m2.finalize(); VERIFY_IS_APPROX(m2,m1); } // test insert (fully random) { DenseMatrix m1(rows,cols); m1.setZero(); SparseMatrixType m2(rows,cols); if(internal::random<int>()%2) m2.reserve(VectorXi::Constant(m2.outerSize(), 2)); for (int k=0; k<rows*cols; ++k) { int i = internal::random<int>(0,rows-1); int j = internal::random<int>(0,cols-1); if ((m1.coeff(i,j)==Scalar(0)) && (internal::random<int>()%2)) m2.insert(i,j) = m1(i,j) = internal::random<Scalar>(); else { Scalar v = internal::random<Scalar>(); m2.coeffRef(i,j) += v; m1(i,j) += v; } } VERIFY_IS_APPROX(m2,m1); } // test insert (un-compressed) for(int mode=0;mode<4;++mode) { DenseMatrix m1(rows,cols); m1.setZero(); SparseMatrixType m2(rows,cols); VectorXi r(VectorXi::Constant(m2.outerSize(), ((mode%2)==0) ? m2.innerSize() : std::max<int>(1,m2.innerSize()/8))); m2.reserve(r); for (int k=0; k<rows*cols; ++k) { int i = internal::random<int>(0,rows-1); int j = internal::random<int>(0,cols-1); if (m1.coeff(i,j)==Scalar(0)) m2.insert(i,j) = m1(i,j) = internal::random<Scalar>(); if(mode==3) m2.reserve(r); } if(internal::random<int>()%2) m2.makeCompressed(); VERIFY_IS_APPROX(m2,m1); } // test basic computations { DenseMatrix refM1 = DenseMatrix::Zero(rows, rows); DenseMatrix refM2 = DenseMatrix::Zero(rows, rows); DenseMatrix refM3 = DenseMatrix::Zero(rows, rows); DenseMatrix refM4 = DenseMatrix::Zero(rows, rows); SparseMatrixType m1(rows, rows); SparseMatrixType m2(rows, rows); SparseMatrixType m3(rows, rows); SparseMatrixType m4(rows, rows); initSparse<Scalar>(density, refM1, m1); initSparse<Scalar>(density, refM2, m2); initSparse<Scalar>(density, refM3, m3); initSparse<Scalar>(density, refM4, m4); VERIFY_IS_APPROX(m1+m2, refM1+refM2); VERIFY_IS_APPROX(m1+m2+m3, refM1+refM2+refM3); VERIFY_IS_APPROX(m3.cwiseProduct(m1+m2), refM3.cwiseProduct(refM1+refM2)); VERIFY_IS_APPROX(m1*s1-m2, refM1*s1-refM2); VERIFY_IS_APPROX(m1*=s1, refM1*=s1); VERIFY_IS_APPROX(m1/=s1, refM1/=s1); VERIFY_IS_APPROX(m1+=m2, refM1+=refM2); VERIFY_IS_APPROX(m1-=m2, refM1-=refM2); if(SparseMatrixType::IsRowMajor) VERIFY_IS_APPROX(m1.innerVector(0).dot(refM2.row(0)), refM1.row(0).dot(refM2.row(0))); else VERIFY_IS_APPROX(m1.innerVector(0).dot(refM2.row(0)), refM1.col(0).dot(refM2.row(0))); VERIFY_IS_APPROX(m1.conjugate(), refM1.conjugate()); VERIFY_IS_APPROX(m1.real(), refM1.real()); refM4.setRandom(); // sparse cwise* dense VERIFY_IS_APPROX(m3.cwiseProduct(refM4), refM3.cwiseProduct(refM4)); // VERIFY_IS_APPROX(m3.cwise()/refM4, refM3.cwise()/refM4); } // test transpose { DenseMatrix refMat2 = DenseMatrix::Zero(rows, rows); SparseMatrixType m2(rows, rows); initSparse<Scalar>(density, refMat2, m2); VERIFY_IS_APPROX(m2.transpose().eval(), refMat2.transpose().eval()); VERIFY_IS_APPROX(m2.transpose(), refMat2.transpose()); VERIFY_IS_APPROX(SparseMatrixType(m2.adjoint()), refMat2.adjoint()); } // test innerVector() { DenseMatrix refMat2 = DenseMatrix::Zero(rows, rows); SparseMatrixType m2(rows, rows); initSparse<Scalar>(density, refMat2, m2); int j0 = internal::random<int>(0,rows-1); int j1 = internal::random<int>(0,rows-1); if(SparseMatrixType::IsRowMajor) VERIFY_IS_APPROX(m2.innerVector(j0), refMat2.row(j0)); else VERIFY_IS_APPROX(m2.innerVector(j0), refMat2.col(j0)); if(SparseMatrixType::IsRowMajor) VERIFY_IS_APPROX(m2.innerVector(j0)+m2.innerVector(j1), refMat2.row(j0)+refMat2.row(j1)); else VERIFY_IS_APPROX(m2.innerVector(j0)+m2.innerVector(j1), refMat2.col(j0)+refMat2.col(j1)); SparseMatrixType m3(rows,rows); m3.reserve(VectorXi::Constant(rows,rows/2)); for(int j=0; j<rows; ++j) for(int k=0; k<j; ++k) m3.insertByOuterInner(j,k) = k+1; for(int j=0; j<rows; ++j) { VERIFY(j==internal::real(m3.innerVector(j).nonZeros())); if(j>0) VERIFY(j==internal::real(m3.innerVector(j).lastCoeff())); } m3.makeCompressed(); for(int j=0; j<rows; ++j) { VERIFY(j==internal::real(m3.innerVector(j).nonZeros())); if(j>0) VERIFY(j==internal::real(m3.innerVector(j).lastCoeff())); } //m2.innerVector(j0) = 2*m2.innerVector(j1); //refMat2.col(j0) = 2*refMat2.col(j1); //VERIFY_IS_APPROX(m2, refMat2); } // test innerVectors() { DenseMatrix refMat2 = DenseMatrix::Zero(rows, rows); SparseMatrixType m2(rows, rows); initSparse<Scalar>(density, refMat2, m2); int j0 = internal::random<int>(0,rows-2); int j1 = internal::random<int>(0,rows-2); int n0 = internal::random<int>(1,rows-(std::max)(j0,j1)); if(SparseMatrixType::IsRowMajor) VERIFY_IS_APPROX(m2.innerVectors(j0,n0), refMat2.block(j0,0,n0,cols)); else VERIFY_IS_APPROX(m2.innerVectors(j0,n0), refMat2.block(0,j0,rows,n0)); if(SparseMatrixType::IsRowMajor) VERIFY_IS_APPROX(m2.innerVectors(j0,n0)+m2.innerVectors(j1,n0), refMat2.block(j0,0,n0,cols)+refMat2.block(j1,0,n0,cols)); else VERIFY_IS_APPROX(m2.innerVectors(j0,n0)+m2.innerVectors(j1,n0), refMat2.block(0,j0,rows,n0)+refMat2.block(0,j1,rows,n0)); //m2.innerVectors(j0,n0) = m2.innerVectors(j0,n0) + m2.innerVectors(j1,n0); //refMat2.block(0,j0,rows,n0) = refMat2.block(0,j0,rows,n0) + refMat2.block(0,j1,rows,n0); } // test prune { SparseMatrixType m2(rows, rows); DenseMatrix refM2(rows, rows); refM2.setZero(); int countFalseNonZero = 0; int countTrueNonZero = 0; for (int j=0; j<m2.outerSize(); ++j) { m2.startVec(j); for (int i=0; i<m2.innerSize(); ++i) { float x = internal::random<float>(0,1); if (x<0.1) { // do nothing } else if (x<0.5) { countFalseNonZero++; m2.insertBackByOuterInner(j,i) = Scalar(0); } else { countTrueNonZero++; m2.insertBackByOuterInner(j,i) = Scalar(1); if(SparseMatrixType::IsRowMajor) refM2(j,i) = Scalar(1); else refM2(i,j) = Scalar(1); } } } m2.finalize(); VERIFY(countFalseNonZero+countTrueNonZero == m2.nonZeros()); VERIFY_IS_APPROX(m2, refM2); m2.prune(Scalar(1)); VERIFY(countTrueNonZero==m2.nonZeros()); VERIFY_IS_APPROX(m2, refM2); } // test setFromTriplets { typedef Triplet<Scalar,Index> TripletType; std::vector<TripletType> triplets; int ntriplets = rows*cols; triplets.reserve(ntriplets); DenseMatrix refMat(rows,cols); refMat.setZero(); for(int i=0;i<ntriplets;++i) { int r = internal::random<int>(0,rows-1); int c = internal::random<int>(0,cols-1); Scalar v = internal::random<Scalar>(); triplets.push_back(TripletType(r,c,v)); refMat(r,c) += v; } SparseMatrixType m(rows,cols); m.setFromTriplets(triplets.begin(), triplets.end()); VERIFY_IS_APPROX(m, refMat); } // test triangularView { DenseMatrix refMat2(rows, rows), refMat3(rows, rows); SparseMatrixType m2(rows, rows), m3(rows, rows); initSparse<Scalar>(density, refMat2, m2); refMat3 = refMat2.template triangularView<Lower>(); m3 = m2.template triangularView<Lower>(); VERIFY_IS_APPROX(m3, refMat3); refMat3 = refMat2.template triangularView<Upper>(); m3 = m2.template triangularView<Upper>(); VERIFY_IS_APPROX(m3, refMat3); refMat3 = refMat2.template triangularView<UnitUpper>(); m3 = m2.template triangularView<UnitUpper>(); VERIFY_IS_APPROX(m3, refMat3); refMat3 = refMat2.template triangularView<UnitLower>(); m3 = m2.template triangularView<UnitLower>(); VERIFY_IS_APPROX(m3, refMat3); } // test selfadjointView if(!SparseMatrixType::IsRowMajor) { DenseMatrix refMat2(rows, rows), refMat3(rows, rows); SparseMatrixType m2(rows, rows), m3(rows, rows); initSparse<Scalar>(density, refMat2, m2); refMat3 = refMat2.template selfadjointView<Lower>(); m3 = m2.template selfadjointView<Lower>(); VERIFY_IS_APPROX(m3, refMat3); } // test sparseView { DenseMatrix refMat2 = DenseMatrix::Zero(rows, rows); SparseMatrixType m2(rows, rows); initSparse<Scalar>(density, refMat2, m2); VERIFY_IS_APPROX(m2.eval(), refMat2.sparseView().eval()); } // test diagonal { DenseMatrix refMat2 = DenseMatrix::Zero(rows, rows); SparseMatrixType m2(rows, rows); initSparse<Scalar>(density, refMat2, m2); VERIFY_IS_APPROX(m2.diagonal(), refMat2.diagonal().eval()); } }
bool PoroElasticity::evalInt (LocalIntegral& elmInt, const FiniteElement& fe, const TimeDomain& time, const Vec3& X) const { ElmMats& elMat = static_cast<ElmMats&>(elmInt); const PoroMaterial* pmat = dynamic_cast<const PoroMaterial*>(material); if (!pmat) { std::cerr << __FUNCTION__ << ": No material data." << std::endl; return false; } size_t i,j,k; Matrix Bmat, Cmat, CB; if (!this->formBmatrix(Bmat,fe.dNdX)) return false; SymmTensor eps(nsd), sigma(nsd); double U = 0.0; if (!material->evaluate(Cmat,sigma,U,fe,X,eps,eps,0)) return false; Vec3 permeability = pmat->getPermeability(X); double scl(sc); if (scl == 0.0) scl = sqrt(pmat->getStiffness(X)*pmat->getFluidDensity(X)*gacc/(permeability[0]*time.dt)); // Biot's coefficient double Ko = pmat->getBulkMedium(X); double Ks = pmat->getBulkSolid(X); double Kw = pmat->getBulkWater(X); double poro = pmat->getPorosity(X); double alpha = 1.0 - (Ko/Ks); // Inverse of the compressibility modulus double Minv = ((alpha - poro)/Ks) + (poro/Kw); // Integration of the stiffness matrix CB.multiply(Cmat,Bmat,false,false); CB *= -1.0 * fe.detJxW; elMat.A[uu].multiply(Bmat,CB,true,false,true); // Define the unit Voigt vector Vector m(Cmat.rows()); for (i = 1; i <= m.size(); i++) if (i <= nsd) m(i) = 1.0; // Integration of the coupling matrix Matrix Kuptmp; const size_t nstrc = nsd*(nsd+1)/2; Kuptmp.resize(fe.basis(2).size(),nstrc); for (i = 1; i <= fe.basis(2).size(); i++) for (j = 1; j <= nstrc; j++) Kuptmp(i,j) += scl*m(j)*alpha*fe.basis(2)(i)*fe.detJxW; elMat.A[up].multiply(Bmat,Kuptmp,true,true,true); // Integration of the compressibilty matrix Matrix Cpp; Cpp.resize(fe.basis(2).size(),fe.basis(2).size()); for (i = 1; i <= fe.basis(2).size(); i++) for (j = 1; j <= fe.basis(2).size(); j++) Cpp(i,j) += scl*scl*fe.basis(2)(i)*Minv*fe.basis(2)(j)*fe.detJxW; // Integration of the permeability matrix Matrix Kpp; Kpp.resize(fe.basis(2).size(),fe.basis(2).size()); for (i = 1; i <= fe.basis(2).size(); i++) for (j = 1; j <= fe.basis(2).size(); j++) for (k = 1; k <= nsd; k++) Kpp(i,j) += scl*scl*fe.grad(2)(i,k)*(permeability[k-1]/(pmat->getFluidDensity(X)*gacc))*fe.grad(2)(j,k)*fe.detJxW; elMat.A[pp] += Cpp; elMat.A[pp].add(Kpp,time.dt); size_t rAuu = elMat.A[uu].rows(); size_t rApp = elMat.A[pp].rows(); for (i = 1; i <= rApp; i++) for (j = 1; j <= rApp; j++) elMat.A[Kprev](rAuu+i,rAuu+j) += Cpp(i,j); return true; }
// 4x4 Matrix Tests TEST(Mat44Test, CheckTranspose) { simphys::mat44 m{0,1,2,3, 4,5,6,7, 8,9,10,11, 12,13,14,15}; m.transpose(); EXPECT_FLOAT_EQ( m(0,0), 0); EXPECT_FLOAT_EQ( m(0,1), 4); EXPECT_FLOAT_EQ( m(0,2), 8); EXPECT_FLOAT_EQ( m(0,3), 12); EXPECT_FLOAT_EQ( m(1,0), 1); EXPECT_FLOAT_EQ( m(1,1), 5); EXPECT_FLOAT_EQ( m(1,2), 9); EXPECT_FLOAT_EQ( m(1,3), 13); EXPECT_FLOAT_EQ( m(2,0), 2); EXPECT_FLOAT_EQ( m(2,1), 6); EXPECT_FLOAT_EQ( m(2,2), 10); EXPECT_FLOAT_EQ( m(2,3), 14); EXPECT_FLOAT_EQ( m(3,0), 3); EXPECT_FLOAT_EQ( m(3,1), 7); EXPECT_FLOAT_EQ( m(3,2), 11); EXPECT_FLOAT_EQ( m(3,3), 15); }
int CProgressbarSetup::showMenu() { CMenuWidget m(LOCALE_MAINMENU_SETTINGS, NEUTRINO_ICON_SETTINGS, width, MN_WIDGET_ID_OSDSETUP_PROGRESSBAR); m.addIntroItems(LOCALE_MISCSETTINGS_PROGRESSBAR /*, LOCALE_MISCSETTINGS_GENERAL*/); // general progress bar design CMenuOptionChooser *mc = new CMenuOptionChooser(LOCALE_MISCSETTINGS_PROGRESSBAR_DESIGN_LONG, &g_settings.progressbar_design, PROGRESSBAR_COLOR_OPTIONS + 1, PROGRESSBAR_COLOR_OPTION_COUNT - 1, true, this); mc->setHint("", LOCALE_MENU_HINT_PROGRESSBAR_COLOR); m.addItem(mc); // progress bar gradient mc = new CMenuOptionChooser(LOCALE_MISCSETTINGS_PROGRESSBAR_GRADIENT, &g_settings.progressbar_gradient, OPTIONS_OFF0_ON1_OPTIONS, OPTIONS_OFF0_ON1_OPTION_COUNT, true, this); mc->setHint("", LOCALE_MENU_HINT_PROGRESSBAR_GRADIENT); m.addItem(mc); // preview CMenuProgressbar *mb = new CMenuProgressbar(LOCALE_MISCSETTINGS_PROGRESSBAR_PREVIEW); mb->setHint("", LOCALE_MENU_HINT_PROGRESSBAR_PREVIEW); m.addItem(mb); m.addItem(new CMenuSeparator(CMenuSeparator::LINE | CMenuSeparator::STRING, LOCALE_MISCSETTINGS_PROGRESSBAR_TIMESCALE)); CMenuOptionNumberChooser *nc; nc = new CMenuOptionNumberChooser(LOCALE_MISCSETTINGS_PROGRESSBAR_TIMESCALE_RED, &g_settings.progressbar_timescale_red, true, 0, 100, this); nc->setNumericInput(true); nc->setNumberFormat("%d %%"); nc->setHint("", LOCALE_MENU_HINT_PROGRESSBAR_TIMESCALE_RED); m.addItem(nc); nc = new CMenuOptionNumberChooser(LOCALE_MISCSETTINGS_PROGRESSBAR_TIMESCALE_YELLOW, &g_settings.progressbar_timescale_yellow, true, 0, 100, this); nc->setNumericInput(true); nc->setNumberFormat("%d %%"); nc->setHint("", LOCALE_MENU_HINT_PROGRESSBAR_TIMESCALE_YELLOW); m.addItem(nc); nc = new CMenuOptionNumberChooser(LOCALE_MISCSETTINGS_PROGRESSBAR_TIMESCALE_GREEN, &g_settings.progressbar_timescale_green, true, 0, 100, this); nc->setNumericInput(true); nc->setNumberFormat("%d %%"); nc->setHint("", LOCALE_MENU_HINT_PROGRESSBAR_TIMESCALE_GREEN); m.addItem(nc); mc = new CMenuOptionChooser(LOCALE_MISCSETTINGS_PROGRESSBAR_TIMESCALE_INVERT, &g_settings.progressbar_timescale_invert, PROGRESSBAR_TIMESCALE_INVERT_OPTIONS, PROGRESSBAR_TIMESCALE_INVERT_OPTION_COUNT, true, this); mc->setHint("", LOCALE_MENU_HINT_PROGRESSBAR_TIMESCALE_INVERT); m.addItem(mc); mb = new CMenuProgressbar(LOCALE_MISCSETTINGS_PROGRESSBAR_PREVIEW); mb->setHint("", LOCALE_MENU_HINT_PROGRESSBAR_PREVIEW); mb->getScale()->setType(CProgressBar::PB_TIMESCALE); m.addItem(mb); CMenuForwarder* mf = new CMenuForwarder(LOCALE_OPTIONS_DEFAULT, true, NULL, this, "reset", CRCInput::RC_red); mf->setHint("", LOCALE_OPTIONS_HINT_DEFAULT); m.addItem(mf); // extended channel list (progressbars) m.addItem(new CMenuSeparator(CMenuSeparator::LINE | CMenuSeparator::STRING, LOCALE_MAINMENU_CHANNELS)); mc = new CMenuOptionChooser(LOCALE_CHANNELLIST_EXTENDED, &g_settings.channellist_progressbar_design, PROGRESSBAR_COLOR_OPTIONS, PROGRESSBAR_COLOR_OPTION_COUNT, true, this); mc->setHint("", LOCALE_MENU_HINT_CHANNELLIST_EXTENDED); m.addItem(mc); mb = new CMenuProgressbar(LOCALE_MISCSETTINGS_PROGRESSBAR_PREVIEW); mb->setHint("", LOCALE_MENU_HINT_PROGRESSBAR_PREVIEW); mb->getScale()->setType(CProgressBar::PB_TIMESCALE); mb->getScale()->setDesign(g_settings.channellist_progressbar_design); mb->getScale()->doPaintBg(false); m.addItem(mb); return m.exec(NULL, ""); }
TEST(Mat44Test, MatrixMultiplication) { simphys::mat44 m0{0,1,2,3, 4,5,6,7, 8,9,10,11, 12,13,14,15}; simphys::mat44 m1{15,14,13,12, 11,10,9,8, 7,6,5,4, 3,2,1,0}; simphys::mat44 m=m0*m1; EXPECT_FLOAT_EQ( m(0,0), 34); EXPECT_FLOAT_EQ( m(0,1), 28); EXPECT_FLOAT_EQ( m(0,2), 22); EXPECT_FLOAT_EQ( m(0,3), 16); EXPECT_FLOAT_EQ( m(1,0), 178); EXPECT_FLOAT_EQ( m(1,1), 156); EXPECT_FLOAT_EQ( m(1,2), 134); EXPECT_FLOAT_EQ( m(1,3), 112); EXPECT_FLOAT_EQ( m(2,0), 322); EXPECT_FLOAT_EQ( m(2,1), 284); EXPECT_FLOAT_EQ( m(2,2), 246); EXPECT_FLOAT_EQ( m(2,3), 208); EXPECT_FLOAT_EQ( m(3,0), 466); EXPECT_FLOAT_EQ( m(3,1), 412); EXPECT_FLOAT_EQ( m(3,2), 358); EXPECT_FLOAT_EQ( m(3,3), 304); }
void ActivityObjectDialog::menu_type() { Q3PopupMenu m(0); m.insertItem(TR("Choose"), -1); m.insertSeparator(); int index = list.findIndex(edtype->currentText().stripWhiteSpace()); if (index != -1) m.insertItem(TR("Select in browser"), 0); BrowserNode * bn = 0; if (! visit) { bn = BrowserView::selected_item(); if ((bn != 0) && (bn->get_type() == UmlClass) && !bn->deletedp()) m.insertItem(TR("Choose class selected in browser"), 1); else bn = 0; m.insertItem(TR("Create class and choose it"), 2); } if (!visit || (index != -1) || (bn != 0)) { switch (m.exec(QCursor::pos())) { case 0: nodes.at(index)->select_in_browser(); break; case 2: bn = BrowserClass::add_class(FALSE, view); if (bn == 0) return; bn->select_in_browser(); // no break case 1: { QString s = bn->full_name(TRUE); if ((index = list.findIndex(s)) == -1) { // new class, may be created through an other dialog QStringList::Iterator iter = list.begin(); QStringList::Iterator iter_end = list.end(); index = 0; while ((iter != iter_end) && (*iter < s)) { ++iter; index += 1; } nodes.insert((unsigned) index, bn); list.insert(iter, s); edtype->insertItem(s, index + offset); } } edtype->setCurrentItem(index + offset); break; default: break; } } }
static void r(char * s) { if (m() > 0) setto(s); }
/** * Extracts actionable information from the request. */ bool req_parser::parse(const std::string& line) { if(parser_state == http_get) { boost::smatch matches; if(boost::regex_match(current_line, matches, http_get_expr)) { if(matches.size() == 2) { file_ = matches[1]; parser_state = headers; BOOST_LOG_TRIVIAL(debug) << "parser: header parsed sucessfully"; return true; } else { BOOST_LOG_TRIVIAL(error) << "parser error: wrong number of matches " << "for http_get_expr pattern"; return false; } } else if(boost::regex_match(current_line, empty_line_expr)) { return true; } else { BOOST_LOG_TRIVIAL(error) << "parser error: malformed http get request"; return false; } } else if(parser_state == headers) { boost::smatch matches; // Size parameter if(boost::regex_match(current_line, matches, size_header_expr)) { if(matches.size() == 2) { std::string match = matches[1]; size_ = atoi(match.c_str()); BOOST_LOG_TRIVIAL(debug) << "parser: size parsed sucessfully. value: " << size_; return true; } else { BOOST_LOG_TRIVIAL(error) << "parser error: wrong number of matches " << "for size_header_expr pattern"; return false; } } else if(boost::regex_match(current_line, matches, indices_header_expr)) { size_t hits = matches.size(); if(hits != 3) { BOOST_LOG_TRIVIAL(error) << "parser error: wrong number of matches for indices"; return false; } else { std::string m(matches[1].first, matches[1].second); std::vector<std::string> indices; boost::split(indices, m, boost::is_any_of(" ")); for(std::vector<std::string>::iterator it = indices.begin(); it < indices.end(); it++) { int a = atoi((*it).c_str()); if(*it != "" && a >= 0) { indices_.push_back(a); } else { BOOST_LOG_TRIVIAL(error) << "parser error: invalid index given"; } } std::stringstream res; for(std::vector<size_t>::iterator it = indices_.begin(); it != indices_.end(); ++it) { res << *it << " "; } BOOST_LOG_TRIVIAL(debug) << "parser: indices parsed sucessfully. values: " << res.str(); return true; } } else if(boost::regex_match(current_line, empty_line_expr)) { BOOST_LOG_TRIVIAL(debug) << "parser: sucessfully parsed empty line"; return true; } else { return false; } } else { BOOST_LOG_TRIVIAL(error) << "parser error: undefined parser state"; return false; } }
resp_t request(Recver const& recver, Match type, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5) { message m(to_match(type)); m << a1 << a2 << a3 << a4 << a5; return request_impl(get_actor_ref(), recver, m); }
int main() { { typedef std::pair<const int, double> V; V ar[] = { V(1, 1.5), V(2, 2.5), V(3, 3.5), V(4, 4.5), V(5, 5.5), V(7, 7.5), V(8, 8.5), }; std::map<int, double> m(ar, ar+sizeof(ar)/sizeof(ar[0])); assert(m.size() == 7); assert(m.at(1) == 1.5); m.at(1) = -1.5; assert(m.at(1) == -1.5); assert(m.at(2) == 2.5); assert(m.at(3) == 3.5); assert(m.at(4) == 4.5); assert(m.at(5) == 5.5); try { m.at(6); assert(false); } catch (std::out_of_range&) { } assert(m.at(7) == 7.5); assert(m.at(8) == 8.5); assert(m.size() == 7); } { typedef std::pair<const int, double> V; V ar[] = { V(1, 1.5), V(2, 2.5), V(3, 3.5), V(4, 4.5), V(5, 5.5), V(7, 7.5), V(8, 8.5), }; const std::map<int, double> m(ar, ar+sizeof(ar)/sizeof(ar[0])); assert(m.size() == 7); assert(m.at(1) == 1.5); assert(m.at(2) == 2.5); assert(m.at(3) == 3.5); assert(m.at(4) == 4.5); assert(m.at(5) == 5.5); try { m.at(6); assert(false); } catch (std::out_of_range&) { } assert(m.at(7) == 7.5); assert(m.at(8) == 8.5); assert(m.size() == 7); } }
void send(Recver const& recver, Match type, A1 const& a1, A2 const& a2) { message m(to_match(type)); m << a1 << a2; send_impl(get_actor_ref(), recver, m); }
AtomicModel& AtomicModel::operator=(const AtomicModel& mdl) { AtomicModel m(mdl); swap(m); return *this; }
resp_t request(Recver const& recver, Match type, A1 const& a1) { message m(to_match(type)); m << a1; return request_impl(get_actor_ref(), recver, m); }
void SVDLinearSolver<TMatrix,TVector>::solve(Matrix& M, Vector& x, Vector& b) { #ifdef SOFA_DUMP_VISITOR_INFO simulation::Visitor::printComment("SVD"); #endif #ifdef DISPLAY_TIME CTime * timer; double time1 = (double) timer->getTime(); #endif const bool printLog = this->f_printLog.getValue(); const bool verbose = f_verbose.getValue(); /// Convert the matrix and the right-hand vector to Eigen objects Eigen::MatrixXd m(M.rowSize(),M.colSize()); Eigen::VectorXd rhs(M.rowSize()); for(unsigned i=0; i<M.rowSize(); i++ ) { for( unsigned j=0; j<M.colSize(); j++ ) m(i,j) = M[i][j]; rhs(i) = b[i]; } if(verbose) { serr << "SVDLinearSolver<TMatrix,TVector>::solve, Here is the matrix m:" << sendl << m << sendl; } /// Compute the SVD decomposition and the condition number Eigen::JacobiSVD<Eigen::MatrixXd> svd(m, Eigen::ComputeThinU | Eigen::ComputeThinV); f_conditionNumber.setValue( (Real)(svd.singularValues()(0) / svd.singularValues()(M.rowSize()-1)) ); if(printLog) { serr << "SVDLinearSolver<TMatrix,TVector>::solve, the singular values are:" << sendl << svd.singularValues() << sendl; } if(verbose) { serr << "Its left singular vectors are the columns of the thin U matrix:" << sendl << svd.matrixU() << sendl; serr << "Its right singular vectors are the columns of the thin V matrix:" << sendl << svd.matrixV() << sendl; } /// Solve the equation system and copy the solution to the SOFA vector // Eigen::VectorXd solution = svd.solve(rhs); // for(unsigned i=0; i<M.rowSize(); i++ ){ // x[i] = solution(i); // } Eigen::VectorXd Ut_b = svd.matrixU().transpose() * rhs; Eigen::VectorXd S_Ut_b(M.colSize()); for( unsigned i=0; i<M.colSize(); i++ ) /// product with the diagonal matrix, using the threshold for near-null values { if( svd.singularValues()[i] > f_minSingularValue.getValue() ) S_Ut_b[i] = Ut_b[i]/svd.singularValues()[i]; else S_Ut_b[i] = (Real)0.0 ; } Eigen::VectorXd solution = svd.matrixV() * S_Ut_b; for(unsigned i=0; i<M.rowSize(); i++ ) { x[i] = (Real) solution(i); } if( printLog ) { #ifdef DISPLAY_TIME time1 = (double)(((double) timer->getTime() - time1) * timeStamp / (nb_iter-1)); std::cerr<<"SVDLinearSolver::solve, SVD = "<<time1<<std::endl; #endif serr << "SVDLinearSolver<TMatrix,TVector>::solve, rhs vector = " << sendl << rhs.transpose() << sendl; serr << "SVDLinearSolver<TMatrix,TVector>::solve, solution = " << sendl << x << sendl; serr << "SVDLinearSolver<TMatrix,TVector>::solve, verification, mx - b = " << sendl << (m * solution - rhs ).transpose() << sendl; } }
int main() { { typedef std::map<int, double> M; typedef std::pair<int, double> P; typedef M::iterator I; P ar[] = { P(1, 1.5), P(2, 2.5), P(3, 3.5), P(4, 4.5), P(5, 5.5), P(6, 6.5), P(7, 7.5), P(8, 8.5), }; M m(ar, ar + sizeof(ar)/sizeof(ar[0])); assert(m.size() == 8); I i = m.erase(next(m.cbegin(), 3)); assert(m.size() == 7); assert(i == next(m.begin(), 3)); assert(m.begin()->first == 1); assert(m.begin()->second == 1.5); assert(next(m.begin())->first == 2); assert(next(m.begin())->second == 2.5); assert(next(m.begin(), 2)->first == 3); assert(next(m.begin(), 2)->second == 3.5); assert(next(m.begin(), 3)->first == 5); assert(next(m.begin(), 3)->second == 5.5); assert(next(m.begin(), 4)->first == 6); assert(next(m.begin(), 4)->second == 6.5); assert(next(m.begin(), 5)->first == 7); assert(next(m.begin(), 5)->second == 7.5); assert(next(m.begin(), 6)->first == 8); assert(next(m.begin(), 6)->second == 8.5); i = m.erase(next(m.cbegin(), 0)); assert(m.size() == 6); assert(i == m.begin()); assert(m.begin()->first == 2); assert(m.begin()->second == 2.5); assert(next(m.begin())->first == 3); assert(next(m.begin())->second == 3.5); assert(next(m.begin(), 2)->first == 5); assert(next(m.begin(), 2)->second == 5.5); assert(next(m.begin(), 3)->first == 6); assert(next(m.begin(), 3)->second == 6.5); assert(next(m.begin(), 4)->first == 7); assert(next(m.begin(), 4)->second == 7.5); assert(next(m.begin(), 5)->first == 8); assert(next(m.begin(), 5)->second == 8.5); i = m.erase(next(m.cbegin(), 5)); assert(m.size() == 5); assert(i == m.end()); assert(m.begin()->first == 2); assert(m.begin()->second == 2.5); assert(next(m.begin())->first == 3); assert(next(m.begin())->second == 3.5); assert(next(m.begin(), 2)->first == 5); assert(next(m.begin(), 2)->second == 5.5); assert(next(m.begin(), 3)->first == 6); assert(next(m.begin(), 3)->second == 6.5); assert(next(m.begin(), 4)->first == 7); assert(next(m.begin(), 4)->second == 7.5); i = m.erase(next(m.cbegin(), 1)); assert(m.size() == 4); assert(i == next(m.begin())); assert(m.begin()->first == 2); assert(m.begin()->second == 2.5); assert(next(m.begin())->first == 5); assert(next(m.begin())->second == 5.5); assert(next(m.begin(), 2)->first == 6); assert(next(m.begin(), 2)->second == 6.5); assert(next(m.begin(), 3)->first == 7); assert(next(m.begin(), 3)->second == 7.5); i = m.erase(next(m.cbegin(), 2)); assert(m.size() == 3); assert(i == next(m.begin(), 2)); assert(m.begin()->first == 2); assert(m.begin()->second == 2.5); assert(next(m.begin())->first == 5); assert(next(m.begin())->second == 5.5); assert(next(m.begin(), 2)->first == 7); assert(next(m.begin(), 2)->second == 7.5); i = m.erase(next(m.cbegin(), 2)); assert(m.size() == 2); assert(i == next(m.begin(), 2)); assert(m.begin()->first == 2); assert(m.begin()->second == 2.5); assert(next(m.begin())->first == 5); assert(next(m.begin())->second == 5.5); i = m.erase(next(m.cbegin(), 0)); assert(m.size() == 1); assert(i == next(m.begin(), 0)); assert(m.begin()->first == 5); assert(m.begin()->second == 5.5); i = m.erase(m.cbegin()); assert(m.size() == 0); assert(i == m.begin()); assert(i == m.end()); } #if __cplusplus >= 201103L { typedef std::map<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> M; typedef std::pair<int, double> P; typedef M::iterator I; P ar[] = { P(1, 1.5), P(2, 2.5), P(3, 3.5), P(4, 4.5), P(5, 5.5), P(6, 6.5), P(7, 7.5), P(8, 8.5), }; M m(ar, ar + sizeof(ar)/sizeof(ar[0])); assert(m.size() == 8); I i = m.erase(next(m.cbegin(), 3)); assert(m.size() == 7); assert(i == next(m.begin(), 3)); assert(m.begin()->first == 1); assert(m.begin()->second == 1.5); assert(next(m.begin())->first == 2); assert(next(m.begin())->second == 2.5); assert(next(m.begin(), 2)->first == 3); assert(next(m.begin(), 2)->second == 3.5); assert(next(m.begin(), 3)->first == 5); assert(next(m.begin(), 3)->second == 5.5); assert(next(m.begin(), 4)->first == 6); assert(next(m.begin(), 4)->second == 6.5); assert(next(m.begin(), 5)->first == 7); assert(next(m.begin(), 5)->second == 7.5); assert(next(m.begin(), 6)->first == 8); assert(next(m.begin(), 6)->second == 8.5); i = m.erase(next(m.cbegin(), 0)); assert(m.size() == 6); assert(i == m.begin()); assert(m.begin()->first == 2); assert(m.begin()->second == 2.5); assert(next(m.begin())->first == 3); assert(next(m.begin())->second == 3.5); assert(next(m.begin(), 2)->first == 5); assert(next(m.begin(), 2)->second == 5.5); assert(next(m.begin(), 3)->first == 6); assert(next(m.begin(), 3)->second == 6.5); assert(next(m.begin(), 4)->first == 7); assert(next(m.begin(), 4)->second == 7.5); assert(next(m.begin(), 5)->first == 8); assert(next(m.begin(), 5)->second == 8.5); i = m.erase(next(m.cbegin(), 5)); assert(m.size() == 5); assert(i == m.end()); assert(m.begin()->first == 2); assert(m.begin()->second == 2.5); assert(next(m.begin())->first == 3); assert(next(m.begin())->second == 3.5); assert(next(m.begin(), 2)->first == 5); assert(next(m.begin(), 2)->second == 5.5); assert(next(m.begin(), 3)->first == 6); assert(next(m.begin(), 3)->second == 6.5); assert(next(m.begin(), 4)->first == 7); assert(next(m.begin(), 4)->second == 7.5); i = m.erase(next(m.cbegin(), 1)); assert(m.size() == 4); assert(i == next(m.begin())); assert(m.begin()->first == 2); assert(m.begin()->second == 2.5); assert(next(m.begin())->first == 5); assert(next(m.begin())->second == 5.5); assert(next(m.begin(), 2)->first == 6); assert(next(m.begin(), 2)->second == 6.5); assert(next(m.begin(), 3)->first == 7); assert(next(m.begin(), 3)->second == 7.5); i = m.erase(next(m.cbegin(), 2)); assert(m.size() == 3); assert(i == next(m.begin(), 2)); assert(m.begin()->first == 2); assert(m.begin()->second == 2.5); assert(next(m.begin())->first == 5); assert(next(m.begin())->second == 5.5); assert(next(m.begin(), 2)->first == 7); assert(next(m.begin(), 2)->second == 7.5); i = m.erase(next(m.cbegin(), 2)); assert(m.size() == 2); assert(i == next(m.begin(), 2)); assert(m.begin()->first == 2); assert(m.begin()->second == 2.5); assert(next(m.begin())->first == 5); assert(next(m.begin())->second == 5.5); i = m.erase(next(m.cbegin(), 0)); assert(m.size() == 1); assert(i == next(m.begin(), 0)); assert(m.begin()->first == 5); assert(m.begin()->second == 5.5); i = m.erase(m.cbegin()); assert(m.size() == 0); assert(i == m.begin()); assert(i == m.end()); } #endif }
int main(int argc, const char ** argv) { print_copyright(); /* GraphChi initialization will read the command line arguments and the configuration file. */ graphchi_init(argc, argv); /* Metrics object for keeping track of performance counters and other information. Currently required. */ metrics m("time-svdpp-inmemory-factors"); //specific command line parameters for time-svd++ tsp.lrate = get_option_float("lrate", tsp.lrate); tsp.beta = get_option_float("beta", tsp.beta); tsp.gamma = get_option_float("gamma", tsp.gamma); tsp.lrate_mult_dec = get_option_float("lrate_mult_dec", tsp.lrate_mult_dec); parse_command_line_args(); parse_implicit_command_line(); /* Preprocess data if needed, or discover preprocess files */ int nshards = convert_matrixmarket4<edge_data>(training, false); init_time_svdpp(); if (validation != ""){ int vshards = convert_matrixmarket4<EdgeDataType>(validation, false, M==N, VALIDATION); init_validation_rmse_engine<VertexDataType, EdgeDataType>(pvalidation_engine, vshards, &time_svdpp_predict, false, true, 1); } if (load_factors_from_file){ load_matrix_market_matrix(training + "_U.mm", 0, 4*D); load_matrix_market_matrix(training + "_V.mm", M, 2*D); load_matrix_market_matrix(training + "_T.mm", M+N, 2*D); vec user_bias = load_matrix_market_vector(training +"_U_bias.mm", false, true); vec item_bias = load_matrix_market_vector(training +"_V_bias.mm", false, true); vec time_bias = load_matrix_market_vector(training+ "_T_bias.mm", false, true); for (uint i=0; i<M+N+K; i++){ if (i < M) latent_factors_inmem[i].bias = user_bias[i]; else if (i <M+N) latent_factors_inmem[i].bias = item_bias[i-M]; else latent_factors_inmem[i].bias = time_bias[i-M-N]; } vec gm = load_matrix_market_vector(training + "_global_mean.mm", false, true); globalMean = gm[0]; } /* Run */ TIMESVDPPVerticesInMemProgram program; graphchi_engine<VertexDataType, EdgeDataType> engine(training, nshards, false, m); set_engine_flags(engine); pengine = &engine; engine.run(program, niters); /* Output test predictions in matrix-market format */ output_timesvdpp_result(training); test_predictions3(&time_svdpp_predict, 1); /* Report execution metrics */ if (!quiet) metrics_report(m); return 0; }