The
RInside
package makes it pretty simple and straightforward to embed
R, the wonderful statistical
programming environment and language, inside of a C++ application. This uses
both the robust embedding API provided by
R itself, and the higher-level
abstractions from our
Rcpp package.
A number of examples are shown on this blog both
here and
here
as well as on the
RInside page;
and the source package actually contains well over a dozen complete examples which cover
anything from simple examples to parallel use via
MPI for parallel computing.
Beginning users sometimes ask about how to use
RInside inside
larger projects. And as I had meant to experiment with embedding inside of
the powerful
Qt framework anyway, I
started to dabble a little. A first result is now in the SVN sources of
RInside.
My starting point was the classic
tkdensity demo that comes with
R itself. It is a good point of departure as Tcl/Tk makes it very
portable---in fact it should run on every platform that runs
R---and quite
expressive. And having followed some of the GUI experiments around
R over
the years, I have also seen various re-implementations using different GUI frameworks. And so I am adding
mine to this body of work:
The problem I addressed first was actual buildability. For the
RInside
examples, Romain and I provide a Makefile that
just works by making
calls to
R itself to learn about flags
for
R,
Rcpp and
RInside such
that all required headers and libraries are found. That is actually
relatively straightforward (and documented in our vignettes) but a little
intimidating at first---which is why a ready-made Makefile is a good thing.
Qt of course uses
qmake
and the
.pro files to encode / resolve dependencies. So task one
was to map what our Makefile does into its variables. Turns out that wasn't all that
hard:
## -*- mode: Makefile; c-indent-level: 4; c-basic-offset: 4; tab-width: 8; -*-
##
## Qt usage example for RInside, inspired by the standard 'density
## sliders' example for other GUI toolkits
##
## Copyright (C) 2011 Dirk Eddelbuettel and Romain Francois
TEMPLATE = app
HEADERS = qtdensity.h
SOURCES = qtdensity.cpp main.cpp
QT += svg
## comment this out if you need a different version of R,
## and set set R_HOME accordingly as an environment variable
R_HOME = $$system(R RHOME)
## include headers and libraries for R
RCPPFLAGS = $$system($$R_HOME/bin/R CMD config --cppflags)
RLDFLAGS = $$system($$R_HOME/bin/R CMD config --ldflags)
RBLAS = $$system($$R_HOME/bin/R CMD config BLAS_LIBS)
RLAPACK = $$system($$R_HOME/bin/R CMD config LAPACK_LIBS)
## if you need to set an rpath to R itself, also uncomment
#RRPATH = -Wl,-rpath,$$R_HOME/lib
## include headers and libraries for Rcpp interface classes
RCPPINCL = $$system($$R_HOME/bin/Rscript -e \'Rcpp:::CxxFlags\(\)\')
RCPPLIBS = $$system($$R_HOME/bin/Rscript -e \'Rcpp:::LdFlags\(\)\')
## for some reason when building with Qt we get this each time
## so we turn unused parameter warnings off
RCPPWARNING = -Wno-unused-parameter
## include headers and libraries for RInside embedding classes
RINSIDEINCL = $$system($$R_HOME/bin/Rscript -e \'RInside:::CxxFlags\(\)\')
RINSIDELIBS = $$system($$R_HOME/bin/Rscript -e \'RInside:::LdFlags\(\)\')
## compiler etc settings used in default make rules
QMAKE_CXXFLAGS += $$RCPPWARNING $$RCPPFLAGS $$RCPPINCL $$RINSIDEINCL
QMAKE_LFLAGS += $$RLDFLAGS $$RBLAS $$RLAPACK $$RCPPLIBS $$RINSIDELIBS
## addition clean targets
QMAKE_CLEAN += qtdensity Makefile
The double dollar signs and escaping of parentheses are a little tedious, but
hey it works and expands the compiler and linker flags such that everything <emjust works="Works">.
The code itself is pretty straightforward too. We instantiate the
RInside object
as well as the main
Qt application
object. We then instantiate a new object of class
QtDensity that
will launch the main widget; it is given a reference to the
RInside object.
// -*- mode: C++; c-indent-level: 4; c-basic-offset: 4; tab-width: 8; -*-
//
// Qt usage example for RInside, inspired by the standard 'density
// sliders' example for other GUI toolkits
//
// Copyright (C) 2011 Dirk Eddelbuettel and Romain Francois
#include <QApplication>
#include "qtdensity.h"
int main(int argc, char *argv[])
RInside R(argc, argv); // create an embedded R instance
QApplication app(argc, argv);
QtDensity qtdensity(R);
return app.exec();
The definition of the main object is pretty simple: a few private variables, and a few
functions to interact with the GUI and get values from the radio buttons,
slider or input field---as well as functions to update the chart or re-draw
the random variables.
// -*- mode: C++; c-indent-level: 4; c-basic-offset: 4; tab-width: 8; -*-
//
// Qt usage example for RInside, inspired by the standard 'density
// sliders' example for other GUI toolkits
//
// Copyright (C) 2011 Dirk Eddelbuettel and Romain Francois
#ifndef QTDENSITY_H
#define QTDENSITY_H
#include <RInside.h>
#include <QMainWindow>
#include <QHBoxLayout>
#include <QSlider>
#include <QSpinBox>
#include <QLabel>
#include <QTemporaryFile>
#include <QSvgWidget>
class QtDensity : public QMainWindow
Q_OBJECT
public:
QtDensity(RInside & R);
private slots:
void getBandwidth(int bw);
void getKernel(int kernel);
void getRandomDataCmd(QString txt);
void runRandomDataCmd(void);
private:
void setupDisplay(void); // standard GUI boilderplate of arranging things
void plot(void); // run a density plot in R and update the
void filterFile(void); // modify the richer SVG produced by R
QSvgWidget *m_svg; // the SVG device
RInside & m_R; // reference to the R instance passed to constructor
QString m_tempfile; // name of file used by R for plots
QString m_svgfile; // another temp file, this time from Qt
int m_bw, m_kernel; // parameters used to estimate the density
QString m_cmd; // random draw command string
;
#endif
Lastly, no big magic in the code either (apart from the standard magic provided
by
RInside). A bit of standard GUI layouting, and
then some functions to pick values from the inputs as well as to compute /
update the output. One issue is worth mentioning. The screenshot and code
show the second version of this little application. I built a first one using
a standard portable network graphics (png) file. That was fine, but not
crisp as png is a pixel format so I went back and
experimented with scalable vector graphics (svg) instead. One can create svg output with
R in a number of ways, one of
which is the
cairoDevice
package by Michael Lawrence (who also wrote
RGtk2 and good
chunks of
Ggobi). Now, it turns out that
Qt displays the so-called
SVG
tiny standard whereas
R creates a fuller SVG format. Some
discussion with Michael reveals that one can modify the svg file suitably (which
is what the function
filterFile below does) and it all works. Well:
almost. There is a bug (and Michael thinks it is the SVG rendering) in which
the density estimate does not get clipped to the plotting region.
// -*- mode: C++; c-indent-level: 4; c-basic-offset: 4; tab-width: 8; -*-
//
// Qt usage example for RInside, inspired by the standard 'density
// sliders' example for other GUI toolkits -- this time with SVG
//
// Copyright (C) 2011 Dirk Eddelbuettel and Romain Francois
#include <QtGui>
#include "qtdensity.h"
QtDensity::QtDensity(RInside & R) : m_R(R)
m_bw = 100; // initial bandwidth, will be scaled by 100 so 1.0
m_kernel = 0; // initial kernel: gaussian
m_cmd = "c(rnorm(100,0,1), rnorm(50,5,1))"; // simple mixture
m_R["bw"] = m_bw; // pass bandwidth to R, and have R compute a temp.file name
m_tempfile = QString::fromStdString(Rcpp::as<std::string>(m_R.parseEval("tfile <- tempfile()")));
m_svgfile = QString::fromStdString(Rcpp::as<std::string>(m_R.parseEval("sfile <- tempfile()")));
m_R.parseEvalQ("library(cairoDevice)");
setupDisplay();
void QtDensity::setupDisplay(void)
QWidget *window = new QWidget;
window->setWindowTitle("Qt and RInside demo: density estimation");
QSpinBox *spinBox = new QSpinBox;
QSlider *slider = new QSlider(Qt::Horizontal);
spinBox->setRange(5, 200);
slider->setRange(5, 200);
QObject::connect(spinBox, SIGNAL(valueChanged(int)), slider, SLOT(setValue(int)));
QObject::connect(slider, SIGNAL(valueChanged(int)), spinBox, SLOT(setValue(int)));
spinBox->setValue(m_bw);
QObject::connect(spinBox, SIGNAL(valueChanged(int)), this, SLOT(getBandwidth(int)));
QLabel *cmdLabel = new QLabel("R command for random data creation");
QLineEdit *cmdEntry = new QLineEdit(m_cmd);
QObject::connect(cmdEntry, SIGNAL(textEdited(QString)), this, SLOT(getRandomDataCmd(QString)));
QObject::connect(cmdEntry, SIGNAL(editingFinished()), this, SLOT(runRandomDataCmd()));
QGroupBox *kernelRadioBox = new QGroupBox("Density Estimation kernel");
QRadioButton *radio1 = new QRadioButton("&Gaussian");
QRadioButton *radio2 = new QRadioButton("&Epanechnikov");
QRadioButton *radio3 = new QRadioButton("&Rectangular");
QRadioButton *radio4 = new QRadioButton("&Triangular");
QRadioButton *radio5 = new QRadioButton("&Cosine");
radio1->setChecked(true);
QVBoxLayout *vbox = new QVBoxLayout;
vbox->addWidget(radio1);
vbox->addWidget(radio2);
vbox->addWidget(radio3);
vbox->addWidget(radio4);
vbox->addWidget(radio5);
kernelRadioBox->setMinimumSize(260,140);
kernelRadioBox->setMaximumSize(260,140);
kernelRadioBox->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
kernelRadioBox->setLayout(vbox);
QButtonGroup *kernelGroup = new QButtonGroup;
kernelGroup->addButton(radio1, 0);
kernelGroup->addButton(radio2, 1);
kernelGroup->addButton(radio3, 2);
kernelGroup->addButton(radio4, 3);
kernelGroup->addButton(radio5, 4);
QObject::connect(kernelGroup, SIGNAL(buttonClicked(int)), this, SLOT(getKernel(int)));
m_svg = new QSvgWidget();
runRandomDataCmd(); // also calls plot()
QGroupBox *estimationBox = new QGroupBox("Density estimation bandwidth (scaled by 100)");
QHBoxLayout *spinners = new QHBoxLayout;
spinners->addWidget(spinBox);
spinners->addWidget(slider);
QVBoxLayout *topright = new QVBoxLayout;
topright->addLayout(spinners);
topright->addWidget(cmdLabel);
topright->addWidget(cmdEntry);
estimationBox->setMinimumSize(360,140);
estimationBox->setMaximumSize(360,140);
estimationBox->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
estimationBox->setLayout(topright);
QHBoxLayout *upperlayout = new QHBoxLayout;
upperlayout->addWidget(kernelRadioBox);
upperlayout->addWidget(estimationBox);
QHBoxLayout *svglayout = new QHBoxLayout;
svglayout->addWidget(m_svg);
QVBoxLayout *outer = new QVBoxLayout;
outer->addLayout(upperlayout);
outer->addLayout(svglayout);
window->setLayout(outer);
window->show();
void QtDensity::plot(void)
const char *kernelstrings[] = "gaussian", "epanechnikov", "rectangular", "triangular", "cosine" ;
m_R["bw"] = m_bw;
m_R["kernel"] = kernelstrings[m_kernel]; // that passes the string to R
std::string cmd1 = "Cairo(width=6,height=6,pointsize=10,surface='svg',filename=tfile); "
"plot(density(y, bw=bw/100, kernel=kernel), xlim=range(y)+c(-2,2), main=\"Kernel: ";
std::string cmd2 = "\"); points(y, rep(0, length(y)), pch=16, col=rgb(0,0,0,1/4)); dev.off()";
std::string cmd = cmd1 + kernelstrings[m_kernel] + cmd2; // stick the selected kernel in the middle
m_R.parseEvalQ(cmd);
filterFile(); // we need to simplify the svg file for display by Qt
m_svg->load(m_svgfile);
void QtDensity::getBandwidth(int bw)
if (bw != m_bw)
m_bw = bw;
plot();
void QtDensity::getKernel(int kernel)
if (kernel != m_kernel)
m_kernel = kernel;
plot();
void QtDensity::getRandomDataCmd(QString txt)
m_cmd = txt;
void QtDensity::runRandomDataCmd(void)
std::string cmd = "y <- " + m_cmd.toStdString();
m_R.parseEvalQ(cmd);
plot(); // after each random draw, update plot with estimate
void QtDensity::filterFile()
// cairoDevice creates richer SVG than Qt can display
// but per Michaele Lawrence, a simple trick is to s/symbol/g/ which we do here
QFile infile(m_tempfile);
infile.open(QFile::ReadOnly);
QFile outfile(m_svgfile);
outfile.open(QFile::WriteOnly QFile::Truncate);
QTextStream in(&infile);
QTextStream out(&outfile);
QRegExp rx1("<symbol");
QRegExp rx2("</symbol");
while (!in.atEnd())
QString line = in.readLine();
line.replace(rx1, "<g"); // so '<symbol' becomes '<g ...'
line.replace(rx2, "</g");// and '</symbol becomes '</g'
out << line << "\n";
infile.close();
outfile.close();
What the little application does is actually somewhat neat for the few
lines. One key features is that the generated data can be specified directly by an
R expression which allows for mixtures
(as shown, and as is the default). With that it easy to see how many points are
needed in the second
hump to make the estimate multi-modal, and
how much of a distance between both centers is needed and so on. Obviously,
the effect of the chosen kernel and bandwidth can also be visualized. And with
the chart the being a support vector graphics display, we can resize and
scale at will and it still looks crisp.
The code (for both the simpler png variant and the svg version shown here) is in the SVN repository for
RInside
and will be in the next release. Special thanks to Michael Lawrence for
patiently working through some svg woes with me over a few emails.
Update: Some typos fixed.
Update 2: Two URLs corrected.
It seems that Project Harmony
has finally taken itself public. From the website:
Warning, this post is COMPANY CONFIDENTIAL, do not spread outside of authorized corporate internal communication channels.
Today Nokia will announce that in order to increase investor confidence and foster brand loyalty all Nokia Symbian phones in the world will receive two free Nokia-themed games.
The first game will be Angry Nokias Nokias have discovered that other phones are taking their market share away and now they are very, very angry! Fling cool and shiny Nokia phone and destroy the competition. Complete all free 30 levels and be first to collect all golden Ovi s by gathering MeeGo and Windows Phone 7 logos in the levels!
The other game that is sure to be an instant hit among true Nokia fans will be the Nokia Ninja you are a humble user and sales people are throwing phones at you all kinds of phones. But beware most of those phones are not Nokias! Use your finger to slice trough the competition, rake up combos and achievements! But be careful you do not want to slice trough a Nokia phone! Only trough instant brand recognition you can rake up truly great scores in this game.
Nokia connecting people.
(P.S. Check the date)
), during my talk at FOSDEM 
So, the first half of my spring challenge is over. I managed to run
the 50km version of 
I'm experimenting with zfs at home, for the moment on top of my md/lvm setup, and I ran out of disk space. Growing the lv is pretty easy:
Proposals for autosigning were floating around for quite some time. The most controversial parts were how we secure the machines that do the building (and in turn: how do we secure the key) and who's going to manage the keyring (because there are multiple teams involved; such discussions can indeed take quite a bit time).
Given that printed paper is fairly durable and unlikely to go suddenly
bad, like hard disks do, this can be used for backups.
I did a quick experiment. I 
A few weeks ago, at work, we were looking for a solution to a tricky printing problem: how to manage, in a centralized infrastructure, a large number of locations, worstations and printers?
One of the consultants working for us came up with a great idea. With only a 20-line patch to CUPS, workstations would be able to find which printers are on the same location. 20 lines of code, instead of a complex virtualisation solution? This is exactly the kind of reasons why we use free software: when there s something wrong, you can fix it. When you need something more, you can code it.
Now, many others could benefit of such an improvement, and we don t want to maintain a forked version of CUPS, so we forwarded it upstream, who looked interested. But upstream now being Apple, they requested a stupid 
Around the first bunch of postings in my 
You know it already, since Debian 6.0 non-free firmware are no longer provided by a standard Debian installation. This will cause some troubles to users who need them. I m thus going to do a small overview on the topic and teach you what you need to know to deal with the problem.
What are firmware and how are they used?
From the user s point of view, a firmware is just some data that is needed by some piece of hardware in order to function properly. The driver for that hardware typically loads the firmware on the device as part of its initialization.
In the Linux kernel, the drivers are all using a standardized interface (request_firmware) to retrieve the firmware before sending it to the device. Thanks to this standardization, it s possible to either embed the firmware in the kernel or to have it request the firmware from user-space when needed.
Debian (like most distributions) has selected the latter option. Thus when the kernel needs a firmware, it sends out a request to user-space. udev is getting the request with the name of the firmware, and in its default configuration (see 
update-initramfs will also generate a similar warning on the terminal: