void FontResource::checkNotify() { ResourceClientWalker<FontResourceClient> w(m_clients); while (FontResourceClient* c = w.next()) c->fontLoaded(this); }
void Fl_Roller::draw() { if (damage()&(FL_DAMAGE_ALL|FL_DAMAGE_HIGHLIGHT)) draw_box(); int X=0; int Y=0; int W=w(); int H=h(); box()->inset(X,Y,W,H); if (W<=0 || H<=0) return; double s = step(); if (!s) s = (maximum()-minimum())/100; int offset = int(value()/s); const double ARC = 1.5; // 1/2 the number of radians visible const double delta = .2; // radians per knurl if (type()==HORIZONTAL) { // draw shaded ends of wheel: int h1 = W/4+1; // distance from end that shading starts fl_color(button_color()); fl_rectf(X+h1,Y,W-2*h1,H); for (int i=0; h1; i++) { fl_color((Fl_Color)(FL_GRAY-i-1)); int h2 = FL_GRAY-i-1 > FL_DARK3 ? 2*h1/3+1 : 0; fl_rectf(X+h2,Y,h1-h2,H); fl_rectf(X+W-h1,Y,h1-h2,H); h1 = h2; } if (active_r()) { // draw ridges: double junk; for (double y = -ARC+modf(offset*sin(ARC)/(W/2)/delta,&junk)*delta;; y += delta) { int y1 = int((sin(y)/sin(ARC)+1)*W/2); if (y1 <= 0) continue; else if (y1 >= W-1) break; fl_color(FL_DARK3); fl_line(X+y1,Y+1,X+y1,Y+H-1); if (y < 0) y1--; else y1++; fl_color(FL_LIGHT1);fl_line(X+y1,Y+1,X+y1,Y+H-1); } // draw edges: h1 = W/8+1; // distance from end the color inverts fl_color(FL_DARK2); fl_line(X+h1,Y+H-1,X+W-h1,Y+H-1); fl_color(FL_DARK3); fl_line(X,Y+H,X,Y); fl_line(X,Y,X+h1,Y); fl_line(X+W-h1,Y,X+W,Y); fl_color(FL_LIGHT2); fl_line(X+h1,Y,X+W-h1,Y); fl_line(X+W,Y,X+W,Y+H); fl_line(X+W,Y+H,X+W-h1,Y+H); fl_line(X+h1,Y+H,X,Y+H); } } // vertical one else { offset = (1-offset); // draw shaded ends of wheel: int h1 = H/4+1; // distance from end that shading starts fl_color(button_color()); fl_rectf(X,Y+h1,W,H-2*h1); for (int i=0; h1; i++) { fl_color((Fl_Color)(FL_GRAY-i-1)); int h2 = FL_GRAY-i-1 > FL_DARK3 ? 2*h1/3+1 : 0; fl_rectf(X,Y+h2,W,h1-h2); fl_rectf(X,Y+H-h1,W,h1-h2); h1 = h2; } if (active_r()) { // draw ridges: double junk; for (double y = -ARC+modf(offset*sin(ARC)/(H/2)/delta,&junk)*delta; ; y += delta) { int y1 = int((sin(y)/sin(ARC)+1)*H/2); if (y1 <= 0) continue; else if (y1 >= H-1) break; fl_color(FL_DARK3); fl_line(X+1,Y+y1,X+W-1,Y+y1); if (y < 0) y1--; else y1++; fl_color(FL_LIGHT1);fl_line(X+1,Y+y1,X+W-1,Y+y1); } // draw edges: h1 = H/8+1; // distance from end the color inverts fl_color(FL_DARK2); fl_line(X+W-1,Y+h1,X+W-1,Y+H-h1); fl_color(FL_DARK3); fl_line(X+W,Y,X,Y); fl_line(X,Y,X,Y+h1); fl_line(X,Y+H-h1,X,Y+H); fl_color(FL_LIGHT2); fl_line(X,Y+h1,X,Y+H-h1); fl_line(X,Y+H,X+W,Y+H); fl_line(X+W,Y+H,X+W,Y+H-h1); fl_line(X+W,Y+h1,X+W,Y); } } if (focused()) { focus_box()->draw(0,0,w(),h(), FL_BLACK, FL_INVISIBLE); } }
int main(int argc, char *argv[]) { qRegisterMetaType<JoyButtonSlot*>(); qRegisterMetaType<AdvanceButtonDialog*>(); //qRegisterMetaType<Joystick*>(); qRegisterMetaType<InputDevice*>(); // If running Win version, check if an explicit style // was defined on the command-line. If so, make a note // of it. #ifdef Q_OS_WIN bool styleChangeFound = false; for (int i=0; i < argc && !styleChangeFound; i++) { char *tempchrstr = argv[i]; QString temp = QString::fromUtf8(tempchrstr); if (temp == "-style") { styleChangeFound = true; } } #endif QApplication a(argc, argv); //QString defaultStyleName = qApp->style()->objectName(); // If running Win version and no explicit style was // defined, use the style Fusion by default. I find the // windowsvista style a tad ugly #ifdef Q_OS_WIN if (!styleChangeFound) { qApp->setStyle(QStyleFactory::create("Fusion")); } #endif CommandLineUtility cmdutility; QStringList cmdarguments = a.arguments(); cmdutility.parseArguments(cmdarguments); QTranslator qtTranslator; qtTranslator.load("qt_" + QLocale::system().name(), QLibraryInfo::location(QLibraryInfo::TranslationsPath)); a.installTranslator(&qtTranslator); QTranslator myappTranslator; #if defined(Q_OS_UNIX) myappTranslator.load("antimicro_" + QLocale::system().name(), QApplication::applicationDirPath().append("/../share/antimicro/translations")); #elif defined(Q_OS_WIN) myappTranslator.load("antimicro_" + QLocale::system().name(), QApplication::applicationDirPath().append("\\share\\antimicro\\translations")); #endif a.installTranslator(&myappTranslator); if (cmdutility.hasError()) { return 1; } else if (cmdutility.isHelpRequested()) { cmdutility.printHelp(); return 0; } else if (cmdutility.isVersionRequested()) { cmdutility.printVersionString(); return 0; } Q_INIT_RESOURCE(resources); a.setQuitOnLastWindowClosed(false); QDir configDir (PadderCommon::configPath); if (!configDir.exists()) { configDir.mkpath(PadderCommon::configPath); } #ifdef USE_SDL_2 QHash<SDL_JoystickID, InputDevice*> *joysticks = new QHash<SDL_JoystickID, InputDevice*>(); #else QHash<int, InputDevice*> *joysticks = new QHash<int, InputDevice*>(); #endif // Cross-platform way of performing IPC. Currently, // only establish a connection and then disconnect. // In the future, there might be a reason to actually send // messages to the QLocalServer. QLocalSocket socket; socket.connectToServer(PadderCommon::localSocketKey); socket.waitForConnected(1000); if (socket.state() == QLocalSocket::ConnectedState) { // An instance of this program is already running. // Save app config and exit. InputDaemon *joypad_worker = new InputDaemon(joysticks, false); MainWindow w(joysticks, &cmdutility, false); if (!cmdutility.hasError() && cmdutility.hasProfile()) { w.saveAppConfig(); } joypad_worker->quit(); w.removeJoyTabs(); socket.disconnectFromServer(); #ifdef USE_SDL_2 QHashIterator<SDL_JoystickID, InputDevice*> iter(*joysticks); #else QHashIterator<int, InputDevice*> iter(*joysticks); #endif while (iter.hasNext()) { InputDevice *joystick = iter.next().value(); if (joystick) { delete joystick; joystick = 0; } } joysticks->clear(); delete joysticks; joysticks = 0; delete joypad_worker; joypad_worker = 0; return 0; } InputDaemon *joypad_worker = new InputDaemon (joysticks); MainWindow w(joysticks, &cmdutility); w.startLocalServer(); #ifdef USE_SDL_2 QObject::connect(joypad_worker, SIGNAL(joysticksRefreshed(QHash<SDL_JoystickID, InputDevice*>*)), &w, SLOT(fillButtons(QHash<SDL_JoystickID, InputDevice*>*))); #else QObject::connect(joypad_worker, SIGNAL(joysticksRefreshed(QHash<int, InputDevice*>*)), &w, SLOT(fillButtons(QHash<int, InputDevice*>*))); #endif QObject::connect(&w, SIGNAL(joystickRefreshRequested()), joypad_worker, SLOT(refresh())); QObject::connect(joypad_worker, SIGNAL(joystickRefreshed(InputDevice*)), &w, SLOT(fillButtons(InputDevice*))); QObject::connect(&a, SIGNAL(lastWindowClosed()), &a, SLOT(quit())); QObject::connect(&a, SIGNAL(aboutToQuit()), &w, SLOT(saveAppConfig())); QObject::connect(&a, SIGNAL(aboutToQuit()), &w, SLOT(removeJoyTabs())); QObject::connect(&a, SIGNAL(aboutToQuit()), joypad_worker, SLOT(quit())); #ifdef USE_SDL_2 QObject::connect(&w, SIGNAL(mappingUpdated(QString,InputDevice*)), joypad_worker, SLOT(refreshMapping(QString,InputDevice*))); QObject::connect(joypad_worker, SIGNAL(deviceUpdated(int,InputDevice*)), &w, SLOT(testMappingUpdateNow(int,InputDevice*))); QObject::connect(joypad_worker, SIGNAL(deviceRemoved(SDL_JoystickID)), &w, SLOT(removeJoyTab(SDL_JoystickID))); QObject::connect(joypad_worker, SIGNAL(deviceAdded(InputDevice*)), &w, SLOT(addJoyTab(InputDevice*))); #endif /*if (!cmdutility.isHiddenRequested() && (!cmdutility.isLaunchInTrayEnabled() || !QSystemTrayIcon::isSystemTrayAvailable())) { w.show(); }*/ int app_result = a.exec(); #ifdef USE_SDL_2 QHashIterator<SDL_JoystickID, InputDevice*> iter(*joysticks); #else QHashIterator<int, InputDevice*> iter(*joysticks); #endif while (iter.hasNext()) { InputDevice *joystick = iter.next().value(); if (joystick) { delete joystick; joystick = 0; } } joysticks->clear(); delete joysticks; joysticks = 0; delete joypad_worker; joypad_worker = 0; return app_result; }
std::vector<boost::function1<Real, Array> > LsmBasisSystem::multiPathBasisSystem(Size dim, Size order, PolynomType polynomType) { const std::vector<boost::function1<Real, Real> > b = pathBasisSystem(order, polynomType); std::vector<boost::function1<Real, Array> > ret; ret.push_back(bind(constant<Real, Real>(1.0), bind(f_workaround, _1, 0, dim))); for (Size i=1; i<=order; ++i) { const std::vector<boost::function1<Real, Array> > a = w(dim, i, polynomType, b); for (std::vector<boost::function1<Real, Array> >::const_iterator iter = a.begin(); iter < a.end(); ++iter) { ret.push_back(*iter); } } // remove-o-zap: now remove redundant functions. // usually we do have a lot of them due to the construction schema. // We use a more "hands on" method here. std::deque<bool> rm(ret.size(), true); Array x(dim), v(ret.size()); MersenneTwisterUniformRng rng(1234UL); for (Size i=0; i<10; ++i) { Size k; // calculate random x vector for (k=0; k<dim; ++k) { x[k] = rng.next().value; } // get return values for all basis functions for (k=0; k<ret.size(); ++k) { v[k] = ret[k](x); } // find duplicates for (k=0; k<ret.size(); ++k) { if (std::find_if(v.begin(), v.end(), bind(equal_within<Real>(10*v[k]*QL_EPSILON), v[k], _1) ) == v.begin() + k) { // don't remove this item, it's unique! rm[k] = false; } } } std::vector<boost::function1<Real, Array> >::iterator iter = ret.begin(); for (Size i=0; i < rm.size(); ++i) { if (rm[i]) { iter = ret.erase(iter); } else { ++iter; } } return ret; }
bool link_det_minor( size_t size , size_t repeat , CppAD::vector<double> &matrix , CppAD::vector<double> &gradient ) { // speed test global option values if( global_option["atomic"] ) return false; // ----------------------------------------------------- // setup // object for computing determinant typedef CppAD::AD<double> ADScalar; typedef CppAD::vector<ADScalar> ADVector; CppAD::det_by_minor<ADScalar> Det(size); size_t i; // temporary index size_t m = 1; // number of dependent variables size_t n = size * size; // number of independent variables ADVector A(n); // AD domain space vector ADVector detA(m); // AD range space vector // vectors of reverse mode weights CppAD::vector<double> w(1); w[0] = 1.; // the AD function object CppAD::ADFun<double> f; // --------------------------------------------------------------------- if( ! global_option["onetape"] ) while(repeat--) { // choose a matrix CppAD::uniform_01(n, matrix); for( i = 0; i < size * size; i++) A[i] = matrix[i]; // declare independent variables Independent(A); // AD computation of the determinant detA[0] = Det(A); // create function object f : A -> detA f.Dependent(A, detA); if( global_option["optimize"] ) f.optimize(); // skip comparison operators f.compare_change_count(0); // evaluate the determinant at the new matrix value f.Forward(0, matrix); // evaluate and return gradient using reverse mode gradient = f.Reverse(1, w); } else { // choose a matrix CppAD::uniform_01(n, matrix); for( i = 0; i < size * size; i++) A[i] = matrix[i]; // declare independent variables Independent(A); // AD computation of the determinant detA[0] = Det(A); // create function object f : A -> detA f.Dependent(A, detA); if( global_option["optimize"] ) f.optimize(); // skip comparison operators f.compare_change_count(0); // ------------------------------------------------------ while(repeat--) { // get the next matrix CppAD::uniform_01(n, matrix); // evaluate the determinant at the new matrix value f.Forward(0, matrix); // evaluate and return gradient using reverse mode gradient = f.Reverse(1, w); } } return true; }
void Screen::blockMove() { blockMove(Common::Rect(0, 0, w(), h())); }
int Flu_Wrap_Group :: layout( bool sbVisible, bool doScrollTo, int *measure ) { int xx = x()+Fl::box_dx(box()), yy = y()+Fl::box_dy(box()), ww = w()-Fl::box_dw(box()), hh = h()-Fl::box_dh(box()); if( type() == FL_VERTICAL ) { int i, X, Y, maxH, H, col, row, maxW, scrollY; Fl_Widget *c; scrollbar.type( FL_VERTICAL ); BEGIN_H: X = xx+_offset[0]; Y = yy+_offset[1] - (sbVisible ? scrollbar.value() : 0); maxH = _offset[1]; H = 0; col = 0; row = 0; scrollY = 0; maxW = xx + ww - (sbVisible ? scrollbar.w() : 0); for( i = 0; i < group.children(); i++ ) { c = group.child(i); if( !c->visible() ) continue; H = MAX( H, c->h() ); if( col == 0 ) maxH += H + _spacing[1]; if( ( X + c->w() ) > maxW ) { Y += H + _spacing[1]; scrollY += H + _spacing[1]; if( i == group.children()-1 ) maxH += H + _spacing[1]; if( measure ) { if( xx+_offset[0] <= measure[0] && measure[0] <= xx+c->w()+_offset[0]+_spacing[0] && Y <= measure[1] && measure[1] <= Y+c->h()+_spacing[1] ) return i; } else c->position( xx+_offset[0], Y ); col = 0; row++; H = 0; X = xx+c->w() + _offset[0] + _spacing[0]; } else { if( measure ) { if( X <= measure[0] && measure[0] <= X+c->w()+_spacing[0] && Y <= measure[1] && measure[1] <= Y+c->h()+_spacing[1] ) return i; } else c->position( X, Y ); X += c->w() + _spacing[0]; col++; } if( doScrollTo && (c == scrollTo) ) { if( scrollY > scrollbar.maximum() ) scrollY = (int)scrollbar.maximum(); ((Fl_Valuator*)&scrollbar)->value( scrollY ); scrollTo = NULL; goto BEGIN_H; } // if we exceed the height and the scrollbar is not visible, // then it will soon become visible so we don't need to process anymore if( !measure && !sbVisible && maxH > hh ) return 1; } if( measure ) return -1; else if( maxH > hh ) { scrollbar.range( 0, maxH-hh ); scrollbar.slider_size( MAX( float(scrollbar.h()-(maxH-hh))/float(scrollbar.h()), 0.08f ) ); return 1; } else return 0; } else { int i, X, Y, W, maxW, maxH, col, row, scrollX; Fl_Widget *c; scrollbar.type( FL_HORIZONTAL ); BEGIN_W: X = xx+_offset[0] - (sbVisible ? scrollbar.value() : 0); Y = yy+_offset[1]; maxW = _offset[0]; W = 0; col = 0; row = 0; scrollX = 0; maxH = yy + hh - (sbVisible ? scrollbar.h() : 0); for( i = 0; i < group.children(); i++ ) { c = group.child(i); if( !c->visible() ) continue; W = MAX( W, c->w() ); if( row == 0 ) maxW += W + _spacing[0]; if( ( Y + c->h() ) > maxH ) { X += W + _spacing[0]; scrollX += W + _spacing[0]; if( i == group.children()-1 ) maxW += W + _spacing[0]; if( measure ) { if( X <= measure[0] && measure[0] <= X+c->w()+_spacing[0] && yy+_offset[1] <= measure[1] && measure[1] <= yy+c->h()+_offset[1]+_spacing[1] ) return i; } else c->position( X, yy+_offset[1] ); row = 0; col++; W = 0; Y = yy+c->h() + _offset[1] + _spacing[1]; } else { if( measure ) { if( X <= measure[0] && measure[0] <= X+c->w()+_spacing[0] && Y <= measure[1] && measure[1] <= Y+c->h()+_spacing[1] ) return i; } else c->position( X, Y ); Y += c->h() + _spacing[1]; row++; } if( doScrollTo && (c == scrollTo) ) { if( scrollX > scrollbar.maximum() ) scrollX = (int)scrollbar.maximum(); ((Fl_Valuator*)&scrollbar)->value( scrollX ); scrollTo = NULL; goto BEGIN_W; } // if we exceed the width and the scrollbar is not visible, // then it will soon become visible so we don't need to process anymore if( !measure && !sbVisible && maxW > ww ) return 1; } if( measure ) return -1; else if( maxW > ww ) { scrollbar.range( 0, maxW-ww ); scrollbar.slider_size( MAX( float(scrollbar.w()-(maxW-ww))/float(scrollbar.w()), 0.08f ) ); return 1; } else return 0; } }
void gWaveform::draw() { /* blank canvas */ fl_rectf(x(), y(), w(), h(), COLOR_BG_0); /* draw selection (if any) */ if (selectionA != selectionB) { int a_x = selectionA + x() - BORDER; // - start; int b_x = selectionB + x() - BORDER; // - start; if (a_x < 0) a_x = 0; if (b_x >= w()-1) b_x = w()-1; if (selectionA < selectionB) fl_rectf(a_x+BORDER, y(), b_x-a_x, h(), COLOR_BD_0); else fl_rectf(b_x+BORDER, y(), a_x-b_x, h(), COLOR_BD_0); } /* draw waveform from x1 (offset driven by the scrollbar) to x2 * (width of parent window). We don't draw the entire waveform, * only the visibile part. */ int offset = h() / 2; int zero = y() + offset; // sample zero (-inf dB) int wx1 = abs(x() - ((gWaveTools*)parent())->x()); int wx2 = wx1 + ((gWaveTools*)parent())->w(); if (x()+w() < ((gWaveTools*)parent())->w()) wx2 = x() + w() - BORDER; fl_color(0, 0, 0); for (int i=wx1; i<wx2; i++) { fl_line(i+x(), zero, i+x(), data.sup[i]); fl_line(i+x(), zero, i+x(), data.inf[i]); /* print grid */ for (unsigned k=0; k<grid.points.size; k++) { if (grid.points.at(k) == i) { //gLog("draw grid line at %d\n", i); fl_color(fl_rgb_color(54, 54, 54)); fl_line_style(FL_DASH, 0, NULL); fl_line(i+x(), y(), i+x(), y()+h()); fl_color(0, 0, 0); fl_line_style(FL_SOLID, 0, NULL); break; } } } /* border box */ fl_rect(x(), y(), w(), h(), COLOR_BD_0); /* print chanStart */ int lineX = x()+chanStart+1; if (chanStartLit) fl_color(COLOR_BD_1); else fl_color(COLOR_BD_0); /* vertical line */ fl_line(lineX, y()+1, lineX, y()+h()-2); /* print flag and avoid overflow */ if (lineX+FLAG_WIDTH > w()+x()-2) fl_rectf(lineX, y()+h()-FLAG_HEIGHT-1, w()-lineX+x()-1, FLAG_HEIGHT); else { fl_rectf(lineX, y()+h()-FLAG_HEIGHT-1, FLAG_WIDTH, FLAG_HEIGHT); fl_color(255, 255, 255); fl_draw("s", lineX+4, y()+h()-3); } /* print chanEnd */ lineX = x()+chanEnd; if (chanEndLit) fl_color(COLOR_BD_1); else fl_color(COLOR_BD_0); fl_line(lineX, y()+1, lineX, y()+h()-2); if (lineX-FLAG_WIDTH < x()) fl_rectf(x()+1, y()+1, lineX-x(), FLAG_HEIGHT); else { fl_rectf(lineX-FLAG_WIDTH, y()+1, FLAG_WIDTH, FLAG_HEIGHT); fl_color(255, 255, 255); fl_draw("e", lineX-10, y()+10); } }
void ClpLsqr::do_lsqr(CoinDenseVector< double > &b, double damp, double atol, double btol, double conlim, int itnlim, bool show, Info info, CoinDenseVector< double > &x, int *istop, int *itn, Outfo *outfo, bool precon, CoinDenseVector< double > &Pr) { /** Special version of LSQR for use with pdco.m. It continues with a reduced atol if a pdco-specific test isn't satisfied with the input atol. */ // Initialize. static char term_msg[8][80] = { "The exact solution is x = 0", "The residual Ax - b is small enough, given ATOL and BTOL", "The least squares error is small enough, given ATOL", "The estimated condition number has exceeded CONLIM", "The residual Ax - b is small enough, given machine precision", "The least squares error is small enough, given machine precision", "The estimated condition number has exceeded machine precision", "The iteration limit has been reached" }; // printf("***************** Entering LSQR *************\n"); assert(model_); char str1[100], str2[100], str3[100], str4[100], head1[100], head2[100]; int n = ncols_; // set m,n from lsqr object *itn = 0; *istop = 0; double ctol = 0; if (conlim > 0) ctol = 1 / conlim; double anorm = 0; double acond = 0; double ddnorm = 0; double xnorm = 0; double xxnorm = 0; double z = 0; double cs2 = -1; double sn2 = 0; // Set up the first vectors u and v for the bidiagonalization. // These satisfy beta*u = b, alfa*v = A'u. CoinDenseVector< double > u(b); CoinDenseVector< double > v(n, 0.0); x.clear(); double alfa = 0; double beta = u.twoNorm(); if (beta > 0) { u = (1 / beta) * u; matVecMult(2, v, u); if (precon) v = v * Pr; alfa = v.twoNorm(); } if (alfa > 0) { v.scale(1 / alfa); } CoinDenseVector< double > w(v); double arnorm = alfa * beta; if (arnorm == 0) { printf(" %s\n\n", term_msg[0]); return; } double rhobar = alfa; double phibar = beta; double bnorm = beta; double rnorm = beta; sprintf(head1, " Itn x(1) Function"); sprintf(head2, " Compatible LS Norm A Cond A"); if (show) { printf(" %s%s\n", head1, head2); double test1 = 1; double test2 = alfa / beta; sprintf(str1, "%6d %12.5e %10.3e", *itn, x[0], rnorm); sprintf(str2, " %8.1e %8.1e", test1, test2); printf("%s%s\n", str1, str2); } //---------------------------------------------------------------- // Main iteration loop. //---------------------------------------------------------------- while (*itn < itnlim) { *itn += 1; // Perform the next step of the bidiagonalization to obtain the // next beta, u, alfa, v. These satisfy the relations // beta*u = a*v - alfa*u, // alfa*v = A'*u - beta*v. u.scale((-alfa)); if (precon) { CoinDenseVector< double > pv(v * Pr); matVecMult(1, u, pv); } else { matVecMult(1, u, v); } beta = u.twoNorm(); if (beta > 0) { u.scale((1 / beta)); anorm = sqrt(anorm * anorm + alfa * alfa + beta * beta + damp * damp); v.scale((-beta)); CoinDenseVector< double > vv(n); vv.clear(); matVecMult(2, vv, u); if (precon) vv = vv * Pr; v = v + vv; alfa = v.twoNorm(); if (alfa > 0) v.scale((1 / alfa)); } // Use a plane rotation to eliminate the damping parameter. // This alters the diagonal (rhobar) of the lower-bidiagonal matrix. double rhobar1 = sqrt(rhobar * rhobar + damp * damp); double cs1 = rhobar / rhobar1; double sn1 = damp / rhobar1; double psi = sn1 * phibar; phibar *= cs1; // Use a plane rotation to eliminate the subdiagonal element (beta) // of the lower-bidiagonal matrix, giving an upper-bidiagonal matrix. double rho = sqrt(rhobar1 * rhobar1 + beta * beta); double cs = rhobar1 / rho; double sn = beta / rho; double theta = sn * alfa; rhobar = -cs * alfa; double phi = cs * phibar; phibar = sn * phibar; double tau = sn * phi; // Update x and w. double t1 = phi / rho; double t2 = -theta / rho; // dk = ((1/rho)*w); double w_norm = w.twoNorm(); x = x + t1 * w; w = v + t2 * w; ddnorm = ddnorm + (w_norm / rho) * (w_norm / rho); // if wantvar, var = var + dk.*dk; end // Use a plane rotation on the right to eliminate the // super-diagonal element (theta) of the upper-bidiagonal matrix. // Then use the result to estimate norm(x). double delta = sn2 * rho; double gambar = -cs2 * rho; double rhs = phi - delta * z; double zbar = rhs / gambar; xnorm = sqrt(xxnorm + zbar * zbar); double gamma = sqrt(gambar * gambar + theta * theta); cs2 = gambar / gamma; sn2 = theta / gamma; z = rhs / gamma; xxnorm = xxnorm + z * z; // Test for convergence. // First, estimate the condition of the matrix Abar, // and the norms of rbar and Abar'rbar. acond = anorm * sqrt(ddnorm); double res1 = phibar * phibar; double res2 = res1 + psi * psi; rnorm = sqrt(res1 + res2); arnorm = alfa * fabs(tau); // Now use these norms to estimate certain other quantities, // some of which will be small near a solution. double test1 = rnorm / bnorm; double test2 = arnorm / (anorm * rnorm); double test3 = 1 / acond; t1 = test1 / (1 + anorm * xnorm / bnorm); double rtol = btol + atol * anorm * xnorm / bnorm; // The following tests guard against extremely small values of // atol, btol or ctol. (The user may have set any or all of // the parameters atol, btol, conlim to 0.) // The effect is equivalent to the normal tests using // atol = eps, btol = eps, conlim = 1/eps. if (*itn >= itnlim) *istop = 7; if (1 + test3 <= 1) *istop = 6; if (1 + test2 <= 1) *istop = 5; if (1 + t1 <= 1) *istop = 4; // Allow for tolerances set by the user. if (test3 <= ctol) *istop = 3; if (test2 <= atol) *istop = 2; if (test1 <= rtol) *istop = 1; //------------------------------------------------------------------- // SPECIAL TEST THAT DEPENDS ON pdco.m. // Aname in pdco is iw in lsqr. // dy is x // Other stuff is in info. // We allow for diagonal preconditioning in pdDDD3. //------------------------------------------------------------------- if (*istop > 0) { double r3new = arnorm; double r3ratio = r3new / info.r3norm; double atolold = atol; double atolnew = atol; if (atol > info.atolmin) { if (r3ratio <= 0.1) { // dy seems good // Relax } else if (r3ratio <= 0.5) { // Accept dy but make next one more accurate. atolnew = atolnew * 0.1; } else { // Recompute dy more accurately if (show) { printf("\n "); printf(" \n"); printf(" %5.1f%7d%7.3f", log10(atolold), *itn, r3ratio); } atol = atol * 0.1; atolnew = atol; *istop = 0; } outfo->atolold = atolold; outfo->atolnew = atolnew; outfo->r3ratio = r3ratio; } //------------------------------------------------------------------- // See if it is time to print something. //------------------------------------------------------------------- int prnt = 0; if (n <= 40) prnt = 1; if (*itn <= 10) prnt = 1; if (*itn >= itnlim - 10) prnt = 1; if (*itn % 10 == 0) prnt = 1; if (test3 <= 2 * ctol) prnt = 1; if (test2 <= 10 * atol) prnt = 1; if (test1 <= 10 * rtol) prnt = 1; if (*istop != 0) prnt = 1; if (prnt == 1) { if (show) { sprintf(str1, " %6d %12.5e %10.3e", *itn, x[0], rnorm); sprintf(str2, " %8.1e %8.1e", test1, test2); sprintf(str3, " %8.1e %8.1e", anorm, acond); printf("%s%s%s\n", str1, str2, str3); } } if (*istop > 0) break; } } // End of iteration loop. // Print the stopping condition. if (show) { printf("\n LSQR finished\n"); // disp(msg(istop+1,:)) // disp(' ') printf("%s\n", term_msg[*istop]); sprintf(str1, "istop =%8d itn =%8d", *istop, *itn); sprintf(str2, "anorm =%8.1e acond =%8.1e", anorm, acond); sprintf(str3, "rnorm =%8.1e arnorm =%8.1e", rnorm, arnorm); sprintf(str4, "bnorm =%8.1e xnorm =%8.1e", bnorm, xnorm); printf("%s %s\n", str1, str2); printf("%s %s\n", str3, str4); } }
void CachedRawResource::didSendData(unsigned long long bytesSent, unsigned long long totalBytesToBeSent) { CachedResourceClientWalker<CachedRawResourceClient> w(m_clients); while (CachedRawResourceClient* c = w.next()) c->dataSent(this, bytesSent, totalBytesToBeSent); }
int main(int argc, char *argv[]) { // Creation des abonnes, des etudiants et des professeurs Abonne john("1839456", "Doe", "John", 23); Abonne nicolas("1630236", "Gagnon", "Nicolas", 8); Abonne martin("1269348", "Tremblay", "Martin", 18); Etudiant harry("1782965", "Potter", "Harry", 21, "Pourdlard"); Etudiant hermione("1876458", "Granger", "Hermione", 20, "Pourdlard"); EtudiantBaccalaureat tony("1865487", "Stark", "Tony", 42); Professeur albus("p878546", "Dumbledore", "Albus", 78, { "Polytechnique", "UdM", "Poudlard" }); // Création des livres et DVD Livre livre1("BD302", "Harry Potter et le prisionier d'Azkaban", 1999, 3, 17, "JK ROWLING", "Science-Fiction"); Livre livre2("QA204", "Calcul a plusieurs variables partie 2", 2011, 3, 1, "Cay HORTSTMANN", "Informatique"); Livre livre3("GA403", "Big C++", 2009, 8, 2, "Cay HORTSTMANN", "Informatique"); Livre livre4("AC409", "Le chateau d'Ortrante", 1764, 16, 2, "Cay HORTSTMANN", "Informatique"); Livre livre5("QA203", "Calcul a plusieurs variables partie 1", 2011, 3, 1, "Cay HORTSTMANN", "Informatique"); Livre livre6("GA404", "Big C++", 2016, 8, 2, "Cay HORTSTMANN", "Informatique"); Dvd dvd1("D8403", "Rush Hour", 1998, 2, 13, "Al", { "Jackie Chan", "Chris Tucker" }); Dvd dvd2("D7203", "Avenger", 2012, 3, 5, "Nick Fury", { "Iron Man", "Thor","Hulk", "Captain America", "Black Window" }); // Creation de la bibliotheque, et ajout des elements Bibliotheque biblio; //Ajout des Abonnes biblio += &john; biblio += &nicolas; biblio += &martin; biblio += &harry; biblio += &tony; biblio += &hermione; biblio += &albus; // Ajout des livres et DVD biblio += &livre1; biblio += &livre2; biblio += &livre3; biblio += &livre4; biblio += &livre5; biblio += &livre6; biblio += &dvd1; biblio += &dvd2; // Creation des objets numeriques et ajout à la bibliotheque LivreNumerique livNum1(FORMAT_EPUB, 1270, "vvv.3Mousquetaire.com", "NUM392", "Les 3 mousquetaires", 1844, 11, 5, "A. Dumas", "Roman"); LivreNumerique livNum2(FORMAT_EPUB, 1270, "vvv.3Mousquetaire.com", "NUM393", "Les 3 mousquetaires 2", 1846, 11, 5, "A. Dumas", "Roman"); biblio += &livNum1; biblio += &livNum2; // Création du vecteur pour effectuer les emprunts vector<pair<string,string> > vecEmp {make_pair("1630236","BD302"), make_pair("1630236","D7203"), make_pair("1782965","AC409"), make_pair("1782965","BD302"), make_pair("1782965","D7203"), make_pair("1782965","QA203"), make_pair("1865487","AC409"), make_pair("1865487","BD302"), make_pair("1865487","D7203"), make_pair("1865487","QA204"), make_pair("1865487","NUM392"), make_pair("p878546","BD302"), make_pair("p878546","D7203"), make_pair("p878546","NUM392")}; // Effectue les emprunts for (size_t i = 0; i < vecEmp.size(); i++) { try { biblio.emprunter(vecEmp[i].first, vecEmp[i].second, 160204); } catch (exception&) {} } QApplication a(argc, argv); MainWindow w(&biblio); w.show(); return a.exec(); }
void speedometer::update(vertex3d & v) { vertex3d diff = v-m_last; float rad; color w((unsigned char)0xff, 0xff, 0xff, 0xff); color b((unsigned char)0x00, 0x00, 0x00, 0xff); float diffx2 = diff.x() * diff.x(); float diffy2 = diff.y() * diff.y(); float diffz2 = diff.z() * diff.z(); float groundspeed = sqrt(diffx2 + diffy2); float airspeed = sqrt(diffx2 + diffy2 + diffz2); airspeed = (unsigned int)(airspeed * 3.6f); /* Erase last speed */ rad = (((float)m_lastvel)/360.0f)*6.283f; m_fb.setcolor(w); for(float r=0; r<20.0f; r++) { float x = 120.0f + (r*cosf(rad)); float y = 160.0f + (r*sinf(rad)); // m_fb.pixel((unsigned int)x,(unsigned int)y); } /* Display */ rad = (((float)airspeed)/360.0f)*6.283f; m_fb.setcolor(b); for(float r=0; r<20.0f; r++) { float x = 120.0f + (r*cosf(rad)); float y = 160.0f + (r*sinf(rad)); // m_fb.pixel((unsigned int)x,(unsigned int)y); } printf("%f\n", airspeed); m_fb.blit(); float vdiff = airspeed - m_lastvel; if((airspeed + (3*vdiff)) > 250) m_sc.play(m_caution); //if((airspeed + (1*vdiff)) > 280) // m_sc.play(m_warning); if((airspeed + (3*vdiff)) < 70) m_sc.play(m_caution); //if((airspeed + (2*vdiff)) < 70); // m_sc.play(m_warning); // if( (airspeed - m_lastvel) > 5 || // (airspeed - m_lastvel) < -5) // m_fb.pixel((unsigned int)airspeed-50, (unsigned int)(diff.z() * -10)); m_lastvel = airspeed; m_last = v; }
bool gWaveform::smaller() { return w() < ((gWaveTools*)parent())->w(); }
/** Loads a weight list specified in powerup.xml. The different position * classes must be loaded in the right order * \param root The root node of powerup.xml * \param class_name The name of the position class to load. * \param position_class The class for which the weights are read. */ void PowerupManager::loadWeights(const XMLNode &root, unsigned int num_karts, const std::string &class_name, PositionClass position_class) { const XMLNode *node = root.getNode(class_name), *node2; std::string s(""), s_multi(""), k; std::string w("w"), w_multi("w-multi"), w_add(""); /** Adds to w the suffixe of the num_karts_class * associated with num_karts */ if(position_class!=POSITION_BATTLE_MODE && position_class!=POSITION_TUTORIAL_MODE) { node2 = root.getNode("range_kart"); k = StringUtils::toString(num_karts); k = "k" + k;//Xml nodes can't start with a number //k now contains XML attributes containing kart number class if(node2) node2->get(k, &w_add); if(!node2) { Log::error("[PowerupManager]","No class of weights found" "for %d karts - probabilities will be incorrect", num_karts); } if(race_manager->isFollowMode()) { w_add = "f"; } if(w_add=="") { w_add = "d";//fallback values Log::warn("[PowerupManager]","powerup.xml do not support" "%d karts - fallback probabilities will be used", num_karts); } w = w + w_add; w_multi = w_multi + w_add; }//w is changed to associate with an arbitrary class of kart numbers if(node) node->get(w, &s ); if(node) node->get(w_multi, &s_multi); if(!node || s=="" || s_multi=="") { Log::error("[PowerupManager]", "No weights found for class '%s'" " - probabilities will be incorrect.", class_name.c_str()); return; } std::vector<std::string> weight_list = StringUtils::split(s+" "+s_multi,' '); std::vector<std::string>::iterator i=weight_list.begin(); while(i!=weight_list.end()) { if(*i=="") { std::vector<std::string>::iterator next=weight_list.erase(i); i=next; } else i++; } // Fill missing entries with 0s while(weight_list.size()<2*(int)POWERUP_LAST) weight_list.push_back(0); if(weight_list.size()!=2*(int)POWERUP_LAST) { Log::error("[PowerupManager]", "Incorrect number of weights found in class '%s':", class_name.c_str()); Log::error("[PowerupManager]", "%d instead of %d - probabilities will be incorrect.", (int)weight_list.size(), (int)POWERUP_LAST); return; } for(unsigned int i=0; i<weight_list.size(); i++) { int w = atoi(weight_list[i].c_str()); m_weights[position_class].push_back(w); } } // loadWeights
void Flu_Wrap_Group :: type( int t ) { _type = t; resize( x(), y(), w(), h() ); }
void check_stdvector_matrix(const MatrixType& m) { int rows = m.rows(); int cols = m.cols(); MatrixType x = MatrixType::Random(rows,cols), y = MatrixType::Random(rows,cols); std::vector<MatrixType,Eigen::aligned_allocator<MatrixType> > v(10, MatrixType(rows,cols)), w(20, y); v[5] = x; w[6] = v[5]; VERIFY_IS_APPROX(w[6], v[5]); v = w; for(int i = 0; i < 20; i++) { VERIFY_IS_APPROX(w[i], v[i]); } v.resize(21); v[20] = x; VERIFY_IS_APPROX(v[20], x); v.resize(22,y); VERIFY_IS_APPROX(v[21], y); v.push_back(x); VERIFY_IS_APPROX(v[22], x); VERIFY((std::size_t)&(v[22]) == (std::size_t)&(v[21]) + sizeof(MatrixType)); // do a lot of push_back such that the vector gets internally resized // (with memory reallocation) MatrixType* ref = &w[0]; for(int i=0; i<30 || ((ref==&w[0]) && i<300); ++i) v.push_back(w[i%w.size()]); for(unsigned int i=23; i<v.size(); ++i) { VERIFY(v[i]==w[(i-23)%w.size()]); } }
std::vector<double> getWeights() const { std::vector<double> w(weights, weights + n_points); return w; }