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.
Mandatory warning: What follows is for testing only, and
insecure (
Today I made a couple of small tweaks to my systems. First of all I updated my 
Today we gathered the representatives of different distributions that are present at GNOME.Asia to discuss what GNOME could do to improve its support for distributions that distribute it, especially in matters of long-term support.
It is kind of sad that there weren t any representatives from Canonical nor Red Hat, but the discussion turned out really interesting and we learned a lot about the packaging habits of each other. Furthermore, there were several concrete leads that were explored, which will lead to proposals from the GNOME foundation to all distributions.
Helping with long-term support
The most widespread GNOME version in the LTS releases that happened recently is 2.30, which is used by Debian squeeze, Ubuntu LTS 10.04, RHEL 6, and Solaris 11. It looks like an accident, but on the other hand:
In one of the corners of what is now know as Europa, there was a rich,
prosperous and beautiful kingdom known as Trist nia. In the past, not
that long ago, it had been a number of smaller kingdoms and
caliphates, all with their own cultures, religions and ways of life. Wars,
and series of marriages of convenience eventually configured what ended up
being the united kingdom of Trist nia. Throughout the years, some of the
unified cultures grew and flourished, while others struggled to survive in
their ever-shrinking areas of influence.
A required introduction
Sometimes, the minor cultures would suffer due to oppression coming
from the delegates of the King, who would ban any expression of these
cultures, as they were seen as a potential threat to the kingdom's
stability and unity. For example, just a few decades before the main
subject of this tale, the predecessor of the incumbent King took power by
force, after crushing everyone who opposed his uprise during a bloody and
hard civil war. His reign was ruthless and he imposed draconian laws
uppon his people: usage and teaching of the minor languages was banned,
and everyone was forced to use the language of the Centr lia region, in
public or private.
After four decades, the majority of the Tristanian people were sick enough
of the situation to consider standing against their fear of the regime and
demand freedom, but repression prevailed until the old general died. His
place was taken by the King's grandson even if the people had expressed,
just before the Great War, that they had had enough kings and demanded a
ruler they could choose directly. Of course, the new King seemed a lot
nicer than who they had been suffering for ages, so when asked if they
accepted the new situation, an overwhelming majority said yes .
However, there was a region, Verd lia, where the majority said no .
Things were actually more complicated. Verdalians formed a traditional,
proud society, and while the years of oppression had undoubtedly weakened
it, they had managed to preserve their very unique culture, language and
traditions healthy. The Verdal language was really weird to the
ears of Centr lians and even other minor cultures of the Kingdom, and
erudites struggled to find its real origins, not being able to reach
plausible conclusions.
Verdanians, as we already know, were a traditional society, living in a
land of deep and poorly connected valleys. Little they knew or cared about
the complicated matters of Centr lia and other regions. What made them
happy was to take care their sheep and cows, keep a good fire in their
living room and, every now and then, enjoy one of their log cutting
contests. The impositions of the former dictator were too much for them,
and some of them started sabotaging, assaulting and killing some of the
dictator's soldiers, agents and officers. This was a huge risk at the
time; getting caught meant death penalty for sure, and at first, even
people from other regions were in favour of these actions. However, this
popular support greatly diminished when the new King took the throne, as
these minority continued with the killings, while most of the people saw
it was no longer justified.
The Royal Ball
One of the very first measures the young King introduced was to organise
the Royal Ball of Trist nia , a major event through which the people of the
different regions would be able to elect their delegates to the Crown.
Every four years, a Great Ball contest would happen in Centr lia, and the
winners would be able to decide by their own on some of the matters that
affected their region. Verdanians would send a few teams of dancers, each
of which came from different towns or areas. Some Verdanian teams were
happy about the King and the new political situation, but other teams
weren't so much. And some others, while being simple non-violent dancers,
were known to be supporters of the violent minority who kept on harassing,
assaulting and even killing in their struggle for freedom of Verd nia .
The Verdanian groups aligned with the different culture of Verd nia
(including those who were said to support the violent) tended to get a lot
more points in the dancing contest, and a majority of the elected delegates
were appointed by them, making it easier to pass laws and edicts that
favoured protection of their ways, traditions and language.
No matter how hard they tried, the dancing groups closer to Centr lia
kept losing to the majority. After many years of dance contests, these
groups used their closeness to the King's court to pass the Ball Law of
Tristanian, that would ban any dancing group which didn't condemn the assaults
and killings that kept happening in Verd nia. The unsurprising result was
that, with less dancing groups participating in the following Royal Ball, the
Verdanian majority was broken and new delegates, friendly of the
Centralian officers, were elected.
Many people who had been in favour of assaults and killings began to
question this strategy, and this political movement's unity started to
break. In the end, the dancers decided to part ways with the violent; they
wanted to dance in the next ball, and to do so, they wrote a letter to the
King, in which they explicitly expressed their rejection of violent ways,
and their embracing of dancing as the only means to drive their political
agenda. An objective reading of the new Ball Law clearly showed that this
was enough: the text only said the requisite for a dancing group was to
disavow all kinds of violence.
This wasn't really expected in Centr lia, so they started to add new
requirements in an attempt to keep this group from the contest: their
decisive majority in Verd nia was at stake.
The Royal Ball was nearing and registrations for the contest would soon
close. The Centralian government first argued that the dancing group
should reject the violence coming from the Verdanian extremists in
particular. The dancers did it. Then they argued that the dancers were the
same people who had been supporting violence in Verd nia for years, and
obviously their violence rejection statement was a lie. The dancers
struggled to find new dancers who had not been involved in past dances.
But it was not enough. They then claimed that this dance group should be
quarantined for four years, until they could prove they really were
serious about their new non-violent ideas.
The dance group made a plea to the Trist nian Supreme Counsel, a group
of sixteen experts in law of the Kingdom, and argued that all of these
draconian requirements were not part of the law that was being enforced by
the King. Their appeal to the elder counselors was in vain, though. They
ruled this dancing group was as criminal as the violent minority they had
once supported, and should by no means take part in the Royal Ball.
As a last, desperate measure, the dancing group reached an agreement
with other Verdanian dancers to join forces. They would adopt a new name
and new dancing costume colours. Many feared this would only end up in the
ban of the other dancing group.
Unfortunately, the end of this story has not been written yet, but it
will be completed very soon. Only time will tell if things continue being very
sad and unfair in Trist nia, or if the dance contest will once again be
impartial, with legitimate results.
Recent attacks against the DNS infrastructure have exposed the limitations of relying on TLS/SSL certificates for securing connections on the Internet.
I just found this out, so I'm posting it, since it might be useful both as a
reminder, and for others to read.
Suppose you have a "classical" 
jrollins and i recently did a bunch of cleanup work on 
We're heading to release candidates for 
Now that I sent an update about my running activities, I have to
report about what I'm doing these weeks in Debian to try keeping a
fair balance for those of you who read this blog through Planet Debian.
Most January was spent in preparing the release of squeeze. Of course,
I didn't work directly on the release, not being involved in the
release team. However, last bits of preparation for Debian Installer
as well as rushing out the last remaining bits of localization work
took most of my time.
After the release of squeeze, time came to resume back some
activities.
First of all, on the l10n front, I resumed the work on "l10n NMUs",
trying to get 