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