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